Repository: mdabrowski1990/uds (language: python)

Issue:
Incorrect implementation for aliases
**Describe the bug**
- Enums has unnecessary aliases, e.g. `AbstractUdsPacketType` and `AbstractUdsPacketTypeAlias`.
- There are multiple Aliases for packets containers


**Expected behavior**
Number of Aliases are reduced and they are simplified.


**Screenshots**
![image](https://github.com/mdabrowski1990/uds/assets/51504507/c165d029-0166-4571-ac4f-9460bd03f6c4)

![image](https://github.com/mdabrowski1990/uds/assets/51504507/e4acea0d-5976-4553-9fda-5ea7c4149452)


Discussion / hints:

Fix patch:
diff --git a/uds/can/__init__.py b/uds/can/__init__.py
index 116f88d1..4c011046 100644
--- a/uds/can/__init__.py
+++ b/uds/can/__init__.py
@@ -15,7 +15,7 @@
    - Flow Status
 """
 
-from .addressing_format import CanAddressingFormat, CanAddressingFormatAlias
+from .addressing_format import CanAddressingFormat
 from .abstract_addressing_information import AbstractCanAddressingInformation, PacketAIParamsAlias
 from .normal_addressing_information import Normal11BitCanAddressingInformation, NormalFixedCanAddressingInformation
 from .extended_addressing_information import ExtendedCanAddressingInformation
@@ -25,4 +25,4 @@
 from .single_frame import CanSingleFrameHandler
 from .first_frame import CanFirstFrameHandler
 from .consecutive_frame import CanConsecutiveFrameHandler
-from .flow_control import CanFlowControlHandler, CanFlowStatus, CanFlowStatusAlias, CanSTminTranslator
+from .flow_control import CanFlowControlHandler, CanFlowStatus, CanSTminTranslator
diff --git a/uds/can/abstract_addressing_information.py b/uds/can/abstract_addressing_information.py
index bf60471c..22d5945b 100644
--- a/uds/can/abstract_addressing_information.py
+++ b/uds/can/abstract_addressing_information.py
@@ -6,16 +6,16 @@
 from abc import ABC, abstractmethod
 from copy import deepcopy
 
-from uds.transmission_attributes import AddressingTypeAlias, AddressingType
-from .addressing_format import CanAddressingFormatAlias
+from uds.transmission_attributes import AddressingType
+from .addressing_format import CanAddressingFormat
 from .frame_fields import CanIdHandler
 
 
 class PacketAIParamsAlias(TypedDict):
     """Alias of :ref:`Addressing Information <knowledge-base-n-ai>` parameters of CAN packets stream."""
 
-    addressing_format: CanAddressingFormatAlias
-    addressing_type: AddressingTypeAlias
+    addressing_format: CanAddressingFormat
+    addressing_type: AddressingType
     can_id: int
     target_address: Optional[int]
     source_address: Optional[int]
@@ -69,7 +69,7 @@ def __init__(self,
 
     @property
     @abstractmethod
-    def addressing_format(self) -> CanAddressingFormatAlias:
+    def addressing_format(self) -> CanAddressingFormat:
         """CAN Addressing format used."""
 
     @property
@@ -135,7 +135,7 @@ def tx_packets_functional_ai(self, value: InputAIParamsAlias):
     @classmethod
     @abstractmethod
     def validate_packet_ai(cls,
-                           addressing_type: AddressingTypeAlias,
+                           addressing_type: AddressingType,
                            can_id: Optional[int] = None,
                            target_address: Optional[int] = None,
                            source_address: Optional[int] = None,
diff --git a/uds/can/addressing_format.py b/uds/can/addressing_format.py
index ce6d9d49..d0e674c2 100644
--- a/uds/can/addressing_format.py
+++ b/uds/can/addressing_format.py
@@ -1,8 +1,6 @@
 """Implementation of CAN Addressing Formats."""
 
-__all__ = ["CanAddressingFormat", "CanAddressingFormatAlias"]
-
-from typing import Union
+__all__ = ["CanAddressingFormat"]
 
 from aenum import unique, StrEnum
 
@@ -18,21 +16,17 @@ class CanAddressingFormat(StrEnum, ValidatedEnum):
     :ref:`Network Address Information (N_AI) <knowledge-base-n-ai>` is provided.
     """
 
-    NORMAL_11BIT_ADDRESSING = "Normal 11-bit Addressing"
+    NORMAL_11BIT_ADDRESSING: "CanAddressingFormat" = "Normal 11-bit Addressing"  # type: ignore
     """:ref:`Normal addressing <knowledge-base-can-normal-addressing>` format that uses 11-bit CAN Identifiers."""
-    NORMAL_FIXED_ADDRESSING = "Normal Fixed Addressing"
+    NORMAL_FIXED_ADDRESSING: "CanAddressingFormat" = "Normal Fixed Addressing"  # type: ignore
     """:ref:`Normal fixed addressing <knowledge-base-can-normal-fixed-addressing>` format.
     It is a subformat of :ref:`Normal addressing <knowledge-base-can-normal-addressing>` which uses 29-bit
     CAN Identifiers only."""
-    EXTENDED_ADDRESSING = "Extended Addressing"
+    EXTENDED_ADDRESSING: "CanAddressingFormat" = "Extended Addressing"  # type: ignore
     """:ref:`Extended addressing <knowledge-base-can-extended-addressing>` format."""
-    MIXED_11BIT_ADDRESSING = "Mixed 11-bit Addressing"
+    MIXED_11BIT_ADDRESSING: "CanAddressingFormat" = "Mixed 11-bit Addressing"  # type: ignore
     """:ref:`Mixed addressing with 11-bit CAN ID <knowledge-base-can-mixed-11-bit-addressing>` format.
     It is a subformat of :ref:`mixed addressing <knowledge-base-can-mixed-addressing>`."""
-    MIXED_29BIT_ADDRESSING = "Mixed 29-bit Addressing"
+    MIXED_29BIT_ADDRESSING: "CanAddressingFormat" = "Mixed 29-bit Addressing"  # type: ignore
     """:ref:`Mixed addressing with 29-bit CAN ID <knowledge-base-can-mixed-29-bit-addressing>` format.
     It is a subformat of :ref:`mixed addressing <knowledge-base-can-mixed-addressing>`."""
-
-
-CanAddressingFormatAlias = Union[CanAddressingFormat, str]
-"""Alias that describes :class:`~uds.can.addressing_format.CanAddressingFormat` member."""
diff --git a/uds/can/addressing_information.py b/uds/can/addressing_information.py
index 97b237dd..adfc50fa 100644
--- a/uds/can/addressing_information.py
+++ b/uds/can/addressing_information.py
@@ -8,9 +8,10 @@
 
 from typing import Optional, Dict, TypedDict, Type
 
-from uds.utilities import RawBytes, RawBytesList, validate_raw_byte, validate_raw_bytes, InconsistentArgumentsError
-from uds.transmission_attributes import AddressingTypeAlias
-from .addressing_format import CanAddressingFormat, CanAddressingFormatAlias
+from uds.utilities import InconsistentArgumentsError, \
+    RawBytesAlias, RawBytesListAlias, validate_raw_byte, validate_raw_bytes
+from uds.transmission_attributes import AddressingType
+from .addressing_format import CanAddressingFormat
 from .frame_fields import CanIdHandler
 from .abstract_addressing_information import AbstractCanAddressingInformation, PacketAIParamsAlias
 from .normal_addressing_information import Normal11BitCanAddressingInformation, NormalFixedCanAddressingInformation
@@ -21,7 +22,7 @@
 class CanAddressingInformation:
     """CAN Entity (either server or client) Addressing Information."""
 
-    ADDRESSING_INFORMATION_MAPPING: Dict[CanAddressingFormatAlias, Type[AbstractCanAddressingInformation]] = {
+    ADDRESSING_INFORMATION_MAPPING: Dict[CanAddressingFormat, Type[AbstractCanAddressingInformation]] = {
         CanAddressingFormat.NORMAL_11BIT_ADDRESSING: Normal11BitCanAddressingInformation,
         CanAddressingFormat.NORMAL_FIXED_ADDRESSING: NormalFixedCanAddressingInformation,
         CanAddressingFormat.EXTENDED_ADDRESSING: ExtendedCanAddressingInformation,
@@ -30,7 +31,7 @@ class CanAddressingInformation:
     }
     """Dictionary with CAN Addressing format mapping to Addressing Information handler classes."""
 
-    class DataBatesAIParamsAlias(TypedDict, total=False):
+    class DataBytesAIParamsAlias(TypedDict, total=False):
         """Alias of :ref:`Addressing Information <knowledge-base-n-ai>` parameters encoded in data field."""
 
         target_address: int
@@ -39,13 +40,13 @@ class DataBatesAIParamsAlias(TypedDict, total=False):
     class DecodedAIParamsAlias(TypedDict, total=True):
         """Alias of :ref:`Addressing Information <knowledge-base-n-ai>` parameters encoded in CAN ID and data field."""
 
-        addressing_type: Optional[AddressingTypeAlias]
+        addressing_type: Optional[AddressingType]
         target_address: Optional[int]
         source_address: Optional[int]
         address_extension: Optional[int]
 
     def __new__(cls,  # type: ignore
-                addressing_format: CanAddressingFormatAlias,
+                addressing_format: CanAddressingFormat,
                 rx_physical: AbstractCanAddressingInformation.InputAIParamsAlias,
                 tx_physical: AbstractCanAddressingInformation.InputAIParamsAlias,
                 rx_functional: AbstractCanAddressingInformation.InputAIParamsAlias,
@@ -67,13 +68,12 @@ def __new__(cls,  # type: ignore
 
     @classmethod
     def validate_packet_ai(cls,
-                           addressing_format: CanAddressingFormatAlias,
-                           addressing_type: AddressingTypeAlias,
+                           addressing_format: CanAddressingFormat,
+                           addressing_type: AddressingType,
                            can_id: Optional[int] = None,
                            target_address: Optional[int] = None,
                            source_address: Optional[int] = None,
-                           address_extension: Optional[int] = None
-                           ) -> PacketAIParamsAlias:
+                           address_extension: Optional[int] = None) -> PacketAIParamsAlias:
         """
         Validate Addressing Information parameters of a CAN packet.
 
@@ -95,7 +95,7 @@ def validate_packet_ai(cls,
             address_extension=address_extension)
 
     @classmethod
-    def validate_ai_data_bytes(cls, addressing_format: CanAddressingFormatAlias, ai_data_bytes: RawBytes) -> None:
+    def validate_ai_data_bytes(cls, addressing_format: CanAddressingFormat, ai_data_bytes: RawBytesAlias) -> None:
         """
         Validate Addressing Information stored in CAN data bytes.
 
@@ -115,9 +115,9 @@ def validate_ai_data_bytes(cls, addressing_format: CanAddressingFormatAlias, ai_
 
     @classmethod
     def decode_packet_ai(cls,
-                         addressing_format: CanAddressingFormatAlias,
+                         addressing_format: CanAddressingFormat,
                          can_id: int,
-                         ai_data_bytes: RawBytes) -> DecodedAIParamsAlias:
+                         ai_data_bytes: RawBytesAlias) -> DecodedAIParamsAlias:
         """
         Decode Addressing Information parameters from CAN ID and data bytes.
 
@@ -137,16 +137,17 @@ def decode_packet_ai(cls,
         """
         from_data_bytes = cls.decode_ai_data_bytes(addressing_format=addressing_format, ai_data_bytes=ai_data_bytes)
         from_can_id = CanIdHandler.decode_can_id(addressing_format=addressing_format, can_id=can_id)
-        names = (AbstractCanAddressingInformation.ADDRESSING_TYPE_NAME,
-                 AbstractCanAddressingInformation.TARGET_ADDRESS_NAME,
-                 AbstractCanAddressingInformation.SOURCE_ADDRESS_NAME,
-                 AbstractCanAddressingInformation.ADDRESS_EXTENSION_NAME)
-        return {name: from_data_bytes.get(name, None) or from_can_id.get(name, None) for name in names}  # type: ignore
+        items_names = (AbstractCanAddressingInformation.ADDRESSING_TYPE_NAME,
+                       AbstractCanAddressingInformation.TARGET_ADDRESS_NAME,
+                       AbstractCanAddressingInformation.SOURCE_ADDRESS_NAME,
+                       AbstractCanAddressingInformation.ADDRESS_EXTENSION_NAME)
+        return {name: from_data_bytes.get(name, None) or from_can_id.get(name, None)
+                for name in items_names}  # type: ignore
 
     @classmethod
     def decode_ai_data_bytes(cls,
-                             addressing_format: CanAddressingFormatAlias,
-                             ai_data_bytes: RawBytes) -> DataBatesAIParamsAlias:
+                             addressing_format: CanAddressingFormat,
+                             ai_data_bytes: RawBytesAlias) -> DataBytesAIParamsAlias:
         """
         Decode Addressing Information from CAN data bytes.
 
@@ -175,9 +176,9 @@ def decode_ai_data_bytes(cls,
 
     @classmethod
     def encode_ai_data_bytes(cls,
-                             addressing_format: CanAddressingFormatAlias,
+                             addressing_format: CanAddressingFormat,
                              target_address: Optional[int] = None,
-                             address_extension: Optional[int] = None) -> RawBytesList:
+                             address_extension: Optional[int] = None) -> RawBytesListAlias:
         """
         Generate a list of data bytes that carry Addressing Information.
 
@@ -205,7 +206,7 @@ def encode_ai_data_bytes(cls,
         raise NotImplementedError(f"Missing implementation for: {addressing_format}")
 
     @classmethod
-    def get_ai_data_bytes_number(cls, addressing_format: CanAddressingFormatAlias) -> int:
+    def get_ai_data_bytes_number(cls, addressing_format: CanAddressingFormat) -> int:
         """
         Get number of data bytes that are used to carry Addressing Information.
 
diff --git a/uds/can/consecutive_frame.py b/uds/can/consecutive_frame.py
index a099072b..ce4a02a6 100644
--- a/uds/can/consecutive_frame.py
+++ b/uds/can/consecutive_frame.py
@@ -9,9 +9,9 @@
 
 from typing import Optional
 
-from uds.utilities import RawBytes, RawBytesList, validate_raw_bytes, validate_raw_byte, validate_nibble, \
+from uds.utilities import RawBytesAlias, RawBytesListAlias, validate_raw_bytes, validate_raw_byte, validate_nibble, \
     InconsistentArgumentsError
-from .addressing_format import CanAddressingFormatAlias
+from .addressing_format import CanAddressingFormat
 from .addressing_information import CanAddressingInformation
 from .frame_fields import DEFAULT_FILLER_BYTE, CanDlcHandler
 
@@ -26,13 +26,13 @@ class CanConsecutiveFrameHandler:
 
     @classmethod
     def create_valid_frame_data(cls, *,
-                                addressing_format: CanAddressingFormatAlias,
-                                payload: RawBytes,
+                                addressing_format: CanAddressingFormat,
+                                payload: RawBytesAlias,
                                 sequence_number: int,
                                 dlc: Optional[int] = None,
                                 filler_byte: int = DEFAULT_FILLER_BYTE,
                                 target_address: Optional[int] = None,
-                                address_extension: Optional[int] = None) -> RawBytesList:
+                                address_extension: Optional[int] = None) -> RawBytesListAlias:
         """
         Create a data field of a CAN frame that carries a valid Consecutive Frame packet.
 
@@ -82,13 +82,13 @@ def create_valid_frame_data(cls, *,
 
     @classmethod
     def create_any_frame_data(cls, *,
-                              addressing_format: CanAddressingFormatAlias,
-                              payload: RawBytes,
+                              addressing_format: CanAddressingFormat,
+                              payload: RawBytesAlias,
                               sequence_number: int,
                               dlc: int,
                               filler_byte: int = DEFAULT_FILLER_BYTE,
                               target_address: Optional[int] = None,
-                              address_extension: Optional[int] = None) -> RawBytesList:
+                              address_extension: Optional[int] = None) -> RawBytesListAlias:
         """
         Create a data field of a CAN frame that carries a Consecutive Frame packet.
 
@@ -128,7 +128,7 @@ def create_any_frame_data(cls, *,
         return cf_bytes + data_padding
 
     @classmethod
-    def is_consecutive_frame(cls, addressing_format: CanAddressingFormatAlias, raw_frame_data: RawBytes) -> bool:
+    def is_consecutive_frame(cls, addressing_format: CanAddressingFormat, raw_frame_data: RawBytesAlias) -> bool:
         """
         Check if provided data bytes encodes a Consecutive Frame packet.
 
@@ -145,7 +145,7 @@ def is_consecutive_frame(cls, addressing_format: CanAddressingFormatAlias, raw_f
         return raw_frame_data[ai_bytes_number] >> 4 == cls.CONSECUTIVE_FRAME_N_PCI
 
     @classmethod
-    def decode_payload(cls, addressing_format: CanAddressingFormatAlias, raw_frame_data: RawBytes) -> RawBytesList:
+    def decode_payload(cls, addressing_format: CanAddressingFormat, raw_frame_data: RawBytesAlias) -> RawBytesListAlias:
         """
         Extract diagnostic message payload from Consecutive Frame data bytes.
 
@@ -173,7 +173,7 @@ def decode_payload(cls, addressing_format: CanAddressingFormatAlias, raw_frame_d
         return list(raw_frame_data[ai_bytes_number + cls.SN_BYTES_USED:])
 
     @classmethod
-    def decode_sequence_number(cls, addressing_format: CanAddressingFormatAlias, raw_frame_data: RawBytes) -> int:
+    def decode_sequence_number(cls, addressing_format: CanAddressingFormat, raw_frame_data: RawBytesAlias) -> int:
         """
         Extract a value of Sequence Number from Consecutive Frame data bytes.
 
@@ -195,7 +195,7 @@ def decode_sequence_number(cls, addressing_format: CanAddressingFormatAlias, raw
         return raw_frame_data[ai_bytes_number] & 0xF
 
     @classmethod
-    def get_min_dlc(cls, addressing_format: CanAddressingFormatAlias, payload_length: int = 1) -> int:
+    def get_min_dlc(cls, addressing_format: CanAddressingFormat, payload_length: int = 1) -> int:
         """
         Get the minimum value of a CAN frame DLC to carry a Consecutive Frame packet.
 
@@ -223,7 +223,7 @@ def get_min_dlc(cls, addressing_format: CanAddressingFormatAlias, payload_length
 
     @classmethod
     def get_max_payload_size(cls,
-                             addressing_format: Optional[CanAddressingFormatAlias] = None,
+                             addressing_format: Optional[CanAddressingFormat] = None,
                              dlc: Optional[int] = None) -> int:
         """
         Get the maximum size of a payload that can fit into Consecutive Frame data bytes.
@@ -253,7 +253,7 @@ def get_max_payload_size(cls,
         return output
 
     @classmethod
-    def validate_frame_data(cls, addressing_format: CanAddressingFormatAlias, raw_frame_data: RawBytes) -> None:
+    def validate_frame_data(cls, addressing_format: CanAddressingFormat, raw_frame_data: RawBytesAlias) -> None:
         """
         Validate whether data field of a CAN Packet carries a properly encoded Consecutive Frame.
 
@@ -274,7 +274,7 @@ def validate_frame_data(cls, addressing_format: CanAddressingFormatAlias, raw_fr
             raise InconsistentArgumentsError("Provided `raw_frame_data` does not contain any payload bytes.")
 
     @classmethod
-    def __encode_sn(cls, sequence_number: int) -> RawBytesList:
+    def __encode_sn(cls, sequence_number: int) -> RawBytesListAlias:
         """
         Create Consecutive Frame data bytes with CAN Packet Type and Sequence Number parameters.
 
diff --git a/uds/can/extended_addressing_information.py b/uds/can/extended_addressing_information.py
index 6f70460d..ff51520b 100644
--- a/uds/can/extended_addressing_information.py
+++ b/uds/can/extended_addressing_information.py
@@ -5,8 +5,8 @@
 from typing import Optional
 
 from uds.utilities import InconsistentArgumentsError, UnusedArgumentError, validate_raw_byte
-from uds.transmission_attributes import AddressingType, AddressingTypeAlias
-from .addressing_format import CanAddressingFormat, CanAddressingFormatAlias
+from uds.transmission_attributes import AddressingType
+from .addressing_format import CanAddressingFormat
 from .frame_fields import CanIdHandler
 from .abstract_addressing_information import AbstractCanAddressingInformation, PacketAIParamsAlias
 
@@ -18,18 +18,17 @@ class ExtendedCanAddressingInformation(AbstractCanAddressingInformation):
     """Number of CAN Frame data bytes that are used to carry Addressing Information."""
 
     @property
-    def addressing_format(self) -> CanAddressingFormatAlias:
+    def addressing_format(self) -> CanAddressingFormat:
         """CAN Addressing format used."""
         return CanAddressingFormat.EXTENDED_ADDRESSING
 
     @classmethod
     def validate_packet_ai(cls,
-                           addressing_type: AddressingTypeAlias,
+                           addressing_type: AddressingType,
                            can_id: Optional[int] = None,
                            target_address: Optional[int] = None,
                            source_address: Optional[int] = None,
-                           address_extension: Optional[int] = None
-                           ) -> PacketAIParamsAlias:
+                           address_extension: Optional[int] = None) -> PacketAIParamsAlias:
         """
         Validate Addressing Information parameters of a CAN packet that uses Extended Addressing format.
 
diff --git a/uds/can/first_frame.py b/uds/can/first_frame.py
index f7d546ef..90482f03 100644
--- a/uds/can/first_frame.py
+++ b/uds/can/first_frame.py
@@ -9,9 +9,9 @@
 
 from typing import Optional
 
-from uds.utilities import RawBytes, RawBytesList, int_to_bytes_list, bytes_list_to_int, validate_raw_bytes, \
+from uds.utilities import RawBytesAlias, RawBytesListAlias, int_to_bytes_list, bytes_list_to_int, validate_raw_bytes, \
     InconsistentArgumentsError
-from .addressing_format import CanAddressingFormatAlias
+from .addressing_format import CanAddressingFormat
 from .addressing_information import CanAddressingInformation
 from .frame_fields import CanDlcHandler
 from .single_frame import CanSingleFrameHandler
@@ -36,12 +36,12 @@ class CanFirstFrameHandler:
 
     @classmethod
     def create_valid_frame_data(cls, *,
-                                addressing_format: CanAddressingFormatAlias,
-                                payload: RawBytes,
+                                addressing_format: CanAddressingFormat,
+                                payload: RawBytesAlias,
                                 dlc: int,
                                 ff_dl: int,
                                 target_address: Optional[int] = None,
-                                address_extension: Optional[int] = None) -> RawBytesList:
+                                address_extension: Optional[int] = None) -> RawBytesListAlias:
         """
         Create a data field of a CAN frame that carries a valid First Frame packet.
 
@@ -78,13 +78,13 @@ def create_valid_frame_data(cls, *,
 
     @classmethod
     def create_any_frame_data(cls, *,
-                              addressing_format: CanAddressingFormatAlias,
-                              payload: RawBytes,
+                              addressing_format: CanAddressingFormat,
+                              payload: RawBytesAlias,
                               dlc: int,
                               ff_dl: int,
                               long_ff_dl_format: bool = False,
                               target_address: Optional[int] = None,
-                              address_extension: Optional[int] = None) -> RawBytesList:
+                              address_extension: Optional[int] = None) -> RawBytesListAlias:
         """
         Create a data field of a CAN frame that carries a First Frame packet.
 
@@ -122,7 +122,7 @@ def create_any_frame_data(cls, *,
         return ff_data_bytes
 
     @classmethod
-    def is_first_frame(cls, addressing_format: CanAddressingFormatAlias, raw_frame_data: RawBytes) -> bool:
+    def is_first_frame(cls, addressing_format: CanAddressingFormat, raw_frame_data: RawBytesAlias) -> bool:
         """
         Check if provided data bytes encodes a First Frame packet.
 
@@ -137,7 +137,7 @@ def is_first_frame(cls, addressing_format: CanAddressingFormatAlias, raw_frame_d
         return raw_frame_data[ai_bytes_number] >> 4 == cls.FIRST_FRAME_N_PCI
 
     @classmethod
-    def decode_payload(cls, addressing_format: CanAddressingFormatAlias, raw_frame_data: RawBytes) -> RawBytesList:
+    def decode_payload(cls, addressing_format: CanAddressingFormat, raw_frame_data: RawBytesAlias) -> RawBytesListAlias:
         """
         Extract a value of payload from First Frame data bytes.
 
@@ -156,7 +156,7 @@ def decode_payload(cls, addressing_format: CanAddressingFormatAlias, raw_frame_d
         return list(raw_frame_data[ai_bytes_number + len(ff_dl_data_bytes):])
 
     @classmethod
-    def decode_ff_dl(cls, addressing_format: CanAddressingFormatAlias, raw_frame_data: RawBytes) -> int:
+    def decode_ff_dl(cls, addressing_format: CanAddressingFormat, raw_frame_data: RawBytesAlias) -> int:
         """
         Extract a value of First Frame Data Length from First Frame data bytes.
 
@@ -183,7 +183,7 @@ def decode_ff_dl(cls, addressing_format: CanAddressingFormatAlias, raw_frame_dat
 
     @classmethod
     def get_payload_size(cls,
-                         addressing_format: CanAddressingFormatAlias,
+                         addressing_format: CanAddressingFormat,
                          dlc: int,
                          long_ff_dl_format: bool = False) -> int:
         """
@@ -206,7 +206,7 @@ def get_payload_size(cls,
         return data_bytes_number - ai_data_bytes_number - ff_dl_data_bytes_number
 
     @classmethod
-    def validate_frame_data(cls, addressing_format: CanAddressingFormatAlias, raw_frame_data: RawBytes) -> None:
+    def validate_frame_data(cls, addressing_format: CanAddressingFormat, raw_frame_data: RawBytesAlias) -> None:
         """
         Validate whether data field of a CAN Packet carries a properly encoded First Frame.
 
@@ -234,7 +234,7 @@ def validate_ff_dl(cls,
                        ff_dl: int,
                        long_ff_dl_format: Optional[bool] = None,
                        dlc: Optional[int] = None,
-                       addressing_format: Optional[CanAddressingFormatAlias] = None) -> None:
+                       addressing_format: Optional[CanAddressingFormat] = None) -> None:
         """
         Validate a value of First Frame Data Length.
 
@@ -278,8 +278,8 @@ def validate_ff_dl(cls,
 
     @classmethod
     def __extract_ff_dl_data_bytes(cls,
-                                   addressing_format: CanAddressingFormatAlias,
-                                   raw_frame_data: RawBytes) -> RawBytesList:
+                                   addressing_format: CanAddressingFormat,
+                                   raw_frame_data: RawBytesAlias) -> RawBytesListAlias:
         """
         Extract data bytes that carries CAN Packet Type and First Frame Data Length parameters.
 
@@ -301,7 +301,7 @@ def __extract_ff_dl_data_bytes(cls,
     def __encode_valid_ff_dl(cls,
                              ff_dl: int,
                              dlc: int,
-                             addressing_format: CanAddressingFormatAlias) -> RawBytesList:
+                             addressing_format: CanAddressingFormat) -> RawBytesListAlias:
         """
         Create First Frame data bytes with CAN Packet Type and First Frame Data Length parameters.
 
@@ -319,7 +319,7 @@ def __encode_valid_ff_dl(cls,
         return cls.__encode_any_ff_dl(ff_dl=ff_dl, long_ff_dl_format=ff_dl > cls.MAX_SHORT_FF_DL_VALUE)
 
     @classmethod
-    def __encode_any_ff_dl(cls, ff_dl: int, long_ff_dl_format: bool = False) -> RawBytesList:
+    def __encode_any_ff_dl(cls, ff_dl: int, long_ff_dl_format: bool = False) -> RawBytesListAlias:
         """
         Create First Frame data bytes with CAN Packet Type and First Frame Data Length parameters.
 
diff --git a/uds/can/flow_control.py b/uds/can/flow_control.py
index 27c0ba20..ef6bb6cc 100644
--- a/uds/can/flow_control.py
+++ b/uds/can/flow_control.py
@@ -7,17 +7,16 @@
  - :ref:`Separation Time minimum (STmin) <knowledge-base-can-st-min>`
 """
 
-__all__ = ["CanFlowStatus", "CanFlowStatusAlias", "CanSTminTranslator", "CanFlowControlHandler",
-           "UnrecognizedSTminWarning"]
+__all__ = ["CanFlowStatus", "CanSTminTranslator", "CanFlowControlHandler", "UnrecognizedSTminWarning"]
 
-from typing import Union, Optional, Any
+from typing import Optional, Any
 from warnings import warn
 
 from aenum import unique
 
-from uds.utilities import InconsistentArgumentsError, NibbleEnum, ValidatedEnum, TimeMilliseconds, \
-    RawBytes, RawBytesList, validate_nibble, validate_raw_byte, validate_raw_bytes
-from .addressing_format import CanAddressingFormatAlias
+from uds.utilities import InconsistentArgumentsError, NibbleEnum, ValidatedEnum, TimeMillisecondsAlias, \
+    RawBytesAlias, RawBytesListAlias, validate_nibble, validate_raw_byte, validate_raw_bytes
+from .addressing_format import CanAddressingFormat
 from .addressing_information import CanAddressingInformation
 from .frame_fields import DEFAULT_FILLER_BYTE, CanDlcHandler
 
@@ -42,18 +41,14 @@ class CanFlowStatus(NibbleEnum, ValidatedEnum):
     Consecutive Frames transmission.
     """
 
-    ContinueToSend = 0x0
+    ContinueToSend: "CanFlowStatus" = 0x0  # type: ignore
     """Asks to resume Consecutive Frames transmission."""
-    Wait = 0x1  # noqa: F841
+    Wait: "CanFlowStatus" = 0x1  # type: ignore  # noqa: F841
     """Asks to pause Consecutive Frames transmission."""
-    Overflow = 0x2  # noqa: F841
+    Overflow: "CanFlowStatus" = 0x2  # type: ignore  # noqa: F841
     """Asks to abort transmission of a diagnostic message."""
 
 
-CanFlowStatusAlias = Union[CanFlowStatus, int]
-"""Typing alias that describes :class:`~uds.can.flow_control.CanFlowStatus` member."""
-
-
 class CanSTminTranslator:
     """
     Helper class that provides STmin values mapping.
@@ -62,7 +57,7 @@ class CanSTminTranslator:
     a transmission of two following Consecutive Frames.
     """
 
-    MAX_STMIN_TIME: TimeMilliseconds = 127
+    MAX_STMIN_TIME: TimeMillisecondsAlias = 127
     """Maximal time value (in milliseconds) of STmin."""
 
     MIN_VALUE_MS_RANGE: int = 0
@@ -74,16 +69,16 @@ class CanSTminTranslator:
     """Minimal raw value of STmin in 100 microseconds range."""
     MAX_RAW_VALUE_100US_RANGE: int = 0xF9
     """Maximal raw value of STmin in 100 microseconds range."""
-    MIN_TIME_VALUE_100US_RANGE: TimeMilliseconds = 0.1
+    MIN_TIME_VALUE_100US_RANGE: TimeMillisecondsAlias = 0.1
     """Minimal time value (in milliseconds) of STmin in 100 microseconds range."""
-    MAX_TIME_VALUE_100US_RANGE: TimeMilliseconds = 0.9
+    MAX_TIME_VALUE_100US_RANGE: TimeMillisecondsAlias = 0.9
     """Maximal time value (in milliseconds) of STmin in 100 microseconds range."""
 
     __FLOATING_POINT_ACCURACY: int = 10
     """Accuracy used for floating point values (rounding is necessary due to float operation in python)."""
 
     @classmethod
-    def decode(cls, raw_value: int) -> TimeMilliseconds:
+    def decode(cls, raw_value: int) -> TimeMillisecondsAlias:
         """
         Map raw value of STmin into time value.
 
@@ -104,7 +99,7 @@ def decode(cls, raw_value: int) -> TimeMilliseconds:
         return cls.MAX_STMIN_TIME
 
     @classmethod
-    def encode(cls, time_value: TimeMilliseconds) -> int:
+    def encode(cls, time_value: TimeMillisecondsAlias) -> int:
         """
         Map time value of STmin into raw value.
 
@@ -137,7 +132,7 @@ def is_time_value(cls, value: Any) -> bool:
         return cls._is_ms_value(value) or cls._is_100us_value(value)
 
     @classmethod
-    def _is_ms_value(cls, value: TimeMilliseconds) -> bool:
+    def _is_ms_value(cls, value: TimeMillisecondsAlias) -> bool:
         """
         Check if provided argument is STmin time value in milliseconds.
 
@@ -150,7 +145,7 @@ def _is_ms_value(cls, value: TimeMilliseconds) -> bool:
         return value % 1 == 0
 
     @classmethod
-    def _is_100us_value(cls, value: TimeMilliseconds) -> bool:
+    def _is_100us_value(cls, value: TimeMillisecondsAlias) -> bool:
         """
         Check if provided argument is STmin time value in 100 microseconds.
 
@@ -177,14 +172,14 @@ class CanFlowControlHandler:
 
     @classmethod
     def create_valid_frame_data(cls, *,
-                                addressing_format: CanAddressingFormatAlias,
-                                flow_status: CanFlowStatusAlias,
+                                addressing_format: CanAddressingFormat,
+                                flow_status: CanFlowStatus,
                                 block_size: Optional[int] = None,
                                 st_min: Optional[int] = None,
                                 dlc: Optional[int] = None,
                                 filler_byte: int = DEFAULT_FILLER_BYTE,
                                 target_address: Optional[int] = None,
-                                address_extension: Optional[int] = None) -> RawBytesList:
+                                address_extension: Optional[int] = None) -> RawBytesListAlias:
         """
         Create a data field of a CAN frame that carries a valid Flow Control packet.
 
@@ -236,14 +231,14 @@ def create_valid_frame_data(cls, *,
 
     @classmethod
     def create_any_frame_data(cls, *,
-                              addressing_format: CanAddressingFormatAlias,
-                              flow_status: CanFlowStatusAlias,
+                              addressing_format: CanAddressingFormat,
+                              flow_status: CanFlowStatus,
                               dlc: int,
                               block_size: Optional[int] = None,
                               st_min: Optional[int] = None,
                               filler_byte: int = DEFAULT_FILLER_BYTE,
                               target_address: Optional[int] = None,
-                              address_extension: Optional[int] = None) -> RawBytesList:
+                              address_extension: Optional[int] = None) -> RawBytesListAlias:
         """
         Create a data field of a CAN frame that carries a Flow Control packet.
 
@@ -286,7 +281,7 @@ def create_any_frame_data(cls, *,
         return fc_bytes
 
     @classmethod
-    def is_flow_control(cls, addressing_format: CanAddressingFormatAlias, raw_frame_data: RawBytes) -> bool:
+    def is_flow_control(cls, addressing_format: CanAddressingFormat, raw_frame_data: RawBytesAlias) -> bool:
         """
         Check if provided data bytes encodes a Flow Control packet.
 
@@ -304,8 +299,8 @@ def is_flow_control(cls, addressing_format: CanAddressingFormatAlias, raw_frame_
 
     @classmethod
     def decode_flow_status(cls,
-                           addressing_format: CanAddressingFormatAlias,
-                           raw_frame_data: RawBytes) -> CanFlowStatusAlias:
+                           addressing_format: CanAddressingFormat,
+                           raw_frame_data: RawBytesAlias) -> CanFlowStatus:
         """
         Extract Flow Status value from Flow Control data bytes.
 
@@ -327,7 +322,7 @@ def decode_flow_status(cls,
         return CanFlowStatus(raw_frame_data[ai_bytes_number] & 0xF)
 
     @classmethod
-    def decode_block_size(cls, addressing_format: CanAddressingFormatAlias, raw_frame_data: RawBytes) -> int:
+    def decode_block_size(cls, addressing_format: CanAddressingFormat, raw_frame_data: RawBytesAlias) -> int:
         """
         Extract Block Size value from Flow Control data bytes.
 
@@ -352,7 +347,7 @@ def decode_block_size(cls, addressing_format: CanAddressingFormatAlias, raw_fram
         return raw_frame_data[ai_data_bytes_number + cls.BS_BYTE_POSITION]
 
     @classmethod
-    def decode_st_min(cls, addressing_format: CanAddressingFormatAlias, raw_frame_data: RawBytes) -> int:
+    def decode_st_min(cls, addressing_format: CanAddressingFormat, raw_frame_data: RawBytesAlias) -> int:
         """
         Extract STmin value from Flow Control data bytes.
 
@@ -377,7 +372,7 @@ def decode_st_min(cls, addressing_format: CanAddressingFormatAlias, raw_frame_da
         return raw_frame_data[ai_data_bytes_number + cls.STMIN_BYTE_POSITION]
 
     @classmethod
-    def get_min_dlc(cls, addressing_format: CanAddressingFormatAlias) -> int:
+    def get_min_dlc(cls, addressing_format: CanAddressingFormat) -> int:
         """
         Get the minimum value of a CAN frame DLC to carry a Flow Control packet.
 
@@ -389,7 +384,7 @@ def get_min_dlc(cls, addressing_format: CanAddressingFormatAlias) -> int:
         return CanDlcHandler.get_min_dlc(ai_data_bytes_number + cls.FS_BYTES_USED)
 
     @classmethod
-    def validate_frame_data(cls, addressing_format: CanAddressingFormatAlias, raw_frame_data: RawBytes) -> None:
+    def validate_frame_data(cls, addressing_format: CanAddressingFormat, raw_frame_data: RawBytesAlias) -> None:
         """
         Validate whether data field of a CAN Packet carries a properly encoded Flow Control.
 
@@ -410,10 +405,10 @@ def validate_frame_data(cls, addressing_format: CanAddressingFormatAlias, raw_fr
 
     @classmethod
     def __encode_valid_flow_status(cls,
-                                   flow_status: CanFlowStatusAlias,
+                                   flow_status: CanFlowStatus,
                                    block_size: Optional[int] = None,
                                    st_min: Optional[int] = None,
-                                   filler_byte: int = DEFAULT_FILLER_BYTE) -> RawBytesList:
+                                   filler_byte: int = DEFAULT_FILLER_BYTE) -> RawBytesListAlias:
         """
         Create Flow Control data bytes with CAN Packet Type and Flow Status, Block Size and STmin parameters.
 
@@ -445,7 +440,7 @@ def __encode_valid_flow_status(cls,
     def __encode_any_flow_status(cls,
                                  flow_status: int,
                                  block_size: Optional[int] = None,
-                                 st_min: Optional[int] = None) -> RawBytesList:
+                                 st_min: Optional[int] = None) -> RawBytesListAlias:
         """
         Create Flow Control data bytes with CAN Packet Type and Flow Status, Block Size and STmin parameters.
 
diff --git a/uds/can/frame_fields.py b/uds/can/frame_fields.py
index af468ed8..13c64233 100644
--- a/uds/can/frame_fields.py
+++ b/uds/can/frame_fields.py
@@ -12,9 +12,9 @@
 from typing import Any, Optional, Tuple, Set, TypedDict, Dict
 from bisect import bisect_left
 
-from uds.transmission_attributes import AddressingType, AddressingTypeAlias
+from uds.transmission_attributes import AddressingType
 from uds.utilities import validate_raw_byte
-from .addressing_format import CanAddressingFormat, CanAddressingFormatAlias
+from .addressing_format import CanAddressingFormat
 
 
 DEFAULT_FILLER_BYTE: int = 0xCC
@@ -29,7 +29,7 @@ class CanIdHandler:
 
     CAN Identifier (CAN ID) is a CAN frame field that informs about a sender and a content of CAN frames.
 
-    CAN supports two formats of CAN ID:
+    CAN bus supports two formats of CAN ID:
      - Standard (11-bit Identifier)
      - Extended (29-bit Identifier)
     """
@@ -62,12 +62,12 @@ class CanIdHandler:
     class CanIdAIAlias(TypedDict, total=True):
         """Alias of :ref:`Addressing Information <knowledge-base-n-ai>` that is carried by CAN Identifier."""
 
-        addressing_type: Optional[AddressingTypeAlias]
+        addressing_type: Optional[AddressingType]
         target_address: Optional[int]
         source_address: Optional[int]
 
     @classmethod
-    def decode_can_id(cls, addressing_format: CanAddressingFormatAlias, can_id: int) -> CanIdAIAlias:
+    def decode_can_id(cls, addressing_format: CanAddressingFormat, can_id: int) -> CanIdAIAlias:
         """
         Extract Addressing Information out of CAN ID.
 
@@ -170,7 +170,7 @@ def decode_mixed_addressed_29bit_can_id(cls, can_id: int) -> CanIdAIAlias:
 
     @classmethod
     def encode_normal_fixed_addressed_can_id(cls,
-                                             addressing_type: AddressingTypeAlias,
+                                             addressing_type: AddressingType,
                                              target_address: int,
                                              source_address: int) -> int:
         """
@@ -198,7 +198,7 @@ def encode_normal_fixed_addressed_can_id(cls,
 
     @classmethod
     def encode_mixed_addressed_29bit_can_id(cls,
-                                            addressing_type: AddressingTypeAlias,
+                                            addressing_type: AddressingType,
                                             target_address: int,
                                             source_address: int) -> int:
         """
@@ -227,8 +227,8 @@ def encode_mixed_addressed_29bit_can_id(cls,
     @classmethod
     def is_compatible_can_id(cls,
                              can_id: int,
-                             addressing_format: CanAddressingFormatAlias,
-                             addressing_type: Optional[AddressingTypeAlias] = None) -> bool:
+                             addressing_format: CanAddressingFormat,
+                             addressing_type: Optional[AddressingType] = None) -> bool:
         """
         Check if the provided value of CAN ID is compatible with addressing format used.
 
@@ -271,7 +271,7 @@ def is_normal_11bit_addressed_can_id(cls, can_id: int) -> bool:
     @classmethod
     def is_normal_fixed_addressed_can_id(cls,
                                          can_id: int,
-                                         addressing_type: Optional[AddressingTypeAlias] = None) -> bool:
+                                         addressing_type: Optional[AddressingType] = None) -> bool:
         """
         Check if the provided value of CAN ID is compatible with Normal Fixed Addressing format.
 
@@ -319,7 +319,7 @@ def is_mixed_11bit_addressed_can_id(cls, can_id: int) -> bool:
     @classmethod
     def is_mixed_29bit_addressed_can_id(cls,
                                         can_id: int,
-                                        addressing_type: Optional[AddressingTypeAlias] = None) -> bool:
+                                        addressing_type: Optional[AddressingType] = None) -> bool:
         """
         Check if the provided value of CAN ID is compatible with Mixed 29-bit Addressing format.
 
diff --git a/uds/can/mixed_addressing_information.py b/uds/can/mixed_addressing_information.py
index f346c86c..312eb94f 100644
--- a/uds/can/mixed_addressing_information.py
+++ b/uds/can/mixed_addressing_information.py
@@ -5,8 +5,8 @@
 from typing import Optional
 
 from uds.utilities import InconsistentArgumentsError, UnusedArgumentError, validate_raw_byte
-from uds.transmission_attributes import AddressingType, AddressingTypeAlias
-from .addressing_format import CanAddressingFormat, CanAddressingFormatAlias
+from uds.transmission_attributes import AddressingType
+from .addressing_format import CanAddressingFormat
 from .frame_fields import CanIdHandler
 from .abstract_addressing_information import AbstractCanAddressingInformation, PacketAIParamsAlias
 
@@ -18,18 +18,17 @@ class Mixed11BitCanAddressingInformation(AbstractCanAddressingInformation):
     """Number of CAN Frame data bytes that are used to carry Addressing Information."""
 
     @property
-    def addressing_format(self) -> CanAddressingFormatAlias:
+    def addressing_format(self) -> CanAddressingFormat:
         """CAN Addressing format used."""
         return CanAddressingFormat.MIXED_11BIT_ADDRESSING
 
     @classmethod
     def validate_packet_ai(cls,
-                           addressing_type: AddressingTypeAlias,
+                           addressing_type: AddressingType,
                            can_id: Optional[int] = None,
                            target_address: Optional[int] = None,
                            source_address: Optional[int] = None,
-                           address_extension: Optional[int] = None
-                           ) -> PacketAIParamsAlias:
+                           address_extension: Optional[int] = None) -> PacketAIParamsAlias:
         """
         Validate Addressing Information parameters of a CAN packet that uses Mixed 11-bit Addressing format.
 
@@ -69,18 +68,17 @@ class Mixed29BitCanAddressingInformation(AbstractCanAddressingInformation):
     """Number of CAN Frame data bytes that are used to carry Addressing Information."""
 
     @property
-    def addressing_format(self) -> CanAddressingFormatAlias:
+    def addressing_format(self) -> CanAddressingFormat:
         """CAN Addressing format used."""
         return CanAddressingFormat.MIXED_29BIT_ADDRESSING
 
     @classmethod
     def validate_packet_ai(cls,
-                           addressing_type: AddressingTypeAlias,
+                           addressing_type: AddressingType,
                            can_id: Optional[int] = None,
                            target_address: Optional[int] = None,
                            source_address: Optional[int] = None,
-                           address_extension: Optional[int] = None
-                           ) -> PacketAIParamsAlias:
+                           address_extension: Optional[int] = None) -> PacketAIParamsAlias:
         """
         Validate Addressing Information parameters of a CAN packet that uses Mixed 29-bit Addressing format.
 
diff --git a/uds/can/normal_addressing_information.py b/uds/can/normal_addressing_information.py
index eb029fd9..cb2f1b5a 100644
--- a/uds/can/normal_addressing_information.py
+++ b/uds/can/normal_addressing_information.py
@@ -5,8 +5,8 @@
 from typing import Optional
 
 from uds.utilities import InconsistentArgumentsError, UnusedArgumentError, validate_raw_byte
-from uds.transmission_attributes import AddressingType, AddressingTypeAlias
-from .addressing_format import CanAddressingFormat, CanAddressingFormatAlias
+from uds.transmission_attributes import AddressingType
+from .addressing_format import CanAddressingFormat
 from .frame_fields import CanIdHandler
 from .abstract_addressing_information import AbstractCanAddressingInformation, PacketAIParamsAlias
 
@@ -18,13 +18,13 @@ class Normal11BitCanAddressingInformation(AbstractCanAddressingInformation):
     """Number of CAN Frame data bytes that are used to carry Addressing Information."""
 
     @property
-    def addressing_format(self) -> CanAddressingFormatAlias:
+    def addressing_format(self) -> CanAddressingFormat:
         """CAN Addressing format used."""
         return CanAddressingFormat.NORMAL_11BIT_ADDRESSING
 
     @classmethod
     def validate_packet_ai(cls,
-                           addressing_type: AddressingTypeAlias,
+                           addressing_type: AddressingType,
                            can_id: Optional[int] = None,
                            target_address: Optional[int] = None,
                            source_address: Optional[int] = None,
@@ -68,13 +68,13 @@ class NormalFixedCanAddressingInformation(AbstractCanAddressingInformation):
     """Number of CAN Frame data bytes that are used to carry Addressing Information."""
 
     @property
-    def addressing_format(self) -> CanAddressingFormatAlias:
+    def addressing_format(self) -> CanAddressingFormat:
         """CAN Addressing format used."""
         return CanAddressingFormat.NORMAL_FIXED_ADDRESSING
 
     @classmethod
     def validate_packet_ai(cls,
-                           addressing_type: AddressingTypeAlias,
+                           addressing_type: AddressingType,
                            can_id: Optional[int] = None,
                            target_address: Optional[int] = None,
                            source_address: Optional[int] = None,
diff --git a/uds/can/single_frame.py b/uds/can/single_frame.py
index eeb26947..d7ec5a9e 100644
--- a/uds/can/single_frame.py
+++ b/uds/can/single_frame.py
@@ -9,9 +9,9 @@
 
 from typing import Optional
 
-from uds.utilities import RawBytes, RawBytesList, validate_raw_bytes, validate_raw_byte, validate_nibble, \
+from uds.utilities import RawBytesAlias, RawBytesListAlias, validate_raw_bytes, validate_raw_byte, validate_nibble, \
     InconsistentArgumentsError
-from .addressing_format import CanAddressingFormatAlias
+from .addressing_format import CanAddressingFormat
 from .addressing_information import CanAddressingInformation
 from .frame_fields import DEFAULT_FILLER_BYTE, CanDlcHandler
 
@@ -33,12 +33,12 @@ class CanSingleFrameHandler:
 
     @classmethod
     def create_valid_frame_data(cls, *,
-                                addressing_format: CanAddressingFormatAlias,
-                                payload: RawBytes,
+                                addressing_format: CanAddressingFormat,
+                                payload: RawBytesAlias,
                                 dlc: Optional[int] = None,
                                 filler_byte: int = DEFAULT_FILLER_BYTE,
                                 target_address: Optional[int] = None,
-                                address_extension: Optional[int] = None) -> RawBytesList:
+                                address_extension: Optional[int] = None) -> RawBytesListAlias:
         """
         Create a data field of a CAN frame that carries a valid Single Frame packet.
 
@@ -89,14 +89,14 @@ def create_valid_frame_data(cls, *,
 
     @classmethod
     def create_any_frame_data(cls, *,
-                              addressing_format: CanAddressingFormatAlias,
-                              payload: RawBytes,
+                              addressing_format: CanAddressingFormat,
+                              payload: RawBytesAlias,
                               dlc: int,
                               sf_dl_short: int,
                               sf_dl_long: Optional[int] = None,
                               filler_byte: int = DEFAULT_FILLER_BYTE,
                               target_address: Optional[int] = None,
-                              address_extension: Optional[int] = None) -> RawBytesList:
+                              address_extension: Optional[int] = None) -> RawBytesListAlias:
         """
         Create a data field of a CAN frame that carries a Single Frame packet.
 
@@ -138,7 +138,7 @@ def create_any_frame_data(cls, *,
         return sf_bytes + data_padding
 
     @classmethod
-    def is_single_frame(cls, addressing_format: CanAddressingFormatAlias, raw_frame_data: RawBytes) -> bool:
+    def is_single_frame(cls, addressing_format: CanAddressingFormat, raw_frame_data: RawBytesAlias) -> bool:
         """
         Check if provided data bytes encodes a Single Frame packet.
 
@@ -155,7 +155,7 @@ def is_single_frame(cls, addressing_format: CanAddressingFormatAlias, raw_frame_
         return (raw_frame_data[ai_bytes_number] >> 4) == cls.SINGLE_FRAME_N_PCI
 
     @classmethod
-    def decode_payload(cls, addressing_format: CanAddressingFormatAlias, raw_frame_data: RawBytes) -> RawBytesList:
+    def decode_payload(cls, addressing_format: CanAddressingFormat, raw_frame_data: RawBytesAlias) -> RawBytesListAlias:
         """
         Extract diagnostic message payload from Single Frame data bytes.
 
@@ -175,7 +175,7 @@ def decode_payload(cls, addressing_format: CanAddressingFormatAlias, raw_frame_d
         return list(raw_frame_data[ai_data_bytes_number + sf_dl_bytes_number:][:sf_dl])
 
     @classmethod
-    def decode_sf_dl(cls, addressing_format: CanAddressingFormatAlias, raw_frame_data: RawBytes) -> int:
+    def decode_sf_dl(cls, addressing_format: CanAddressingFormat, raw_frame_data: RawBytesAlias) -> int:
         """
         Extract a value of Single Frame Data Length from Single Frame data bytes.
 
@@ -201,7 +201,7 @@ def decode_sf_dl(cls, addressing_format: CanAddressingFormatAlias, raw_frame_dat
         raise NotImplementedError("Unknown format of Single Frame Data Length was found.")
 
     @classmethod
-    def get_min_dlc(cls, addressing_format: CanAddressingFormatAlias, payload_length: int) -> int:
+    def get_min_dlc(cls, addressing_format: CanAddressingFormat, payload_length: int) -> int:
         """
         Get the minimum value of a CAN frame DLC to carry a Single Frame packet.
 
@@ -221,7 +221,7 @@ def get_min_dlc(cls, addressing_format: CanAddressingFormatAlias, payload_length
 
     @classmethod
     def get_max_payload_size(cls,
-                             addressing_format: Optional[CanAddressingFormatAlias] = None,
+                             addressing_format: Optional[CanAddressingFormat] = None,
                              dlc: Optional[int] = None) -> int:
         """
         Get the maximum size of a payload that can fit into Single Frame data bytes.
@@ -264,7 +264,7 @@ def get_sf_dl_bytes_number(cls, dlc: int) -> int:
         return cls.SHORT_SF_DL_BYTES_USED if dlc <= cls.MAX_DLC_VALUE_SHORT_SF_DL else cls.LONG_SF_DL_BYTES_USED
 
     @classmethod
-    def validate_frame_data(cls, addressing_format: CanAddressingFormatAlias, raw_frame_data: RawBytes) -> None:
+    def validate_frame_data(cls, addressing_format: CanAddressingFormat, raw_frame_data: RawBytesAlias) -> None:
         """
         Validate whether data field of a CAN Packet carries a properly encoded Single Frame.
 
@@ -302,7 +302,7 @@ def validate_frame_data(cls, addressing_format: CanAddressingFormatAlias, raw_fr
     def validate_sf_dl(cls,
                        sf_dl: int,
                        dlc: int,
-                       addressing_format: Optional[CanAddressingFormatAlias] = None) -> None:
+                       addressing_format: Optional[CanAddressingFormat] = None) -> None:
         """
         Validate a value of Single Frame Data Length.
 
@@ -353,8 +353,8 @@ def __validate_payload_length(cls, payload_length: int, ai_data_bytes_number: in
 
     @classmethod
     def __extract_sf_dl_data_bytes(cls,
-                                   addressing_format: CanAddressingFormatAlias,
-                                   raw_frame_data: RawBytes) -> RawBytesList:
+                                   addressing_format: CanAddressingFormat,
+                                   raw_frame_data: RawBytesAlias) -> RawBytesListAlias:
         """
         Extract data bytes that carries CAN Packet Type and Single Frame Data Length parameters.
 
@@ -373,7 +373,7 @@ def __extract_sf_dl_data_bytes(cls,
     def __encode_valid_sf_dl(cls,
                              sf_dl: int,
                              dlc: int,
-                             addressing_format: CanAddressingFormatAlias) -> RawBytesList:
+                             addressing_format: CanAddressingFormat) -> RawBytesListAlias:
         """
         Create Single Frame data bytes with CAN Packet Type and Single Frame Data Length parameters.
 
@@ -391,7 +391,7 @@ def __encode_valid_sf_dl(cls,
         return cls.__encode_any_sf_dl(sf_dl_long=sf_dl)
 
     @classmethod
-    def __encode_any_sf_dl(cls, sf_dl_short: int = 0, sf_dl_long: Optional[int] = None) -> RawBytesList:
+    def __encode_any_sf_dl(cls, sf_dl_short: int = 0, sf_dl_long: Optional[int] = None) -> RawBytesListAlias:
         """
         Create Single Frame data bytes with CAN Packet Type and Single Frame Data Length parameters.
 
diff --git a/uds/message/__init__.py b/uds/message/__init__.py
index 4640f549..d02f900b 100644
--- a/uds/message/__init__.py
+++ b/uds/message/__init__.py
@@ -9,6 +9,6 @@
 """
 
 from .uds_message import AbstractUdsMessageContainer, UdsMessage, UdsMessageRecord
-from .service_identifiers import RequestSID, ResponseSID, POSSIBLE_REQUEST_SIDS, POSSIBLE_RESPONSE_SIDS, \
+from .service_identifiers import RequestSID, ResponseSID, ALL_REQUEST_SIDS, ALL_RESPONSE_SIDS, \
     UnrecognizedSIDWarning
 from .nrc import NRC
diff --git a/uds/message/nrc.py b/uds/message/nrc.py
index f23a85b1..b62bfa1f 100644
--- a/uds/message/nrc.py
+++ b/uds/message/nrc.py
@@ -21,208 +21,208 @@ class NRC(ByteEnum, ValidatedEnum, ExtendableEnum):
     message. NRC informs why a server is not sending a positive response message.
     """
 
-    # PositiveResponse = 0x00
+    # PositiveResponse: "NRC" = 0x00
     # This NRC shall not be used in a negative response message as positiveResponse parameter value is reserved
     # for server internal implementation. Refer to 8.7.5 of ISO 14229-1 for more details.
-    GeneralReject = 0x10  # noqa: F841
+    GeneralReject: "NRC" = 0x10  # type: ignore  # noqa: F841
     """GeneralReject (0x10) NRC indicates that the requested action has been rejected by the server."""
-    ServiceNotSupported = 0x11  # noqa: F841
+    ServiceNotSupported: "NRC" = 0x11  # type: ignore  # noqa: F841
     """ServiceNotSupported (0x11) NRC indicates that the requested action will not be taken because the server does not
     support the requested service."""
-    SubFunctionNotSupported = 0x12  # noqa: F841
+    SubFunctionNotSupported: "NRC" = 0x12  # type: ignore  # noqa: F841
     """SubFunctionNotSupported (0x12) NRC indicates that the requested action will not be taken because the server
     does not support the service specific parameters of the request message."""
-    IncorrectMessageLengthOrInvalidFormat = 0x13  # noqa: F841
+    IncorrectMessageLengthOrInvalidFormat: "NRC" = 0x13  # type: ignore  # noqa: F841
     """IncorrectMessageLengthOrInvalidFormat (0x13) NRC indicates that the requested action will not be taken because
     the length of the received request message does not match the prescribed length for the specified service or
     the format of the parameters do not match the prescribed format for the specified service."""
-    ResponseTooLong = 0x14  # noqa: F841
+    ResponseTooLong: "NRC" = 0x14  # type: ignore  # noqa: F841
     """ResponseTooLong (0x14) NRC shall be reported by the server if the response to be generated exceeds the maximum
     number of bytes available by the underlying network layer. This could occur if the response message exceeds
     the maximum size allowed by the underlying transport protocol or if the response message exceeds the server buffer
     size allocated for that purpose."""
-    BusyRepeatRequest = 0x21  # noqa: F841
+    BusyRepeatRequest: "NRC" = 0x21  # type: ignore  # noqa: F841
     """BusyRepeatRequest (0x21) NRC indicates that the server is temporarily too busy to perform the requested
     operation. In this circumstance the client shall perform repetition of the “identical request message”
     or “another request message”. The repetition of the request shall be delayed by a time specified in the respective
     implementation documents."""
-    ConditionsNotCorrect = 0x22  # noqa: F841
+    ConditionsNotCorrect: "NRC" = 0x22  # type: ignore  # noqa: F841
     """ConditionsNotCorrect (0x22) NRC indicates that the requested action will not be taken because the server
     prerequisite conditions are not met."""
-    RequestSequenceError = 0x24  # noqa: F841
+    RequestSequenceError: "NRC" = 0x24  # type: ignore  # noqa: F841
     """RequestSequenceError (0x24) NRC indicates that the requested action will not be taken because the server
     expects a different sequence of request messages or message as sent by the client. This may occur when sequence
     sensitive requests are issued in the wrong order."""
-    NoResponseFromSubnetComponent = 0x25  # noqa: F841
+    NoResponseFromSubnetComponent: "NRC" = 0x25  # type: ignore  # noqa: F841
     """NoResponseFromSubnetComponent (0x25) NRC indicates that the server has received the request but the requested
     action could not be performed by the server as a subnet component which is necessary to supply the requested
     information did not respond within the specified time."""
-    FailurePreventsExecutionOfRequestedAction = 0x26  # noqa: F841
+    FailurePreventsExecutionOfRequestedAction: "NRC" = 0x26  # type: ignore  # noqa: F841
     """FailurePreventsExecutionOfRequestedAction (0x26) NRC indicates that the requested action will not be taken
     because a failure condition, identified by a DTC (with at least one DTC status bit for TestFailed, Pending,
     Confirmed or TestFailedSinceLastClear set to 1), has occurred and that this failure condition prevents
     the server from performing the requested action."""
-    RequestOutOfRange = 0x31  # noqa: F841
+    RequestOutOfRange: "NRC" = 0x31  # type: ignore  # noqa: F841
     """RequestOutOfRange (0x31) NRC indicates that the requested action will not be taken because the server has
     detected that the request message contains a parameter which attempts to substitute a value beyond its range of
     authority (e.g. attempting to substitute a data byte of 111 when the data is only defined to 100), or which
     attempts to access a DataIdentifier/RoutineIdentifer that is not supported or not supported in active session."""
-    SecurityAccessDenied = 0x33  # noqa: F841
+    SecurityAccessDenied: "NRC" = 0x33  # type: ignore  # noqa: F841
     """SecurityAccessDenied (0x33) NRC indicates that the requested action will not be taken because the server’s
     security strategy has not been satisfied by the client."""
-    AuthenticationRequired = 0x34  # noqa: F841
+    AuthenticationRequired: "NRC" = 0x34  # type: ignore  # noqa: F841
     """AuthenticationRequired (0x34) NRC indicates that the requested service will not be taken because the client
     has insufficient rights based on its Authentication state."""
-    InvalidKey = 0x35  # noqa: F841
+    InvalidKey: "NRC" = 0x35  # type: ignore  # noqa: F841
     """InvalidKey (0x35) NRC indicates that the server has not given security access because the key sent by
     the client did not match with the key in the server’s memory. This counts as an attempt to gain security."""
-    ExceedNumberOfAttempts = 0x36  # noqa: F841
+    ExceedNumberOfAttempts: "NRC" = 0x36  # type: ignore  # noqa: F841
     """ExceedNumberOfAttempts (0x36) NRC indicates that the requested action will not be taken because the client
     has unsuccessfully attempted to gain security access more times than the server’s security strategy will allow."""
-    RequiredTimeDelayNotExpired = 0x37  # noqa: F841
+    RequiredTimeDelayNotExpired: "NRC" = 0x37  # type: ignore  # noqa: F841
     """RequiredTimeDelayNotExpired (0x37) NRC indicates that the requested action will not be taken because
     the client’s latest attempt to gain security access was initiated before the server’s required timeout period had
     elapsed."""
-    SecureDataTransmissionRequired = 0x38  # noqa: F841
+    SecureDataTransmissionRequired: "NRC" = 0x38  # type: ignore  # noqa: F841
     """SecureDataTransmissionRequired (0x38) NRC indicates that the requested service will not be taken because
     the requested action is required to be sent using a secured communication channel."""
-    SecureDataTransmissionNotAllowed = 0x39  # noqa: F841
+    SecureDataTransmissionNotAllowed: "NRC" = 0x39  # type: ignore  # noqa: F841
     """SecureDataTransmissionNotAllowed (0x39) NRC indicates that this message was received using
     the SecuredDataTransmission (SID 0x84) service. However, the requested action is not allowed to be sent using
     the SecuredDataTransmission (0x84) service."""
-    SecureDataVerificationFailed = 0x3A  # noqa: F841
+    SecureDataVerificationFailed: "NRC" = 0x3A  # type: ignore  # noqa: F841
     """SecureDataVerificationFailed (0x3A) NRC indicates that the message failed in the security sub-layer."""
-    CertificateVerificationFailed_InvalidTimePeriod = 0x50  # noqa: F841
+    CertificateVerificationFailed_InvalidTimePeriod: "NRC" = 0x50  # type: ignore  # noqa: F841
     """CertificateVerificationFailed_InvalidTimePeriod (0x50) NRC indicates that date and time of the server does not
     match the validity period of the Certificate."""
-    CertificateVerificationFailed_InvalidSignature = 0x51  # noqa: F841
+    CertificateVerificationFailed_InvalidSignature: "NRC" = 0x51  # type: ignore  # noqa: F841
     """CertificateVerificationFailed_InvalidSignature (0x51) NRC indicates that signature of the Certificate could
     not be verified."""
-    CertificateVerificationFailed_InvalidChainOfTrust = 0x52  # noqa: F841
+    CertificateVerificationFailed_InvalidChainOfTrust: "NRC" = 0x52  # type: ignore  # noqa: F841
     """CertificateVerificationFailed_InvalidChainOfTrust (0x52) NRC indicates that The Certificate could not be
     verified against stored information about the issuing authority."""
-    CertificateVerificationFailed_InvalidType = 0x53  # noqa: F841
+    CertificateVerificationFailed_InvalidType: "NRC" = 0x53  # type: ignore  # noqa: F841
     """CertificateVerificationFailed_InvalidType (0x53) NRC indicates that the Certificate does not match the current
     requested use case."""
-    CertificateVerificationFailed_InvalidFormat = 0x54  # noqa: F841
+    CertificateVerificationFailed_InvalidFormat: "NRC" = 0x54  # type: ignore  # noqa: F841
     """CertificateVerificationFailed_InvalidFormat (0x54) NRC indicates that the Certificate could not be evaluated
     because the format requirement has not been met."""
-    CertificateVerificationFailed_InvalidContent = 0x55  # noqa: F841
+    CertificateVerificationFailed_InvalidContent: "NRC" = 0x55  # type: ignore  # noqa: F841
     """CertificateVerificationFailed_InvalidContent (0x55) NRC indicates that the Certificate could not be verified
     because the content does not match."""
-    CertificateVerificationFailed_InvalidScope = 0x56  # noqa: F841
+    CertificateVerificationFailed_InvalidScope: "NRC" = 0x56  # type: ignore  # noqa: F841
     """CertificateVerificationFailed_InvalidScope (0x56) NRC indicates that the scope of the Certificate does not match
     the contents of the server."""
-    CertificateVerificationFailed_InvalidCertificate = 0x57  # noqa: F841
+    CertificateVerificationFailed_InvalidCertificate: "NRC" = 0x57  # type: ignore  # noqa: F841
     """CertificateVerificationFailed_InvalidCertificate (0x57) NRC indicates that the Certificate received from client
     is invalid, because the server has revoked access for some reason."""
-    OwnershipVerificationFailed = 0x58  # noqa: F841
+    OwnershipVerificationFailed: "NRC" = 0x58  # type: ignore  # noqa: F841
     """OwnershipVerificationFailed (0x58) NRC indicates that delivered Ownership does not match the provided challenge
     or could not verified with the own private key."""
-    ChallengeCalculationFailed = 0x59  # noqa: F841
+    ChallengeCalculationFailed: "NRC" = 0x59  # type: ignore  # noqa: F841
     """ChallengeCalculationFailed (0x59) NRC indicates that the challenge could not be calculated on the server side."""
-    SettingAccessRightsFailed = 0x5A  # noqa: F841
+    SettingAccessRightsFailed: "NRC" = 0x5A  # type: ignore  # noqa: F841
     """SettingAccessRightsFailed (0x5A) NRC indicates that the server could not set the access rights."""
-    SessionKeyCreationOrDerivationFailed = 0x5B  # noqa: F841
+    SessionKeyCreationOrDerivationFailed: "NRC" = 0x5B  # type: ignore  # noqa: F841
     """SessionKeyCreationOrDerivationFailed (0x5B) NRC indicates that the server could not create or derive
     a session key."""
-    ConfigurationDataUsageFailed = 0x5C  # noqa: F841
+    ConfigurationDataUsageFailed: "NRC" = 0x5C  # type: ignore  # noqa: F841
     """ConfigurationDataUsageFailed (0x5C) NRC indicates that the server could not work with the provided
     configuration data."""
-    DeAuthenticationFailed = 0x5D  # noqa: F841
+    DeAuthenticationFailed: "NRC" = 0x5D  # type: ignore  # noqa: F841
     """DeAuthenticationFailed (0x5D) NRC indicates that DeAuthentication was not successful, server could still be
     unprotected."""
-    UploadDownloadNotAccepted = 0x70  # noqa: F841
+    UploadDownloadNotAccepted: "NRC" = 0x70  # type: ignore  # noqa: F841
     """UploadDownloadNotAccepted (0x70) NRC indicates that an attempt to upload/download to a server’s memory cannot
     be accomplished due to some fault conditions."""
-    TransferDataSuspended = 0x71  # noqa: F841
+    TransferDataSuspended: "NRC" = 0x71  # type: ignore  # noqa: F841
     """TransferDataSuspended (0x71) NRC indicates that a data transfer operation was halted due to some fault.
     The active transferData sequence shall be aborted."""
-    GeneralProgrammingFailure = 0x72  # noqa: F841
+    GeneralProgrammingFailure: "NRC" = 0x72  # type: ignore  # noqa: F841
     """GeneralProgrammingFailure (0x72) NRC indicates that the server detected an error when erasing or programming
     a memory location in the permanent memory device (e.g. Flash Memory)."""
-    WrongBlockSequenceCounter = 0x73  # noqa: F841
+    WrongBlockSequenceCounter: "NRC" = 0x73  # type: ignore  # noqa: F841
     """WrongBlockSequenceCounter (0x73) NRC indicates that  the server detected an error in the sequence of
     blockSequenceCounter values. Note that the repetition of a TransferData request message with a blockSequenceCounter
     equal to the one included in the previous TransferData request message shall be accepted by the server."""
-    RequestCorrectlyReceived_ResponsePending = 0x78  # noqa: F841
+    RequestCorrectlyReceived_ResponsePending: "NRC" = 0x78  # type: ignore  # noqa: F841
     """RequestCorrectlyReceived_ResponsePending (0x78) NRC ndicates that the request message was received correctly,
     and that all parameters in the request message were valid (these checks can be delayed until after sending this NRC
     if executing the boot software), but the action to be performed is not yet completed and the server is not yet
     ready to receive another request. As soon as the requested service has been completed, the server shall send
     a positive response message or negative response message with a response code different from this."""
-    SubFunctionNotSupportedInActiveSession = 0x7E  # noqa: F841
+    SubFunctionNotSupportedInActiveSession: "NRC" = 0x7E  # type: ignore  # noqa: F841
     """SubFunctionNotSupportedInActiveSession (0x7E) NRC indicates that the requested action will not be taken because
     the server does not support the requested SubFunction in the session currently active. This NRC shall only be used
     when the requested SubFunction is known to be supported in another session, otherwise response code
     SubFunctionNotSupported shall be used."""
-    ServiceNotSupportedInActiveSession = 0x7F  # noqa: F841
+    ServiceNotSupportedInActiveSession: "NRC" = 0x7F  # type: ignore  # noqa: F841
     """ServiceNotSupportedInActiveSession (0x7F) NRC indicates that the requested action will not be taken because
     the server does not support the requested service in the session currently active. This NRC shall only be used when
     the requested service is known to be supported in another session, otherwise response code serviceNotSupported
     shall be used."""
-    RpmTooHigh = 0x81  # noqa: F841
+    RpmTooHigh: "NRC" = 0x81  # type: ignore  # noqa: F841
     """RpmTooHigh (0x81) NRC indicates that the requested action will not be taken because the server prerequisite
     condition for RPM is not met (current RPM is above a preprogrammed maximum threshold)."""
-    RpmTooLow = 0x82  # noqa: F841
+    RpmTooLow: "NRC" = 0x82  # type: ignore  # noqa: F841
     """RpmTooLow (0x82) NRC indicates that the requested action will not be taken because the server prerequisite
     condition for RPM is not met (current RPM is below a preprogrammed minimum threshold)."""
-    EngineIsRunning = 0x83  # noqa: F841
+    EngineIsRunning: "NRC" = 0x83  # type: ignore  # noqa: F841
     """EngineIsRunning (0x83) NRC is required for those actuator tests which cannot be actuated while the Engine
     is running. This is different from RPM too high negative response, and shall be allowed."""
-    EngineIsNotRunning = 0x84  # noqa: F841
+    EngineIsNotRunning: "NRC" = 0x84  # type: ignore  # noqa: F841
     """EngineIsNotRunning (0x84) NRC is required for those actuator tests which cannot be actuated unless the Engine
     is running. This is different from RPM too low negative response, and shall be allowed."""
-    EngineRunTimeTooLow = 0x85  # noqa: F841
+    EngineRunTimeTooLow: "NRC" = 0x85  # type: ignore  # noqa: F841
     """EngineRunTimeTooLow (0x85)  NRC indicates that the requested action will not be taken because the server
     prerequisite condition for engine run time is not met (current engine run time is below a preprogrammed limit)."""
-    TemperatureTooHigh = 0x86  # noqa: F841
+    TemperatureTooHigh: "NRC" = 0x86  # type: ignore  # noqa: F841
     """TemperatureTooHigh (0x86) NRC indicates that the requested action will not be taken because the serve
     prerequisite condition for temperature is not met (current temperature is above a preprogrammed maximum
     threshold)."""
-    TemperatureTooLow = 0x87  # noqa: F841
+    TemperatureTooLow: "NRC" = 0x87  # type: ignore  # noqa: F841
     """TemperatureTooLow (0x87) NRC indicates that the requested action will not be taken because the server
     prerequisite condition for temperature is not met (current temperature is below a preprogrammed minimum
     threshold)."""
-    VehicleSpeedTooHigh = 0x88  # noqa: F841
+    VehicleSpeedTooHigh: "NRC" = 0x88  # type: ignore  # noqa: F841
     """VehicleSpeedTooHigh (0x88) NRC indicates that the requested action will not be taken because the server
     prerequisite condition for vehicle speed is not met (current VS is above a preprogrammed maximum threshold)."""
-    VehicleSpeedTooLow = 0x89  # noqa: F841
+    VehicleSpeedTooLow: "NRC" = 0x89  # type: ignore  # noqa: F841
     """VehicleSpeedTooLow (0x89) NRC indicates that the requested action will not be taken because the server
     prerequisite condition for vehicle speed is not met (current VS is below a preprogrammed minimum threshold)."""
-    ThrottleOrPedalTooHigh = 0x8A  # noqa: F841
+    ThrottleOrPedalTooHigh: "NRC" = 0x8A  # type: ignore  # noqa: F841
     """ThrottleOrPedalTooHigh (0x8A) NRC indicates that the requested action will not be taken because the server
     prerequisite condition for throttle/pedal position is not met (current throttle/pedal position is above
     a preprogrammed maximum threshold)."""
-    ThrottleOrPedalTooLow = 0x8B  # noqa: F841
+    ThrottleOrPedalTooLow: "NRC" = 0x8B  # type: ignore  # noqa: F841
     """ThrottleOrPedalTooLow (0x8B) NRC indicates that the requested action will not be taken because the server
     prerequisite condition for throttle/pedal position is not met (current throttle/pedal position is below
     a preprogrammed minimum threshold)."""
-    TransmissionRangeNotInNeutral = 0x8C  # noqa: F841
+    TransmissionRangeNotInNeutral: "NRC" = 0x8C  # type: ignore  # noqa: F841
     """TransmissionRangeNotInNeutral (0x8C) NRC indicates that the requested action will not be taken because
     the server prerequisite condition for being in neutral is not met (current transmission range is not in neutral)."""
-    TransmissionRangeNotInGear = 0x8D  # noqa: F841
+    TransmissionRangeNotInGear: "NRC" = 0x8D  # type: ignore  # noqa: F841
     """TransmissionRangeNotInGear (0x8D) NRC indicates that the requested action will not be taken because
     the server prerequisite condition for being in gear is not met (current transmission range is not in gear)."""
-    BrakeSwitchOrSwitchesNotClosed = 0x8F  # noqa: F841
+    BrakeSwitchOrSwitchesNotClosed: "NRC" = 0x8F  # type: ignore  # noqa: F841
     """BrakeSwitchOrSwitchesNotClosed (0x8F) NRC indicates that for safety reasons, this is required for certain
     tests before it begins, and shall be maintained for the entire duration of the test."""
-    ShifterLeverNotInPark = 0x90  # noqa: F841
+    ShifterLeverNotInPark: "NRC" = 0x90  # type: ignore  # noqa: F841
     """ShifterLeverNotInPark (0x90) NRC indicates that for safety reasons, this is required for certain tests before
     it begins, and shall be maintained for the entire duration of the test."""
-    TorqueConvertClutchLocked = 0x91  # noqa: F841
+    TorqueConvertClutchLocked: "NRC" = 0x91  # type: ignore  # noqa: F841
     """TorqueConvertClutchLocked (0x91) RC indicates that the requested action will not be taken because the server
     prerequisite condition for torque converter clutch is not met (current torque converter clutch status above
     a preprogrammed limit or locked)."""
-    VoltageTooHigh = 0x92  # noqa: F841
+    VoltageTooHigh: "NRC" = 0x92  # type: ignore  # noqa: F841
     """VoltageTooHigh (0x92) NRC indicates that the requested action will not be taken because the server prerequisite
     condition for voltage at the primary pin of the server (ECU) is not met (current voltage is above a preprogrammed
     maximum threshold)."""
-    VoltageTooLow = 0x93  # noqa: F841
+    VoltageTooLow: "NRC" = 0x93  # type: ignore  # noqa: F841
     """VoltageTooLow (0x93) NRC indicates that the requested action will not be taken because the server prerequisite
     condition for voltage at the primary pin of the server (ECU) is not met (current voltage is below a preprogrammed
     minimum threshold)."""
-    ResourceTemporarilyNotAvailable = 0x94  # noqa: F841
+    ResourceTemporarilyNotAvailable: "NRC" = 0x94  # type: ignore  # noqa: F841
     """ResourceTemporarilyNotAvailable (0x94) NRC indicates that the server has received the request but the requested
     action could not be performed by the server because an application which is necessary to supply the requested
     information is temporality not available. This NRC is in general supported by each diagnostic service, as not
diff --git a/uds/message/service_identifiers.py b/uds/message/service_identifiers.py
index f76a0873..7ad85123 100644
--- a/uds/message/service_identifiers.py
+++ b/uds/message/service_identifiers.py
@@ -5,13 +5,13 @@
     and SAE J1979 standards.
 """
 
-__all__ = ["RequestSID", "ResponseSID", "POSSIBLE_REQUEST_SIDS", "POSSIBLE_RESPONSE_SIDS", "UnrecognizedSIDWarning"]
+__all__ = ["RequestSID", "ResponseSID", "ALL_REQUEST_SIDS", "ALL_RESPONSE_SIDS", "UnrecognizedSIDWarning"]
 
 from warnings import warn
 
 from aenum import unique
 
-from uds.utilities import RawBytesSet, ByteEnum, ValidatedEnum, ExtendableEnum
+from uds.utilities import RawBytesSetAlias, ByteEnum, ValidatedEnum, ExtendableEnum
 
 # reserved SID values
 _REQUEST_SIDS_DEFINED_BY_SAEJ1979 = set(range(0x01, 0x10))
@@ -20,9 +20,9 @@
 _RESPONSE_SIDS_DEFINED_BY_ISO_14229 = set(range(0x50, 0x80)).union(set(range(0xC3, 0xC9)), set(range(0xFA, 0xFF)))
 
 # all supported SID values according to UDS
-POSSIBLE_REQUEST_SIDS: RawBytesSet = _REQUEST_SIDS_DEFINED_BY_SAEJ1979.union(_REQUEST_SIDS_DEFINED_BY_ISO_14229)
+ALL_REQUEST_SIDS: RawBytesSetAlias = _REQUEST_SIDS_DEFINED_BY_SAEJ1979.union(_REQUEST_SIDS_DEFINED_BY_ISO_14229)
 """Set with all possible values of Request SID data parameter according to SAE J1979 and ISO 14229 standards."""
-POSSIBLE_RESPONSE_SIDS: RawBytesSet = _RESPONSE_SIDS_DEFINED_BY_SAEJ1979.union(_RESPONSE_SIDS_DEFINED_BY_ISO_14229)
+ALL_RESPONSE_SIDS: RawBytesSetAlias = _RESPONSE_SIDS_DEFINED_BY_SAEJ1979.union(_RESPONSE_SIDS_DEFINED_BY_ISO_14229)
 """Set with all possible values of Response SID data parameter according to SAE J1979 and ISO 14229 standards."""
 
 
@@ -58,7 +58,7 @@ def is_request_sid(cls, value: int) -> bool:
 
         :return: True if value is valid SID, else False.
         """
-        if value in POSSIBLE_REQUEST_SIDS:
+        if value in ALL_REQUEST_SIDS:
             if not cls.is_member(value):
                 warn(message=f"SID 0x{value:X} is not recognized by this version of the package.",
                      category=UnrecognizedSIDWarning)
@@ -66,37 +66,37 @@ def is_request_sid(cls, value: int) -> bool:
         return False
 
     # Diagnostic and communication management - more information in ISO 14229-1:2020, chapter 10
-    DiagnosticSessionControl = 0x10  # noqa: F841
-    ECUReset = 0x11  # noqa: F841
-    SecurityAccess = 0x27  # noqa: F841
-    CommunicationControl = 0x28  # noqa: F841
-    Authentication = 0x29  # noqa: F841
-    TesterPresent = 0x3E  # noqa: F841
-    ControlDTCSetting = 0x85  # noqa: F841
-    ResponseOnEvent = 0x86  # noqa: F841
-    LinkControl = 0x87  # noqa: F841
+    DiagnosticSessionControl: "RequestSID" = 0x10  # type: ignore  # noqa: F841
+    ECUReset: "RequestSID" = 0x11  # type: ignore  # noqa: F841
+    SecurityAccess: "RequestSID" = 0x27  # type: ignore  # noqa: F841
+    CommunicationControl: "RequestSID" = 0x28  # type: ignore  # noqa: F841
+    Authentication: "RequestSID" = 0x29  # type: ignore  # noqa: F841
+    TesterPresent: "RequestSID" = 0x3E  # type: ignore  # noqa: F841
+    ControlDTCSetting: "RequestSID" = 0x85  # type: ignore  # noqa: F841
+    ResponseOnEvent: "RequestSID" = 0x86  # type: ignore  # noqa: F841
+    LinkControl: "RequestSID" = 0x87  # type: ignore  # noqa: F841
     # Data transmission - more information in ISO 14229-1:2020, chapter 11
-    ReadDataByIdentifier = 0x22  # noqa: F841
-    ReadMemoryByAddress = 0x23  # noqa: F841
-    ReadScalingDataByIdentifier = 0x24  # noqa: F841
-    ReadDataByPeriodicIdentifier = 0x2A  # noqa: F841
-    DynamicallyDefineDataIdentifier = 0x2C  # noqa: F841
-    WriteDataByIdentifier = 0x2E  # noqa: F841
-    WriteMemoryByAddress = 0x3D  # noqa: F841
+    ReadDataByIdentifier: "RequestSID" = 0x22  # type: ignore  # noqa: F841
+    ReadMemoryByAddress: "RequestSID" = 0x23  # type: ignore  # noqa: F841
+    ReadScalingDataByIdentifier: "RequestSID" = 0x24  # type: ignore  # noqa: F841
+    ReadDataByPeriodicIdentifier: "RequestSID" = 0x2A  # type: ignore  # noqa: F841
+    DynamicallyDefineDataIdentifier: "RequestSID" = 0x2C  # type: ignore  # noqa: F841
+    WriteDataByIdentifier: "RequestSID" = 0x2E  # type: ignore  # noqa: F841
+    WriteMemoryByAddress: "RequestSID" = 0x3D  # type: ignore  # noqa: F841
     # Stored data transmission - more information in ISO 14229-1:2020, chapter 12
-    ClearDiagnosticInformation = 0x14  # noqa: F841
-    ReadDTCInformation = 0x19  # noqa: F841
+    ClearDiagnosticInformation: "RequestSID" = 0x14  # type: ignore  # noqa: F841
+    ReadDTCInformation: "RequestSID" = 0x19  # type: ignore  # noqa: F841
     # InputOutput control - more information in ISO 14229-1:2020, chapter 13
-    InputOutputControlByIdentifier = 0x2F  # noqa: F841
+    InputOutputControlByIdentifier: "RequestSID" = 0x2F  # type: ignore  # noqa: F841
     # Routine - more information in ISO 14229-1:2020, chapter 14
-    RoutineControl = 0x31  # noqa: F841
+    RoutineControl: "RequestSID" = 0x31  # type: ignore  # noqa: F841
     # Upload download - more information in ISO 14229-1:2020, chapter 15
-    RequestDownload = 0x34  # noqa: F841
-    RequestUpload = 0x35  # noqa: F841
-    TransferData = 0x36  # noqa: F841
-    RequestTransferExit = 0x37  # noqa: F841
-    RequestFileTransfer = 0x38  # noqa: F841
-    SecuredDataTransmission = 0x84  # noqa: F841
+    RequestDownload: "RequestSID" = 0x34  # type: ignore  # noqa: F841
+    RequestUpload: "RequestSID" = 0x35  # type: ignore  # noqa: F841
+    TransferData: "RequestSID" = 0x36  # type: ignore  # noqa: F841
+    RequestTransferExit: "RequestSID" = 0x37  # type: ignore  # noqa: F841
+    RequestFileTransfer: "RequestSID" = 0x38  # type: ignore  # noqa: F841
+    SecuredDataTransmission: "RequestSID" = 0x84  # type: ignore  # noqa: F841
 
 
 @unique
@@ -120,14 +120,14 @@ def is_response_sid(cls, value: int) -> bool:
 
         :return: True if value is valid RSID, else False.
         """
-        if value in POSSIBLE_RESPONSE_SIDS:
+        if value in ALL_RESPONSE_SIDS:
             if not cls.is_member(value):
                 warn(message=f"RSID 0x{value:X} is not recognized by this version of the package",
                      category=UnrecognizedSIDWarning)
             return True
         return False
 
-    NegativeResponse = 0x7F  # noqa: F841
+    NegativeResponse: "ResponseSID" = 0x7F  # type: ignore  # noqa: F841
 
 
 # extend 'ResponseSID' with members that were defined in RequestSID
diff --git a/uds/message/uds_message.py b/uds/message/uds_message.py
index 15aa3e0d..62cbe06e 100644
--- a/uds/message/uds_message.py
+++ b/uds/message/uds_message.py
@@ -10,8 +10,8 @@
 from abc import ABC, abstractmethod
 from datetime import datetime
 
-from uds.utilities import RawBytes, RawBytesTuple, RawBytesList, validate_raw_bytes, ReassignmentError
-from uds.transmission_attributes import TransmissionDirectionAlias, AddressingType, AddressingTypeAlias
+from uds.utilities import RawBytesAlias, RawBytesTupleAlias, RawBytesListAlias, validate_raw_bytes, ReassignmentError
+from uds.transmission_attributes import TransmissionDirection, AddressingType
 from uds.packet import AbstractUdsPacketRecord, PacketsRecordsTuple, PacketsRecordsSequence
 
 
@@ -30,12 +30,12 @@ def __eq__(self, other: object) -> bool:
 
     @property
     @abstractmethod
-    def payload(self) -> RawBytesTuple:
+    def payload(self) -> RawBytesTupleAlias:
         """Raw payload bytes carried by this diagnostic message."""
 
     @property
     @abstractmethod
-    def addressing_type(self) -> AddressingTypeAlias:
+    def addressing_type(self) -> AddressingType:
         """Addressing for which this diagnostic message is relevant."""
 
 
@@ -50,7 +50,7 @@ class UdsMessage(AbstractUdsMessageContainer):
     :class:`~uds.message.uds_message.UdsMessageRecord`.
     """
 
-    def __init__(self, payload: RawBytes, addressing_type: AddressingTypeAlias) -> None:
+    def __init__(self, payload: RawBytesAlias, addressing_type: AddressingType) -> None:
         """
         Create a storage for a single diagnostic message.
 
@@ -73,12 +73,12 @@ def __eq__(self, other: object) -> bool:
         return self.addressing_type == other.addressing_type and self.payload == other.payload
 
     @property
-    def payload(self) -> RawBytesTuple:
+    def payload(self) -> RawBytesTupleAlias:
         """Raw payload bytes carried by this diagnostic message."""
         return self.__payload
 
     @payload.setter
-    def payload(self, value: RawBytes):
+    def payload(self, value: RawBytesAlias):
         """
         Set value of raw payload bytes that this diagnostic message carries.
 
@@ -88,19 +88,18 @@ def payload(self, value: RawBytes):
         self.__payload = tuple(value)
 
     @property
-    def addressing_type(self) -> AddressingTypeAlias:
+    def addressing_type(self) -> AddressingType:
         """Addressing for which this diagnostic message is relevant."""
         return self.__addressing_type
 
     @addressing_type.setter
-    def addressing_type(self, value: AddressingTypeAlias):
+    def addressing_type(self, value: AddressingType):
         """
         Set value of addressing for this diagnostic message.
 
         :param value: Addressing value to set.
         """
-        AddressingType.validate_member(value)
-        self.__addressing_type = AddressingType(value)
+        self.__addressing_type = AddressingType.validate_member(value)
 
 
 class UdsMessageRecord(AbstractUdsMessageContainer):
@@ -179,26 +178,26 @@ def packets_records(self, value: PacketsRecordsSequence):
             raise ReassignmentError("You cannot change value of 'packets_records' attribute once it is assigned.")
 
     @property
-    def payload(self) -> RawBytesTuple:
+    def payload(self) -> RawBytesTupleAlias:
         """Raw payload bytes carried by this diagnostic message."""
         number_of_bytes = self.packets_records[0].data_length
-        message_payload: RawBytesList = []
+        message_payload: RawBytesListAlias = []
         for packet in self.packets_records:
             if packet.payload is not None:
                 message_payload.extend(packet.payload)
         return tuple(message_payload[:number_of_bytes])
 
     @property
-    def addressing_type(self) -> AddressingTypeAlias:
+    def addressing_type(self) -> AddressingType:
         """Addressing which was used to transmit this diagnostic message."""
         return self.packets_records[0].addressing_type
 
     @property
-    def direction(self) -> TransmissionDirectionAlias:
+    def direction(self) -> TransmissionDirection:
         """Information whether this message was received or sent."""
         return self.packets_records[0].direction
 
-    @property  # noqa
+    @property  # noqa: F841
     def transmission_start(self) -> datetime:
         """
         Time stamp when transmission of this message was initiated.
@@ -210,7 +209,7 @@ def transmission_start(self) -> datetime:
         """
         return self.packets_records[0].transmission_time
 
-    @property  # noqa
+    @property  # noqa: F841
     def transmission_end(self) -> datetime:
         """
         Time stamp when transmission of this message was completed.
diff --git a/uds/packet/__init__.py b/uds/packet/__init__.py
index 8b0c064d..19b4e827 100644
--- a/uds/packet/__init__.py
+++ b/uds/packet/__init__.py
@@ -8,12 +8,10 @@
  - storing historic information about packets that were either received or transmitted
 """
 
-from .abstract_packet_type import AbstractUdsPacketType, AbstractUdsPacketTypeAlias
-from .can_packet_type import CanPacketType, CanPacketTypeAlias
+from .abstract_packet_type import AbstractUdsPacketType
+from .can_packet_type import CanPacketType
 from .abstract_packet import AbstractUdsPacketContainer, AbstractUdsPacket, AbstractUdsPacketRecord, \
-    PacketsContainersSequence, PacketsContainersTuple, PacketsContainersList, \
-    PacketsSequence, PacketsTuple, PacketsList, \
-    PacketsRecordsSequence, PacketsRecordsTuple, PacketsRecordsList
+    PacketsContainersSequence, PacketsTuple, PacketsRecordsTuple, PacketsRecordsSequence
 from .abstract_can_packet_container import AbstractCanPacketContainer
 from .can_packet import CanPacket
 from .can_packet_record import CanPacketRecord
diff --git a/uds/packet/abstract_can_packet_container.py b/uds/packet/abstract_can_packet_container.py
index 53c49026..cbc5853f 100644
--- a/uds/packet/abstract_can_packet_container.py
+++ b/uds/packet/abstract_can_packet_container.py
@@ -5,12 +5,11 @@
 from abc import ABC, abstractmethod
 from typing import Optional
 
-from uds.utilities import RawBytesTuple
-from uds.transmission_attributes import AddressingTypeAlias
-from uds.can import AbstractCanAddressingInformation, CanAddressingInformation, CanDlcHandler, \
-    CanSingleFrameHandler, CanFirstFrameHandler, CanConsecutiveFrameHandler, CanFlowControlHandler, \
-    CanAddressingFormatAlias, CanFlowStatusAlias
-from .can_packet_type import CanPacketTypeAlias, CanPacketType
+from uds.utilities import RawBytesTupleAlias
+from uds.transmission_attributes import AddressingType
+from uds.can import AbstractCanAddressingInformation, CanAddressingInformation, CanAddressingFormat, CanDlcHandler,  \
+    CanSingleFrameHandler, CanFirstFrameHandler, CanConsecutiveFrameHandler, CanFlowControlHandler, CanFlowStatus
+from .can_packet_type import CanPacketType
 
 
 class AbstractCanPacketContainer(ABC):
@@ -18,7 +17,7 @@ class AbstractCanPacketContainer(ABC):
 
     @property
     @abstractmethod
-    def raw_frame_data(self) -> RawBytesTuple:
+    def raw_frame_data(self) -> RawBytesTupleAlias:
         """Raw data bytes of a CAN frame that carries this CAN packet."""
 
     @property
@@ -28,12 +27,12 @@ def can_id(self) -> int:
 
     @property
     @abstractmethod
-    def addressing_format(self) -> CanAddressingFormatAlias:
+    def addressing_format(self) -> CanAddressingFormat:
         """CAN addressing format used by this CAN packet."""
 
     @property
     @abstractmethod
-    def addressing_type(self) -> AddressingTypeAlias:
+    def addressing_type(self) -> AddressingType:
         """Addressing type for which this CAN packet is relevant."""
 
     @property
@@ -42,7 +41,7 @@ def dlc(self) -> int:
         return CanDlcHandler.encode_dlc(len(self.raw_frame_data))
 
     @property
-    def packet_type(self) -> CanPacketTypeAlias:
+    def packet_type(self) -> CanPacketType:
         """Type (N_PCI value) of this CAN packet."""
         ai_data_bytes_number = CanAddressingInformation.get_ai_data_bytes_number(self.addressing_format)
         return CanPacketType(self.raw_frame_data[ai_data_bytes_number] >> 4)
@@ -125,7 +124,7 @@ def sequence_number(self) -> Optional[int]:
         return None
 
     @property
-    def payload(self) -> Optional[RawBytesTuple]:
+    def payload(self) -> Optional[RawBytesTupleAlias]:
         """
         Diagnostic message payload carried by this CAN packet.
 
@@ -154,7 +153,7 @@ def payload(self) -> Optional[RawBytesTuple]:
         return None
 
     @property
-    def flow_status(self) -> Optional[CanFlowStatusAlias]:
+    def flow_status(self) -> Optional[CanFlowStatus]:
         """
         Flow Status carried by this CAN packet.
 
diff --git a/uds/packet/abstract_packet.py b/uds/packet/abstract_packet.py
index f48c97bc..e0a9c698 100644
--- a/uds/packet/abstract_packet.py
+++ b/uds/packet/abstract_packet.py
@@ -1,18 +1,16 @@
 """Abstract definition of UDS packets that is common for all bus types."""
 
 __all__ = ["AbstractUdsPacketContainer", "AbstractUdsPacket", "AbstractUdsPacketRecord",
-           "PacketsContainersSequence", "PacketsContainersTuple", "PacketsContainersList",
-           "PacketsSequence", "PacketsTuple", "PacketsList",
-           "PacketsRecordsSequence", "PacketsRecordsTuple", "PacketsRecordsList"]
+           "PacketsContainersSequence", "PacketsTuple", "PacketsRecordsTuple", "PacketsRecordsSequence"]
 
 from abc import ABC, abstractmethod
-from typing import Union, Optional, Any, Tuple, List
+from typing import Any, Optional, Tuple, Sequence
 from datetime import datetime
 
-from uds.utilities import RawBytesTuple, ReassignmentError
-from uds.transmission_attributes.addressing import AddressingTypeAlias
-from uds.transmission_attributes.transmission_direction import TransmissionDirection, TransmissionDirectionAlias
-from .abstract_packet_type import AbstractUdsPacketTypeAlias
+from uds.utilities import RawBytesTupleAlias, ReassignmentError
+from uds.transmission_attributes.addressing import AddressingType
+from uds.transmission_attributes.transmission_direction import TransmissionDirection
+from .abstract_packet_type import AbstractUdsPacketType
 
 
 class AbstractUdsPacketContainer(ABC):
@@ -20,17 +18,17 @@ class AbstractUdsPacketContainer(ABC):
 
     @property
     @abstractmethod
-    def raw_frame_data(self) -> RawBytesTuple:
+    def raw_frame_data(self) -> RawBytesTupleAlias:
         """Raw data bytes of a frame that carries this packet."""
 
     @property
     @abstractmethod
-    def addressing_type(self) -> AddressingTypeAlias:
+    def addressing_type(self) -> AddressingType:
         """Addressing for which this packet is relevant."""
 
     @property
     @abstractmethod
-    def packet_type(self) -> AbstractUdsPacketTypeAlias:
+    def packet_type(self) -> AbstractUdsPacketType:
         """Type (N_PCI value) of this UDS packet."""
 
     @property
@@ -40,7 +38,7 @@ def data_length(self) -> Optional[int]:
 
     @property
     @abstractmethod
-    def payload(self) -> Optional[RawBytesTuple]:
+    def payload(self) -> Optional[RawBytesTupleAlias]:
         """Raw payload bytes of a diagnostic message that are carried by this packet."""
 
 
@@ -49,17 +47,17 @@ class AbstractUdsPacket(AbstractUdsPacketContainer):
 
     @property
     @abstractmethod
-    def raw_frame_data(self) -> RawBytesTuple:
+    def raw_frame_data(self) -> RawBytesTupleAlias:
         """Raw data bytes of a frame that carries this packet."""
 
     @property
     @abstractmethod
-    def addressing_type(self) -> AddressingTypeAlias:
+    def addressing_type(self) -> AddressingType:
         """Addressing for which this packet is relevant."""
 
     @property
     @abstractmethod
-    def packet_type(self) -> AbstractUdsPacketTypeAlias:
+    def packet_type(self) -> AbstractUdsPacketType:
         """Type (N_PCI value) of this UDS packet."""
 
     @property
@@ -69,7 +67,7 @@ def data_length(self) -> Optional[int]:
 
     @property
     @abstractmethod
-    def payload(self) -> Optional[RawBytesTuple]:
+    def payload(self) -> Optional[RawBytesTupleAlias]:
         """Raw payload bytes of a diagnostic message that are carried by this packet."""
 
 
@@ -79,7 +77,7 @@ class AbstractUdsPacketRecord(AbstractUdsPacketContainer):
     @abstractmethod
     def __init__(self,
                  frame: Any,
-                 direction: TransmissionDirectionAlias,
+                 direction: TransmissionDirection,
                  transmission_time: datetime) -> None:
         """
         Create a record of historic information about a packet that was either received or transmitted.
@@ -115,12 +113,12 @@ def frame(self, value: Any):
             raise ReassignmentError("You cannot change value of 'frame' attribute once it is assigned.")
 
     @property
-    def direction(self) -> TransmissionDirectionAlias:
+    def direction(self) -> TransmissionDirection:
         """Information whether this packet was transmitted or received."""
         return self.__direction
 
     @direction.setter
-    def direction(self, value: TransmissionDirectionAlias):
+    def direction(self, value: TransmissionDirection):
         """
         Set value of direction attribute.
 
@@ -131,8 +129,7 @@ def direction(self, value: TransmissionDirectionAlias):
         try:
             getattr(self, "_AbstractUdsPacketRecord__direction")
         except AttributeError:
-            TransmissionDirection.validate_member(value)
-            self.__direction = TransmissionDirection(value)
+            self.__direction = TransmissionDirection.validate_member(value)
         else:
             raise ReassignmentError("You cannot change value of 'direction' attribute once it is assigned.")
 
@@ -162,17 +159,17 @@ def transmission_time(self, value: datetime):
 
     @property
     @abstractmethod
-    def raw_frame_data(self) -> RawBytesTuple:
+    def raw_frame_data(self) -> RawBytesTupleAlias:
         """Raw data bytes of a frame that carries this packet."""
 
     @property
     @abstractmethod
-    def addressing_type(self) -> AddressingTypeAlias:
+    def addressing_type(self) -> AddressingType:
         """Addressing for which this packet is relevant."""
 
     @property
     @abstractmethod
-    def packet_type(self) -> AbstractUdsPacketTypeAlias:
+    def packet_type(self) -> AbstractUdsPacketType:
         """Type (N_PCI value) of this UDS packet."""
 
     @property
@@ -182,7 +179,7 @@ def data_length(self) -> Optional[int]:
 
     @property
     @abstractmethod
-    def payload(self) -> Optional[RawBytesTuple]:
+    def payload(self) -> Optional[RawBytesTupleAlias]:
         """Raw payload bytes of a diagnostic message that are carried by this packet."""
 
     @staticmethod
@@ -198,23 +195,12 @@ def _validate_frame(value: Any) -> None:
         """
 
 
-PacketsContainersTuple = Tuple[AbstractUdsPacketContainer, ...]
-"""Typing alias of a tuple filled with :class:`~uds.packet.abstract_packet.AbstractUdsPacketContainer` instances."""
-PacketsContainersList = List[AbstractUdsPacketContainer]
-"""Typing alias of a list filled with :class:`~uds.packet.abstract_packet.AbstractUdsPacketContainer` instances."""
-PacketsContainersSequence = Union[PacketsContainersTuple, PacketsContainersList]
-"""Typing alias of a sequence filled with :class:`~uds.packet.abstract_packet.AbstractUdsPacketContainer` instances."""
+PacketsContainersSequence = Sequence[AbstractUdsPacketContainer]
+"""Alias for a sequence filled with packet or packet record object."""
 
 PacketsTuple = Tuple[AbstractUdsPacket, ...]
-"""Typing alias of a tuple filled with :class:`~uds.packet.abstract_packet.AbstractUdsPacket` instances."""
-PacketsList = List[AbstractUdsPacket]
-"""Typing alias of a list filled with :class:`~uds.packet.abstract_packet.AbstractUdsPacket` instances."""
-PacketsSequence = Union[PacketsTuple, PacketsList]  # noqa: F841
-"""Typing alias of a sequence filled with :class:`~uds.packet.abstract_packet.AbstractUdsPacket` instances."""
-
+"""Alias for a packet objects tuple."""
 PacketsRecordsTuple = Tuple[AbstractUdsPacketRecord, ...]
-"""Typing alias of a tuple filled with :class:`~uds.packet.abstract_packet.AbstractUdsPacketRecord` instances."""
-PacketsRecordsList = List[AbstractUdsPacketRecord]
-"""Typing alias of a list filled with :class:`~uds.packet.abstract_packet.AbstractUdsPacketRecord` instances."""
-PacketsRecordsSequence = Union[PacketsRecordsTuple, PacketsRecordsList]
-"""Typing alias of a sequence filled with :class:`~uds.packet.abstract_packet.AbstractUdsPacketRecord` instances."""
+"""Alias for a packet record objects tuple."""
+PacketsRecordsSequence = Sequence[AbstractUdsPacketRecord]
+"""Alias for a packet record objects sequence."""
diff --git a/uds/packet/abstract_packet_type.py b/uds/packet/abstract_packet_type.py
index c68cdf33..44d7e37e 100644
--- a/uds/packet/abstract_packet_type.py
+++ b/uds/packet/abstract_packet_type.py
@@ -1,8 +1,8 @@
 """Common (abstract) implementation of UDS Packet Types."""
 
-__all__ = ["AbstractUdsPacketType", "AbstractUdsPacketTypeAlias"]
+__all__ = ["AbstractUdsPacketType"]
 
-from typing import Any, Union
+from typing import Any
 from abc import abstractmethod
 
 from uds.utilities import NibbleEnum, ValidatedEnum, ExtendableEnum
@@ -28,7 +28,3 @@ def is_initial_packet_type(cls, value: Any) -> bool:
 
         :return: True if given argument is a packet type that initiates a diagnostic message, else False.
         """
-
-
-AbstractUdsPacketTypeAlias = Union[AbstractUdsPacketType, int]
-"""Alias that describes :class:`~uds.packet.abstract_packet_type.AbstractUdsPacketType` member."""
diff --git a/uds/packet/can_packet.py b/uds/packet/can_packet.py
index 5d3202b5..a761e50e 100644
--- a/uds/packet/can_packet.py
+++ b/uds/packet/can_packet.py
@@ -5,17 +5,17 @@
 from typing import Optional, Any
 from warnings import warn
 
-from uds.utilities import AmbiguityError, UnusedArgumentWarning, RawBytes, RawBytesTuple
-from uds.transmission_attributes import AddressingType, AddressingTypeAlias
+from uds.utilities import AmbiguityError, UnusedArgumentWarning, RawBytesAlias, RawBytesTupleAlias
+from uds.transmission_attributes import AddressingType
 from uds.can import DEFAULT_FILLER_BYTE, CanDlcHandler, \
-    CanAddressingFormat, CanAddressingFormatAlias, AbstractCanAddressingInformation, CanAddressingInformation, \
+    CanAddressingFormat, AbstractCanAddressingInformation, CanAddressingInformation, \
     Normal11BitCanAddressingInformation, NormalFixedCanAddressingInformation, ExtendedCanAddressingInformation, \
     Mixed11BitCanAddressingInformation, Mixed29BitCanAddressingInformation, \
     CanSingleFrameHandler, CanFirstFrameHandler, CanConsecutiveFrameHandler, \
-    CanFlowControlHandler, CanFlowStatusAlias
+    CanFlowControlHandler, CanFlowStatus
 from .abstract_can_packet_container import AbstractCanPacketContainer
 from .abstract_packet import AbstractUdsPacket
-from .can_packet_type import CanPacketType, CanPacketTypeAlias
+from .can_packet_type import CanPacketType
 
 
 class CanPacket(AbstractCanPacketContainer, AbstractUdsPacket):
@@ -27,9 +27,9 @@ class CanPacket(AbstractCanPacketContainer, AbstractUdsPacket):
     """
 
     def __init__(self, *,
-                 packet_type: CanPacketTypeAlias,
-                 addressing_format: CanAddressingFormatAlias,
-                 addressing_type: AddressingTypeAlias,
+                 packet_type: CanPacketType,
+                 addressing_format: CanAddressingFormat,
+                 addressing_type: AddressingType,
                  can_id: Optional[int] = None,
                  target_address: Optional[int] = None,
                  source_address: Optional[int] = None,
@@ -77,10 +77,10 @@ def __init__(self, *,
                 Separation Time minimum information carried by this Flow Control frame.
         """
         # initialize the variables
-        self.__raw_frame_data: RawBytesTuple = None  # type: ignore
-        self.__addressing_type: AddressingTypeAlias = None  # type: ignore
-        self.__addressing_format: CanAddressingFormatAlias = None  # type: ignore
-        self.__packet_type: CanPacketTypeAlias = None  # type: ignore
+        self.__raw_frame_data: RawBytesTupleAlias = None  # type: ignore
+        self.__addressing_type: AddressingType = None  # type: ignore
+        self.__addressing_format: CanAddressingFormat = None  # type: ignore
+        self.__packet_type: CanPacketType = None  # type: ignore
         self.__can_id: int = None  # type: ignore
         self.__dlc: int = None  # type: ignore
         self.__target_address: Optional[int] = None
@@ -98,8 +98,8 @@ def __init__(self, *,
                              **packet_type_specific_kwargs)
 
     def set_address_information(self, *,
-                                addressing_format: CanAddressingFormatAlias,
-                                addressing_type: AddressingTypeAlias,
+                                addressing_format: CanAddressingFormat,
+                                addressing_type: AddressingType,
                                 can_id: Optional[int] = None,
                                 target_address: Optional[int] = None,
                                 source_address: Optional[int] = None,
@@ -170,7 +170,7 @@ def set_address_information(self, *,
         else:
             raise NotImplementedError(f"Missing implementation for: {addressing_format}")
 
-    def set_address_information_normal_11bit(self, addressing_type: AddressingTypeAlias, can_id: int) -> None:
+    def set_address_information_normal_11bit(self, addressing_type: AddressingType, can_id: int) -> None:
         """
         Change addressing information for this CAN packet to use Normal 11-bit Addressing format.
 
@@ -188,7 +188,7 @@ def set_address_information_normal_11bit(self, addressing_type: AddressingTypeAl
         self.__update_ai_data_byte()
 
     def set_address_information_normal_fixed(self,
-                                             addressing_type: AddressingTypeAlias,
+                                             addressing_type: AddressingType,
                                              can_id: Optional[int] = None,
                                              target_address: Optional[int] = None,
                                              source_address: Optional[int] = None) -> None:
@@ -217,7 +217,7 @@ def set_address_information_normal_fixed(self,
         self.__update_ai_data_byte()
 
     def set_address_information_extended(self,
-                                         addressing_type: AddressingTypeAlias,
+                                         addressing_type: AddressingType,
                                          can_id: int,
                                          target_address: int) -> None:
         """
@@ -240,7 +240,7 @@ def set_address_information_extended(self,
         self.__update_ai_data_byte()
 
     def set_address_information_mixed_11bit(self,
-                                            addressing_type: AddressingTypeAlias,
+                                            addressing_type: AddressingType,
                                             can_id: int,
                                             address_extension: int) -> None:
         """
@@ -263,7 +263,7 @@ def set_address_information_mixed_11bit(self,
         self.__update_ai_data_byte()
 
     def set_address_information_mixed_29bit(self,
-                                            addressing_type: AddressingTypeAlias,
+                                            addressing_type: AddressingType,
                                             address_extension: int,
                                             can_id: Optional[int] = None,
                                             target_address: Optional[int] = None,
@@ -295,7 +295,7 @@ def set_address_information_mixed_29bit(self,
         self.__update_ai_data_byte()
 
     def set_packet_data(self, *,
-                        packet_type: CanPacketTypeAlias,
+                        packet_type: CanPacketType,
                         dlc: Optional[int] = None,
                         **packet_type_specific_kwargs: Any) -> None:
         """
@@ -347,7 +347,7 @@ def set_packet_data(self, *,
             raise NotImplementedError(f"Missing implementation for: {packet_type}")
 
     def set_single_frame_data(self,
-                              payload: RawBytes,
+                              payload: RawBytesAlias,
                               dlc: Optional[int] = None,
                               filler_byte: int = DEFAULT_FILLER_BYTE) -> None:
         """
@@ -377,7 +377,7 @@ def set_single_frame_data(self,
 
     def set_first_frame_data(self,
                              dlc: int,
-                             payload: RawBytes,
+                             payload: RawBytesAlias,
                              data_length: int) -> None:
         """
         Change packet type (to First Frame) and data field of this CAN packet.
@@ -401,7 +401,7 @@ def set_first_frame_data(self,
         self.__packet_type = CanPacketType.FIRST_FRAME
 
     def set_consecutive_frame_data(self,
-                                   payload: RawBytes,
+                                   payload: RawBytesAlias,
                                    sequence_number: int,
                                    dlc: Optional[int] = None,
                                    filler_byte: int = DEFAULT_FILLER_BYTE) -> None:
@@ -433,7 +433,7 @@ def set_consecutive_frame_data(self,
         self.__packet_type = CanPacketType.CONSECUTIVE_FRAME
 
     def set_flow_control_data(self,
-                              flow_status: CanFlowStatusAlias,
+                              flow_status: CanFlowStatus,
                               block_size: Optional[int] = None,
                               st_min: Optional[int] = None,
                               dlc: Optional[int] = None,
@@ -468,7 +468,7 @@ def set_flow_control_data(self,
         self.__packet_type = CanPacketType.FLOW_CONTROL
 
     @property
-    def raw_frame_data(self) -> RawBytesTuple:
+    def raw_frame_data(self) -> RawBytesTupleAlias:
         """Raw data bytes of a CAN frame that carries this CAN packet."""
         return self.__raw_frame_data
 
@@ -478,12 +478,12 @@ def can_id(self) -> int:
         return self.__can_id
 
     @property
-    def addressing_format(self) -> CanAddressingFormatAlias:
+    def addressing_format(self) -> CanAddressingFormat:
         """CAN addressing format used by this CAN packet."""
         return self.__addressing_format
 
     @property
-    def addressing_type(self) -> AddressingTypeAlias:
+    def addressing_type(self) -> AddressingType:
         """Addressing type for which this CAN packet is relevant."""
         return self.__addressing_type
 
@@ -493,7 +493,7 @@ def dlc(self) -> int:
         return self.__dlc
 
     @property
-    def packet_type(self) -> CanPacketTypeAlias:
+    def packet_type(self) -> CanPacketType:
         """Type (N_PCI value) of this CAN packet."""
         return self.__packet_type
 
@@ -538,7 +538,7 @@ def address_extension(self) -> Optional[int]:
         """
         return self.__address_extension
 
-    def __validate_unambiguous_ai_change(self, addressing_format: CanAddressingFormatAlias) -> None:
+    def __validate_unambiguous_ai_change(self, addressing_format: CanAddressingFormat) -> None:
         """
         Validate whether CAN Addressing Format change to provided value is ambiguous.
 
diff --git a/uds/packet/can_packet_record.py b/uds/packet/can_packet_record.py
index 7b5ae22d..67139fa6 100644
--- a/uds/packet/can_packet_record.py
+++ b/uds/packet/can_packet_record.py
@@ -7,15 +7,16 @@
 
 from can import Message as PythonCanMessage
 
-from uds.utilities import RawBytesTuple, InconsistentArgumentsError
-from uds.transmission_attributes import AddressingType, AddressingTypeAlias, TransmissionDirectionAlias
-from uds.can import CanAddressingFormat, CanAddressingFormatAlias, \
+from uds.utilities import RawBytesTupleAlias, InconsistentArgumentsError
+from uds.transmission_attributes import AddressingType, TransmissionDirection
+from uds.can import CanAddressingFormat, \
     CanAddressingInformation, AbstractCanAddressingInformation, \
     CanDlcHandler, CanIdHandler
-from .can_packet_type import CanPacketType, CanPacketTypeAlias
+from .can_packet_type import CanPacketType
 from .abstract_can_packet_container import AbstractCanPacketContainer
 from .abstract_packet import AbstractUdsPacketRecord
 
+
 CanFrameAlias = Union[PythonCanMessage]
 """Alias of supported CAN frames objects."""
 
@@ -30,9 +31,9 @@ class CanPacketRecord(AbstractCanPacketContainer, AbstractUdsPacketRecord):
 
     def __init__(self,
                  frame: CanFrameAlias,
-                 direction: TransmissionDirectionAlias,
-                 addressing_type: AddressingTypeAlias,
-                 addressing_format: CanAddressingFormatAlias,
+                 direction: TransmissionDirection,
+                 addressing_type: AddressingType,
+                 addressing_format: CanAddressingFormat,
                  transmission_time: datetime) -> None:
         """
         Create a record of historic information about a CAN packet that was either received or transmitted.
@@ -43,12 +44,10 @@ def __init__(self,
         :param addressing_format: CAN addressing format that this CAN packet used.
         :param transmission_time: Time stamp when this packet was fully transmitted on a CAN bus.
         """
-        AddressingType.validate_member(addressing_type)
-        CanAddressingFormat.validate_member(addressing_format)
         super().__init__(frame=frame, direction=direction, transmission_time=transmission_time)
-        self.__addressing_type = AddressingType(addressing_type)
-        self.__addressing_format = CanAddressingFormat(addressing_format)
-        self.__packet_type: CanPacketTypeAlias
+        self.__addressing_type = AddressingType.validate_member(addressing_type)
+        self.__addressing_format = CanAddressingFormat.validate_member(addressing_format)
+        self.__packet_type: CanPacketType
         self.__target_address: Optional[int]
         self.__source_address: Optional[int]
         self.__address_extension: Optional[int]
@@ -56,7 +55,7 @@ def __init__(self,
         self.__assess_ai_attributes()
 
     @property
-    def raw_frame_data(self) -> RawBytesTuple:
+    def raw_frame_data(self) -> RawBytesTupleAlias:
         """Raw data bytes of a frame that carried this CAN packet."""
         if isinstance(self.frame, PythonCanMessage):
             return tuple(self.frame.data)
@@ -70,17 +69,17 @@ def can_id(self) -> int:
         raise NotImplementedError(f"Missing implementation for: {self.frame}")
 
     @property
-    def addressing_format(self) -> CanAddressingFormatAlias:
+    def addressing_format(self) -> CanAddressingFormat:
         """CAN addressing format used by this CAN packet."""
         return self.__addressing_format
 
     @property
-    def addressing_type(self) -> AddressingTypeAlias:
+    def addressing_type(self) -> AddressingType:
         """Addressing type over which this CAN packet was transmitted."""
         return self.__addressing_type
 
     @property
-    def packet_type(self) -> CanPacketTypeAlias:
+    def packet_type(self) -> CanPacketType:
         """CAN packet type value - N_PCI value of this N_PDU."""
         return self.__packet_type
 
@@ -145,8 +144,7 @@ def __assess_packet_type(self) -> None:
         """Assess and set value of Packet Type attribute."""
         ai_data_bytes = CanAddressingInformation.get_ai_data_bytes_number(self.addressing_format)
         n_pci_value = self.raw_frame_data[ai_data_bytes] >> 4
-        CanPacketType.validate_member(n_pci_value)
-        self.__packet_type = CanPacketType(n_pci_value)
+        self.__packet_type = CanPacketType.validate_member(n_pci_value)
 
     def __assess_ai_attributes(self) -> None:
         """
diff --git a/uds/packet/can_packet_type.py b/uds/packet/can_packet_type.py
index 4e5d8277..8f736a36 100644
--- a/uds/packet/can_packet_type.py
+++ b/uds/packet/can_packet_type.py
@@ -1,8 +1,8 @@
 """CAN packet types definitions."""
 
-__all__ = ["CanPacketType", "CanPacketTypeAlias"]
+__all__ = ["CanPacketType"]
 
-from typing import Any, Union
+from typing import Any
 
 from aenum import unique
 
@@ -19,13 +19,13 @@ class CanPacketType(AbstractUdsPacketType):
     :ref:`Network Protocol Control Information (N_PCI) <knowledge-base-n-pci>` values that are specific for CAN bus.
     """
 
-    SINGLE_FRAME = CanSingleFrameHandler.SINGLE_FRAME_N_PCI
+    SINGLE_FRAME: "CanPacketType" = CanSingleFrameHandler.SINGLE_FRAME_N_PCI  # type: ignore
     """CAN packet type (N_PCI) value of :ref:`Single Frame (SF) <knowledge-base-can-single-frame>`."""
-    FIRST_FRAME = CanFirstFrameHandler.FIRST_FRAME_N_PCI
+    FIRST_FRAME: "CanPacketType" = CanFirstFrameHandler.FIRST_FRAME_N_PCI  # type: ignore
     """CAN packet type (N_PCI) value of First Frame (FF) <knowledge-base-can-first-frame>`."""
-    CONSECUTIVE_FRAME = CanConsecutiveFrameHandler.CONSECUTIVE_FRAME_N_PCI
+    CONSECUTIVE_FRAME: "CanPacketType" = CanConsecutiveFrameHandler.CONSECUTIVE_FRAME_N_PCI  # type: ignore
     """CAN packet type (N_PCI) value of :ref:`Consecutive Frame (CF) <knowledge-base-can-consecutive-frame>`."""
-    FLOW_CONTROL = CanFlowControlHandler.FLOW_CONTROL_N_PCI
+    FLOW_CONTROL: "CanPacketType" = CanFlowControlHandler.FLOW_CONTROL_N_PCI  # type: ignore
     """CAN packet type (N_PCI) value of :ref:`Flow Control (FC) <knowledge-base-can-flow-control>`."""
 
     @classmethod
@@ -39,7 +39,3 @@ def is_initial_packet_type(cls, value: Any) -> bool:
         """
         cls.validate_member(value)
         return value in (cls.SINGLE_FRAME, cls.FIRST_FRAME)
-
-
-CanPacketTypeAlias = Union[CanPacketType, int]
-"""Alias that describes :class:`~uds.packet.can_packet_type.CanPacketType` member type."""
diff --git a/uds/segmentation/can_segmenter.py b/uds/segmentation/can_segmenter.py
index ac2b58e4..23163b1c 100644
--- a/uds/segmentation/can_segmenter.py
+++ b/uds/segmentation/can_segmenter.py
@@ -4,10 +4,10 @@
 
 from typing import Optional, Union, Type
 
-from uds.utilities import RawBytesList, RawBytes, validate_raw_byte
+from uds.utilities import RawBytesListAlias, RawBytesAlias, validate_raw_byte
 from uds.transmission_attributes import AddressingType
 from uds.can import AbstractCanAddressingInformation, CanAddressingInformation, PacketAIParamsAlias, \
-    CanAddressingFormatAlias, \
+    CanAddressingFormat, \
     CanDlcHandler, CanSingleFrameHandler, CanFirstFrameHandler, CanConsecutiveFrameHandler, DEFAULT_FILLER_BYTE
 from uds.packet import CanPacket, CanPacketRecord, CanPacketType, \
     AbstractUdsPacket, AbstractUdsPacketRecord, PacketsContainersSequence, PacketsTuple
@@ -49,7 +49,7 @@ def supported_packet_record_class(self) -> Type[AbstractUdsPacketRecord]:
         return CanPacketRecord
 
     @property
-    def addressing_format(self) -> CanAddressingFormatAlias:
+    def addressing_format(self) -> CanAddressingFormat:
         """CAN Addressing format used."""
         return self.addressing_information.addressing_format
 
@@ -146,7 +146,7 @@ def filler_byte(self, value: int):
         validate_raw_byte(value)
         self.__filler_byte: int = value
 
-    def is_input_packet(self, can_id: int, data: RawBytes) -> Optional[AddressingType]:  # type: ignore # noqa
+    def is_input_packet(self, can_id: int, data: RawBytesAlias) -> Optional[AddressingType]:  # type: ignore # noqa
         """
         Check if provided frame attributes belong to a UDS CAN packet which is an input for this CAN Segmenter.
 
@@ -227,7 +227,7 @@ def desegmentation(self, packets: PacketsContainersSequence) -> Union[UdsMessage
                 return UdsMessage(payload=packets[0].payload,  # type: ignore
                                   addressing_type=packets[0].addressing_type)
             if packets[0].packet_type == CanPacketType.FIRST_FRAME:
-                payload_bytes: RawBytesList = []
+                payload_bytes: RawBytesListAlias = []
                 for packet in packets:
                     if packet.payload is not None:
                         payload_bytes.extend(packet.payload)
diff --git a/uds/transmission_attributes/__init__.py b/uds/transmission_attributes/__init__.py
index e33497be..807760a2 100644
--- a/uds/transmission_attributes/__init__.py
+++ b/uds/transmission_attributes/__init__.py
@@ -1,4 +1,4 @@
 """Definition of attributes that describes UDS communication."""
 
-from .addressing import AddressingType, AddressingTypeAlias
-from .transmission_direction import TransmissionDirection, TransmissionDirectionAlias
+from .addressing import AddressingType
+from .transmission_direction import TransmissionDirection
diff --git a/uds/transmission_attributes/addressing.py b/uds/transmission_attributes/addressing.py
index df15fef2..4b4d1368 100644
--- a/uds/transmission_attributes/addressing.py
+++ b/uds/transmission_attributes/addressing.py
@@ -4,9 +4,7 @@
 :ref:`Addressing <knowledge-base-addressing>` describes a communication model that is used during UDS communication.
 """
 
-__all__ = ["AddressingType", "AddressingTypeAlias"]
-
-from typing import Union
+__all__ = ["AddressingType"]
 
 from aenum import StrEnum, unique
 
@@ -26,7 +24,3 @@ class AddressingType(StrEnum, ValidatedEnum):
     FUNCTIONAL: "AddressingType" = "Functional"  # type: ignore
     """:ref:`Functional addressing <knowledge-base-functional-addressing>` - 1 (client) to many (servers)
     communication."""
-
-
-AddressingTypeAlias = Union[AddressingType, str]
-"""Alias that describes :class:`~uds.transmission_attributes.addressing.AddressingType` member."""
diff --git a/uds/transmission_attributes/transmission_direction.py b/uds/transmission_attributes/transmission_direction.py
index 8f590a76..eb8347ed 100644
--- a/uds/transmission_attributes/transmission_direction.py
+++ b/uds/transmission_attributes/transmission_direction.py
@@ -1,8 +1,6 @@
 """Definition of communication direction."""
 
-__all__ = ["TransmissionDirection", "TransmissionDirectionAlias"]
-
-from typing import Union
+__all__ = ["TransmissionDirection"]
 
 from aenum import StrEnum, unique
 
@@ -13,11 +11,7 @@
 class TransmissionDirection(StrEnum, ValidatedEnum):
     """Direction of a communication."""
 
-    RECEIVED = "Rx"  # noqa: F841
+    RECEIVED: "TransmissionDirection" = "Rx"  # type: ignore  # noqa: F841
     """Incoming transmission from the perspective of the code."""
-    TRANSMITTED = "Tx"  # noqa: F841
+    TRANSMITTED: "TransmissionDirection" = "Tx"  # type: ignore  # noqa: F841
     """Outgoing transmission from the perspective of the code."""
-
-
-TransmissionDirectionAlias = Union[TransmissionDirection, str]
-"""Alias that describes :class:`~uds.transmission_attributes.transmission_direction.TransmissionDirection` member."""
diff --git a/uds/transport_interface/abstract_transport_interface.py b/uds/transport_interface/abstract_transport_interface.py
index 204ac508..910354ad 100644
--- a/uds/transport_interface/abstract_transport_interface.py
+++ b/uds/transport_interface/abstract_transport_interface.py
@@ -6,7 +6,7 @@
 from abc import ABC, abstractmethod
 from asyncio import AbstractEventLoop
 
-from uds.utilities import TimeMilliseconds
+from uds.utilities import TimeMillisecondsAlias
 from uds.packet import AbstractUdsPacket, AbstractUdsPacketRecord
 from uds.segmentation import AbstractSegmenter
 
@@ -71,7 +71,7 @@ def send_packet(self, packet: AbstractUdsPacket) -> AbstractUdsPacketRecord:
         """
 
     @abstractmethod
-    def receive_packet(self, timeout: Optional[TimeMilliseconds] = None) -> AbstractUdsPacketRecord:
+    def receive_packet(self, timeout: Optional[TimeMillisecondsAlias] = None) -> AbstractUdsPacketRecord:
         """
         Receive UDS packet.
 
@@ -97,7 +97,7 @@ async def async_send_packet(self,
 
     @abstractmethod
     async def async_receive_packet(self,
-                                   timeout: Optional[TimeMilliseconds] = None,
+                                   timeout: Optional[TimeMillisecondsAlias] = None,
                                    loop: Optional[AbstractEventLoop] = None) -> AbstractUdsPacketRecord:
         """
         Receive UDS packet asynchronously.
diff --git a/uds/transport_interface/can_transport_interface.py b/uds/transport_interface/can_transport_interface.py
index 38b646a3..b7228b1e 100644
--- a/uds/transport_interface/can_transport_interface.py
+++ b/uds/transport_interface/can_transport_interface.py
@@ -11,7 +11,7 @@
 
 from can import BusABC, AsyncBufferedReader, BufferedReader, Notifier, Message
 
-from uds.utilities import TimeMilliseconds, ValueWarning
+from uds.utilities import TimeMillisecondsAlias, ValueWarning
 from uds.can import AbstractCanAddressingInformation, CanIdHandler, CanDlcHandler
 from uds.packet import CanPacket, CanPacketRecord, CanPacketType
 from uds.transmission_attributes import TransmissionDirection
@@ -26,18 +26,18 @@ class AbstractCanTransportInterface(AbstractTransportInterface):
     CAN Transport Interfaces are meant to handle UDS middle layers (Transport and Network) on CAN bus.
     """
 
-    N_AS_TIMEOUT: TimeMilliseconds = 1000
+    N_AS_TIMEOUT: TimeMillisecondsAlias = 1000
     """Timeout value of :ref:`N_As <knowledge-base-can-n-as>` time parameter according to ISO 15765-2."""
-    N_AR_TIMEOUT: TimeMilliseconds = 1000
+    N_AR_TIMEOUT: TimeMillisecondsAlias = 1000
     """Timeout value of :ref:`N_Ar <knowledge-base-can-n-ar>` time parameter according to ISO 15765-2."""
-    N_BS_TIMEOUT: TimeMilliseconds = 1000
+    N_BS_TIMEOUT: TimeMillisecondsAlias = 1000
     """Timeout value of :ref:`N_Bs <knowledge-base-can-n-bs>` time parameter according to ISO 15765-2."""
-    N_CR_TIMEOUT: TimeMilliseconds = 1000
+    N_CR_TIMEOUT: TimeMillisecondsAlias = 1000
     """Timeout value of :ref:`N_Cr <knowledge-base-can-n-cr>` time parameter according to ISO 15765-2."""
 
-    DEFAULT_N_BR: TimeMilliseconds = 0
+    DEFAULT_N_BR: TimeMillisecondsAlias = 0
     """Default value of :ref:`N_Br <knowledge-base-can-n-br>` time parameter."""
-    DEFAULT_N_CS: Optional[TimeMilliseconds] = None
+    DEFAULT_N_CS: Optional[TimeMillisecondsAlias] = None
     """Default value of :ref:`N_Cs <knowledge-base-can-n-cs>` time parameter."""
 
     def __init__(self,
@@ -83,12 +83,12 @@ def segmenter(self) -> CanSegmenter:
     # Time parameter - CAN Network Layer
 
     @property
-    def n_as_timeout(self) -> TimeMilliseconds:
+    def n_as_timeout(self) -> TimeMillisecondsAlias:
         """Timeout value for N_As time parameter."""
         return self.__n_as_timeout
 
     @n_as_timeout.setter
-    def n_as_timeout(self, value: TimeMilliseconds):
+    def n_as_timeout(self, value: TimeMillisecondsAlias):
         """
         Set timeout value for N_As time parameter.
 
@@ -108,7 +108,7 @@ def n_as_timeout(self, value: TimeMilliseconds):
 
     @property
     @abstractmethod
-    def n_as_measured(self) -> Optional[TimeMilliseconds]:
+    def n_as_measured(self) -> Optional[TimeMillisecondsAlias]:
         """
         Get the last measured value of N_As time parameter.
 
@@ -116,12 +116,12 @@ def n_as_measured(self) -> Optional[TimeMilliseconds]:
         """
 
     @property
-    def n_ar_timeout(self) -> TimeMilliseconds:
+    def n_ar_timeout(self) -> TimeMillisecondsAlias:
         """Timeout value for N_Ar time parameter."""
         return self.__n_ar_timeout
 
     @n_ar_timeout.setter
-    def n_ar_timeout(self, value: TimeMilliseconds):
+    def n_ar_timeout(self, value: TimeMillisecondsAlias):
         """
         Set timeout value for N_Ar time parameter.
 
@@ -141,7 +141,7 @@ def n_ar_timeout(self, value: TimeMilliseconds):
 
     @property
     @abstractmethod
-    def n_ar_measured(self) -> Optional[TimeMilliseconds]:
+    def n_ar_measured(self) -> Optional[TimeMillisecondsAlias]:
         """
         Get the last measured value of N_Ar time parameter.
 
@@ -149,12 +149,12 @@ def n_ar_measured(self) -> Optional[TimeMilliseconds]:
         """
 
     @property
-    def n_bs_timeout(self) -> TimeMilliseconds:
+    def n_bs_timeout(self) -> TimeMillisecondsAlias:
         """Timeout value for N_Bs time parameter."""
         return self.__n_bs_timeout
 
     @n_bs_timeout.setter
-    def n_bs_timeout(self, value: TimeMilliseconds):
+    def n_bs_timeout(self, value: TimeMillisecondsAlias):
         """
         Set timeout value for N_Bs time parameter.
 
@@ -174,7 +174,7 @@ def n_bs_timeout(self, value: TimeMilliseconds):
 
     @property  # noqa
     @abstractmethod
-    def n_bs_measured(self) -> Optional[TimeMilliseconds]:
+    def n_bs_measured(self) -> Optional[TimeMillisecondsAlias]:
         """
         Get the last measured value of N_Bs time parameter.
 
@@ -182,7 +182,7 @@ def n_bs_measured(self) -> Optional[TimeMilliseconds]:
         """
 
     @property
-    def n_br(self) -> TimeMilliseconds:
+    def n_br(self) -> TimeMillisecondsAlias:
         """
         Get the value of N_Br time parameter which is currently set.
 
@@ -192,7 +192,7 @@ def n_br(self) -> TimeMilliseconds:
         return self.__n_br
 
     @n_br.setter
-    def n_br(self, value: TimeMilliseconds):
+    def n_br(self, value: TimeMillisecondsAlias):
         """
         Set the value of N_Br time parameter to use.
 
@@ -208,7 +208,7 @@ def n_br(self, value: TimeMilliseconds):
         self.__n_br = value
 
     @property
-    def n_br_max(self) -> TimeMilliseconds:
+    def n_br_max(self) -> TimeMillisecondsAlias:
         """
         Get the maximum valid value of N_Br time parameter.
 
@@ -221,7 +221,7 @@ def n_br_max(self) -> TimeMilliseconds:
         return 0.9 * self.n_bs_timeout - n_ar_measured
 
     @property
-    def n_cs(self) -> Optional[TimeMilliseconds]:
+    def n_cs(self) -> Optional[TimeMillisecondsAlias]:
         """
         Get the value of N_Cs time parameter which is currently set.
 
@@ -231,7 +231,7 @@ def n_cs(self) -> Optional[TimeMilliseconds]:
         return self.__n_cs
 
     @n_cs.setter
-    def n_cs(self, value: Optional[TimeMilliseconds]):
+    def n_cs(self, value: Optional[TimeMillisecondsAlias]):
         """
         Set the value of N_Cs time parameter to use.
 
@@ -250,7 +250,7 @@ def n_cs(self, value: Optional[TimeMilliseconds]):
         self.__n_cs = value
 
     @property
-    def n_cs_max(self) -> TimeMilliseconds:
+    def n_cs_max(self) -> TimeMillisecondsAlias:
         """
         Get the maximum valid value of N_Cs time parameter.
 
@@ -263,12 +263,12 @@ def n_cs_max(self) -> TimeMilliseconds:
         return 0.9 * self.n_cr_timeout - n_as_measured
 
     @property
-    def n_cr_timeout(self) -> TimeMilliseconds:
+    def n_cr_timeout(self) -> TimeMillisecondsAlias:
         """Timeout value for N_Cr time parameter."""
         return self.__n_cr_timeout
 
     @n_cr_timeout.setter
-    def n_cr_timeout(self, value: TimeMilliseconds):
+    def n_cr_timeout(self, value: TimeMillisecondsAlias):
         """
         Set timeout value for N_Cr time parameter.
 
@@ -288,7 +288,7 @@ def n_cr_timeout(self, value: TimeMilliseconds):
 
     @property  # noqa
     @abstractmethod
-    def n_cr_measured(self) -> Optional[TimeMilliseconds]:
+    def n_cr_measured(self) -> Optional[TimeMillisecondsAlias]:
         """
         Get the last measured value of N_Cr time parameter.
 
@@ -386,10 +386,10 @@ def __init__(self,
             - :parameter use_data_optimization: Information whether to use CAN Frame Data Optimization.
             - :parameter filler_byte: Filler byte value to use for CAN Frame Data Padding.
         """
-        self.__n_as_measured: Optional[TimeMilliseconds] = None
-        self.__n_ar_measured: Optional[TimeMilliseconds] = None
-        self.__n_bs_measured: Optional[TimeMilliseconds] = None
-        self.__n_cr_measured: Optional[TimeMilliseconds] = None
+        self.__n_as_measured: Optional[TimeMillisecondsAlias] = None
+        self.__n_ar_measured: Optional[TimeMillisecondsAlias] = None
+        self.__n_bs_measured: Optional[TimeMillisecondsAlias] = None
+        self.__n_cr_measured: Optional[TimeMillisecondsAlias] = None
         super().__init__(can_bus_manager=can_bus_manager,
                          addressing_information=addressing_information,
                          **kwargs)
@@ -404,7 +404,7 @@ def __del__(self):
         self._teardown_async_notifier(suppress_warning=True)
 
     @property
-    def n_as_measured(self) -> Optional[TimeMilliseconds]:
+    def n_as_measured(self) -> Optional[TimeMillisecondsAlias]:
         """
         Get the last measured value of N_As time parameter.
 
@@ -413,7 +413,7 @@ def n_as_measured(self) -> Optional[TimeMilliseconds]:
         return self.__n_as_measured
 
     @property
-    def n_ar_measured(self) -> Optional[TimeMilliseconds]:
+    def n_ar_measured(self) -> Optional[TimeMillisecondsAlias]:
         """
         Get the last measured value of N_Ar time parameter.
 
@@ -422,7 +422,7 @@ def n_ar_measured(self) -> Optional[TimeMilliseconds]:
         return self.__n_ar_measured
 
     @property  # noqa
-    def n_bs_measured(self) -> Optional[TimeMilliseconds]:
+    def n_bs_measured(self) -> Optional[TimeMillisecondsAlias]:
         """
         Get the last measured value of N_Bs time parameter.
 
@@ -431,7 +431,7 @@ def n_bs_measured(self) -> Optional[TimeMilliseconds]:
         return self.__n_bs_measured
 
     @property  # noqa
-    def n_cr_measured(self) -> Optional[TimeMilliseconds]:
+    def n_cr_measured(self) -> Optional[TimeMillisecondsAlias]:
         """
         Get the last measured value of N_Cr time parameter.
 
@@ -557,7 +557,7 @@ def send_packet(self, packet: CanPacket) -> CanPacketRecord:  # type: ignore
                                addressing_format=packet.addressing_format,
                                transmission_time=datetime.fromtimestamp(observed_frame.timestamp))
 
-    def receive_packet(self, timeout: Optional[TimeMilliseconds] = None) -> CanPacketRecord:
+    def receive_packet(self, timeout: Optional[TimeMillisecondsAlias] = None) -> CanPacketRecord:
         """
         Receive CAN packet.
 
@@ -640,7 +640,7 @@ async def async_send_packet(self,
                                transmission_time=datetime.fromtimestamp(observed_frame.timestamp))
 
     async def async_receive_packet(self,
-                                   timeout: Optional[TimeMilliseconds] = None,
+                                   timeout: Optional[TimeMillisecondsAlias] = None,
                                    loop: Optional[AbstractEventLoop] = None) -> CanPacketRecord:
         """
         Receive CAN packet.
diff --git a/uds/utilities/__init__.py b/uds/utilities/__init__.py
index fe759da8..b69b488c 100644
--- a/uds/utilities/__init__.py
+++ b/uds/utilities/__init__.py
@@ -1,10 +1,9 @@
 """Various helper functions, classes and variables that are shared and reused within the project."""
 
 from .enums import ValidatedEnum, ExtendableEnum, ByteEnum, NibbleEnum
-from .common_types import RawBytes, RawBytesTuple, RawBytesList, RawBytesSet, \
-    validate_nibble, validate_raw_bytes, validate_raw_byte, \
-    TimeMilliseconds
-from .bytes_operations import Endianness, EndiannessAlias, int_to_bytes_list, bytes_list_to_int
-from .custom_exceptions import ReassignmentError, InconsistentArgumentsError, AmbiguityError, \
-    UnusedArgumentError
+from .common_types import TimeMillisecondsAlias, \
+    RawBytesAlias, RawBytesTupleAlias, RawBytesListAlias, RawBytesSetAlias, \
+    validate_nibble, validate_raw_bytes, validate_raw_byte
+from .bytes_operations import Endianness, int_to_bytes_list, bytes_list_to_int
+from .custom_exceptions import ReassignmentError, InconsistentArgumentsError, AmbiguityError, UnusedArgumentError
 from .custom_warnings import UnusedArgumentWarning, ValueWarning
diff --git a/uds/utilities/bytes_operations.py b/uds/utilities/bytes_operations.py
index 2a5ac985..225390ba 100644
--- a/uds/utilities/bytes_operations.py
+++ b/uds/utilities/bytes_operations.py
@@ -1,13 +1,13 @@
 """Module with bytes list operations implementation."""
 
-__all__ = ["Endianness", "EndiannessAlias", "bytes_list_to_int", "int_to_bytes_list"]
+__all__ = ["Endianness", "bytes_list_to_int", "int_to_bytes_list"]
 
-from typing import Union, Optional
+from typing import Optional
 
 from aenum import StrEnum
 
 from .enums import ValidatedEnum
-from .common_types import RawBytesList, RawBytes, validate_raw_bytes
+from .common_types import RawBytesListAlias, RawBytesAlias, validate_raw_bytes
 from .custom_exceptions import InconsistentArgumentsError
 
 
@@ -18,19 +18,15 @@ class Endianness(StrEnum, ValidatedEnum):
     `Endianness <https://en.wikipedia.org/wiki/Endianness>`_ determines order of bytes in a bytes sequence.
     """
 
-    LITTLE_ENDIAN = "little"
+    LITTLE_ENDIAN: "Endianness" = "little"  # type: ignore
     """Little Endian stores the most significant byte at the largest memory address and the least significant byte
     at the smallest."""
-    BIG_ENDIAN = "big"
+    BIG_ENDIAN: "Endianness" = "big"  # type: ignore
     """Big Endian stores the most significant byte at the smallest memory address and the least significant byte
     at the largest."""
 
 
-EndiannessAlias = Union[Endianness, str]
-"""Alias that describes :class:`~uds.utilities.bytes_operations.Endianness` member type."""
-
-
-def bytes_list_to_int(bytes_list: RawBytes, endianness: EndiannessAlias = Endianness.BIG_ENDIAN) -> int:
+def bytes_list_to_int(bytes_list: RawBytesAlias, endianness: Endianness = Endianness.BIG_ENDIAN) -> int:
     """
     Convert a list of bytes to integer value.
 
@@ -41,12 +37,12 @@ def bytes_list_to_int(bytes_list: RawBytes, endianness: EndiannessAlias = Endian
     """
     validate_raw_bytes(bytes_list)
     Endianness.validate_member(endianness)
-    return int.from_bytes(bytes=bytes_list, byteorder=endianness)  # type: ignore
+    return int.from_bytes(bytes=bytes_list, byteorder=endianness)
 
 
 def int_to_bytes_list(int_value: int,
                       list_size: Optional[int] = None,
-                      endianness: EndiannessAlias = Endianness.BIG_ENDIAN) -> RawBytesList:
+                      endianness: Endianness = Endianness.BIG_ENDIAN) -> RawBytesListAlias:
     """
     Convert integer value to a list of bytes.
 
diff --git a/uds/utilities/common_types.py b/uds/utilities/common_types.py
index d1c30316..3d66864f 100644
--- a/uds/utilities/common_types.py
+++ b/uds/utilities/common_types.py
@@ -1,20 +1,20 @@
 """Module with all common types (and its aliases) used in the package and helper functions for these types."""
 
-__all__ = ["TimeMilliseconds", "RawBytes", "RawBytesTuple", "RawBytesList", "RawBytesSet",
+__all__ = ["TimeMillisecondsAlias", "RawBytesAlias", "RawBytesTupleAlias", "RawBytesListAlias", "RawBytesSetAlias",
            "validate_nibble", "validate_raw_byte", "validate_raw_bytes"]
 
-from typing import Union, Tuple, List, Set, Any
+from typing import Any, Union, Tuple, List, Set
 
 
-TimeMilliseconds = Union[int, float]
+TimeMillisecondsAlias = Union[int, float]
 """Alias of a time value in milliseconds."""
-RawBytesTuple = Tuple[int, ...]
+RawBytesTupleAlias = Tuple[int, ...]
 """Alias of a tuple filled with byte values."""
-RawBytesSet = Set[int]
+RawBytesSetAlias = Set[int]
 """Alias of a set filled with byte values."""
-RawBytesList = List[int]
+RawBytesListAlias = List[int]
 """Alias of a list filled with byte values."""
-RawBytes = Union[RawBytesTuple, RawBytesList, bytearray]
+RawBytesAlias = Union[RawBytesTupleAlias, RawBytesListAlias, bytearray]
 """Alias of a sequence filled with byte values."""
 
 
@@ -48,7 +48,7 @@ def validate_raw_byte(value: Any) -> None:
         raise ValueError(f"Provided value is out of byte values range (0x00-0xFF). Actual value: {value}")
 
 
-def validate_raw_bytes(value: Any, allow_empty: bool = False) -> None:
+def validate_raw_bytes(value: RawBytesAlias, allow_empty: bool = False) -> None:
     """
     Validate whether provided value stores raw bytes value.
 
diff --git a/uds/utilities/enums.py b/uds/utilities/enums.py
index 60e932a6..a5a12f6a 100644
--- a/uds/utilities/enums.py
+++ b/uds/utilities/enums.py
@@ -51,13 +51,13 @@ def is_member(cls, value: Any) -> bool:
         :return: True if given argument is a member or a value of this Enum, else False.
         """
         try:
-            cls(value)
+            cls.validate_member(value)
         except ValueError:
             return False
         return True
 
     @classmethod
-    def validate_member(cls, value: Any) -> None:
+    def validate_member(cls, value: Any) -> "ValidatedEnum":
         """
         Validate whether given argument is a member or a value stored by this Enum.
 
@@ -65,7 +65,10 @@ def validate_member(cls, value: Any) -> None:
 
         :raise ValueError: Provided value is not a member neither a value of this Enum.
         """
-        if not cls.is_member(value):
+        try:
+            return cls(value)
+        except ValueError:
+            # pylint: disable=raise-missing-from
             raise ValueError(f"Provided value is not a member of this Enum. Actual value: {value}")
 
 
@@ -80,7 +83,7 @@ def __new__(cls, value: int):
         """
         validate_raw_byte(value)
         member = int.__new__(cls, value)
-        member._value_ = value  # noqa
+        member._value_ = value  # noqa: F841
         return member
 
 
@@ -95,5 +98,5 @@ def __new__(cls, value: int):
         """
         validate_nibble(value)
         member = int.__new__(cls, value)
-        member._value_ = value  # noqa
+        member._value_ = value  # noqa: F841
         return member


Test patch:
diff --git a/tests/software_tests/message/test_service_identifiers.py b/tests/software_tests/message/test_service_identifiers.py
index 9d1d0e3c..d5ab2ae0 100644
--- a/tests/software_tests/message/test_service_identifiers.py
+++ b/tests/software_tests/message/test_service_identifiers.py
@@ -16,13 +16,13 @@ def setup_method(self):
         self.mock_warn = self._patcher_warn.start()
         self._patcher_is_member = patch(f"{SCRIPT_LOCATION}.RequestSID.is_member")
         self.mock_is_member = self._patcher_is_member.start()
-        self._patcher_possible_request_sids = patch(f"{SCRIPT_LOCATION}.POSSIBLE_REQUEST_SIDS")
-        self.mock_possible_request_sids = self._patcher_possible_request_sids.start()
+        self.patcher_all_request_sids = patch(f"{SCRIPT_LOCATION}.ALL_REQUEST_SIDS")
+        self.mock_all_request_sids = self.patcher_all_request_sids.start()
 
     def teardown_method(self):
         self._patcher_warn.stop()
         self._patcher_is_member.stop()
-        self._patcher_possible_request_sids.stop()
+        self.patcher_all_request_sids.stop()
 
     def test_inheritance__byte_enum(self):
         assert issubclass(RequestSID, ByteEnum)
@@ -36,29 +36,29 @@ def test_inheritance__extendable_enum(self):
     @pytest.mark.parametrize("value", [1, 0x55, 0xFF])
     def test_is_request_sid__member(self, value):
         self.mock_is_member.return_value = True
-        self.mock_possible_request_sids.__contains__.return_value = True
+        self.mock_all_request_sids.__contains__.return_value = True
         assert RequestSID.is_request_sid(value=value) is True
         self.mock_warn.assert_not_called()
         self.mock_is_member.assert_called_once_with(value)
-        self.mock_possible_request_sids.__contains__.assert_called_once_with(value)
+        self.mock_all_request_sids.__contains__.assert_called_once_with(value)
 
     @pytest.mark.parametrize("value", [1, 0x55, 0xFF])
     def test_is_request_sid__unsupported(self, value):
         self.mock_is_member.return_value = False
-        self.mock_possible_request_sids.__contains__.return_value = True
+        self.mock_all_request_sids.__contains__.return_value = True
         assert RequestSID.is_request_sid(value=value) is True
         self.mock_warn.assert_called_once()
         self.mock_is_member.assert_called_once_with(value)
-        self.mock_possible_request_sids.__contains__.assert_called_once_with(value)
+        self.mock_all_request_sids.__contains__.assert_called_once_with(value)
 
     @pytest.mark.parametrize("value", [1, 0x55, 0xFF])
     def test_is_request_sid__invalid(self, value):
         self.mock_is_member.return_value = False
-        self.mock_possible_request_sids.__contains__.return_value = False
+        self.mock_all_request_sids.__contains__.return_value = False
         assert RequestSID.is_request_sid(value=value) is False
         self.mock_warn.assert_not_called()
         self.mock_is_member.assert_not_called()
-        self.mock_possible_request_sids.__contains__.assert_called_once_with(value)
+        self.mock_all_request_sids.__contains__.assert_called_once_with(value)
 
 
 class TestResponseSID:
@@ -69,13 +69,13 @@ def setup_method(self):
         self.mock_warn = self._patcher_warn.start()
         self._patcher_is_member = patch(f"{SCRIPT_LOCATION}.ResponseSID.is_member")
         self.mock_is_member = self._patcher_is_member.start()
-        self._patcher_possible_response_sids = patch(f"{SCRIPT_LOCATION}.POSSIBLE_RESPONSE_SIDS")
-        self.mock_possible_response_sids = self._patcher_possible_response_sids.start()
+        self.patcher_all_response_sids = patch(f"{SCRIPT_LOCATION}.ALL_RESPONSE_SIDS")
+        self.mock_all_response_sids = self.patcher_all_response_sids.start()
 
     def teardown_method(self):
         self._patcher_warn.stop()
         self._patcher_is_member.stop()
-        self._patcher_possible_response_sids.stop()
+        self.patcher_all_response_sids.stop()
 
     def test_inheritance__byte_enum(self):
         assert issubclass(ResponseSID, ByteEnum)
@@ -89,29 +89,29 @@ def test_inheritance__extendable_enum(self):
     @pytest.mark.parametrize("value", [1, 0x55, 0xFF])
     def test_is_response_sid__member(self, value):
         self.mock_is_member.return_value = True
-        self.mock_possible_response_sids.__contains__.return_value = True
+        self.mock_all_response_sids.__contains__.return_value = True
         assert ResponseSID.is_response_sid(value=value) is True
         self.mock_warn.assert_not_called()
         self.mock_is_member.assert_called_once_with(value)
-        self.mock_possible_response_sids.__contains__.assert_called_once_with(value)
+        self.mock_all_response_sids.__contains__.assert_called_once_with(value)
 
     @pytest.mark.parametrize("value", [1, 0x55, 0xFF])
     def test_is_response_sid__unsupported(self, value):
         self.mock_is_member.return_value = False
-        self.mock_possible_response_sids.__contains__.return_value = True
+        self.mock_all_response_sids.__contains__.return_value = True
         assert ResponseSID.is_response_sid(value=value) is True
         self.mock_warn.assert_called_once()
         self.mock_is_member.assert_called_once_with(value)
-        self.mock_possible_response_sids.__contains__.assert_called_once_with(value)
+        self.mock_all_response_sids.__contains__.assert_called_once_with(value)
 
     @pytest.mark.parametrize("value", [1, 0x55, 0xFF])
     def test_is_response_sid__invalid(self, value):
         self.mock_is_member.return_value = False
-        self.mock_possible_response_sids.__contains__.return_value = False
+        self.mock_all_response_sids.__contains__.return_value = False
         assert ResponseSID.is_response_sid(value=value) is False
         self.mock_warn.assert_not_called()
         self.mock_is_member.assert_not_called()
-        self.mock_possible_response_sids.__contains__.assert_called_once_with(value)
+        self.mock_all_response_sids.__contains__.assert_called_once_with(value)
 
 
 @pytest.mark.integration
diff --git a/tests/software_tests/message/test_uds_message.py b/tests/software_tests/message/test_uds_message.py
index 6d3602e0..ca07cd9b 100644
--- a/tests/software_tests/message/test_uds_message.py
+++ b/tests/software_tests/message/test_uds_message.py
@@ -78,7 +78,7 @@ def test_addressing_type__get(self, value):
 
     def test_addressing_type__set(self, example_addressing_type):
         UdsMessage.addressing_type.fset(self.mock_uds_message, value=example_addressing_type)
-        assert self.mock_uds_message._UdsMessage__addressing_type == example_addressing_type
+        assert self.mock_uds_message._UdsMessage__addressing_type == self.mock_validate_addressing.return_value
         self.mock_validate_addressing.assert_called_once_with(example_addressing_type)
 
     def test_addressing_type__set_second_call(self, example_addressing_type):
diff --git a/tests/software_tests/packet/test_abstract_packet.py b/tests/software_tests/packet/test_abstract_packet.py
index edfcb7c4..a4a4bc6a 100644
--- a/tests/software_tests/packet/test_abstract_packet.py
+++ b/tests/software_tests/packet/test_abstract_packet.py
@@ -65,7 +65,7 @@ def test_direction__get(self, direction):
 
     def test_direction__set(self, example_transmission_direction):
         AbstractUdsPacketRecord.direction.fset(self.mock_packet_record, value=example_transmission_direction)
-        assert self.mock_packet_record._AbstractUdsPacketRecord__direction == example_transmission_direction
+        assert self.mock_packet_record._AbstractUdsPacketRecord__direction == self.mock_validate_direction.return_value
         self.mock_validate_direction.assert_called_once_with(example_transmission_direction)
 
     @pytest.mark.parametrize("old_value", [None, 0, "some direction"])
diff --git a/tests/software_tests/packet/test_can_packet_record.py b/tests/software_tests/packet/test_can_packet_record.py
index 9b5814dc..49827075 100644
--- a/tests/software_tests/packet/test_can_packet_record.py
+++ b/tests/software_tests/packet/test_can_packet_record.py
@@ -60,18 +60,16 @@ def test_init(self, frame, direction, addressing_type, addressing_format, transm
                                  addressing_format=addressing_format,
                                  transmission_time=transmission_time)
         assert self.mock_can_packet_record._CanPacketRecord__addressing_type \
-               == self.mock_addressing_type_class.return_value
+               == self.mock_addressing_type_class.validate_member.return_value
         assert self.mock_can_packet_record._CanPacketRecord__addressing_format \
-               == self.mock_can_addressing_format_class.return_value
+               == self.mock_can_addressing_format_class.validate_member.return_value
         self.mock_abstract_uds_packet_record_init.assert_called_once_with(frame=frame,
                                                                           direction=direction,
                                                                           transmission_time=transmission_time)
         self.mock_can_packet_record._CanPacketRecord__assess_packet_type.assert_called_once_with()
         self.mock_can_packet_record._CanPacketRecord__assess_ai_attributes.assert_called_once_with()
         self.mock_addressing_type_class.validate_member.assert_called_once_with(addressing_type)
-        self.mock_addressing_type_class.assert_called_once_with(addressing_type)
         self.mock_can_addressing_format_class.validate_member.assert_called_once_with(addressing_format)
-        self.mock_can_addressing_format_class.assert_called_once_with(addressing_format)
 
     # raw_frame_data
 
@@ -160,12 +158,12 @@ def test_assess_packet_type(self, raw_frame_data, ai_data_bytes_number):
         self.mock_can_packet_record.raw_frame_data = raw_frame_data
         self.mock_can_ai_class.get_ai_data_bytes_number.return_value = ai_data_bytes_number
         assert CanPacketRecord._CanPacketRecord__assess_packet_type(self=self.mock_can_packet_record) is None
-        assert self.mock_can_packet_record._CanPacketRecord__packet_type == self.mock_can_packet_type_class.return_value
+        assert self.mock_can_packet_record._CanPacketRecord__packet_type \
+               == self.mock_can_packet_type_class.validate_member.return_value
         n_pci_value = raw_frame_data[ai_data_bytes_number] >> 4
         self.mock_can_ai_class.get_ai_data_bytes_number.assert_called_once_with(
             self.mock_can_packet_record.addressing_format)
         self.mock_can_packet_type_class.validate_member.assert_called_once_with(n_pci_value)
-        self.mock_can_packet_type_class.assert_called_once_with(n_pci_value)
 
     # __assess_ai_attributes
 
@@ -195,8 +193,8 @@ def test_assess_ai_attributes(self, addressing_format, can_id, raw_frame_data,
         assert CanPacketRecord._CanPacketRecord__assess_ai_attributes(self=self.mock_can_packet_record) is None
         self.mock_can_ai_class.get_ai_data_bytes_number.assert_called_once_with(addressing_format)
         self.mock_can_ai_class.decode_packet_ai.assert_called_once_with(addressing_format=addressing_format,
-                                                                         can_id=can_id,
-                                                                         ai_data_bytes=raw_frame_data[:ai_data_bytes_number])
+                                                                        can_id=can_id,
+                                                                        ai_data_bytes=raw_frame_data[:ai_data_bytes_number])
         assert self.mock_can_packet_record._CanPacketRecord__target_address == decoded_ai["target_address"]
         assert self.mock_can_packet_record._CanPacketRecord__source_address == decoded_ai["source_address"]
         assert self.mock_can_packet_record._CanPacketRecord__address_extension == decoded_ai["address_extension"]
diff --git a/tests/software_tests/utilities/test_enums.py b/tests/software_tests/utilities/test_enums.py
index 68d6e1e5..44b48f0b 100644
--- a/tests/software_tests/utilities/test_enums.py
+++ b/tests/software_tests/utilities/test_enums.py
@@ -1,5 +1,4 @@
 import pytest
-from mock import patch
 from aenum import IntEnum, StrEnum
 
 from uds.utilities.enums import ExtendableEnum, ValidatedEnum, ByteEnum, NibbleEnum
@@ -111,22 +110,25 @@ def test_is_member__false(self, enum_class, not_member):
 
     # validate_member
 
-    @patch(f"{SCRIPT_LOCATION}.ValidatedEnum.is_member")
     @pytest.mark.parametrize("enum_class", [ExampleByteEnum1, ExampleByteEnum2])
-    @pytest.mark.parametrize("value", [None, ExampleByteEnum1.A, ExampleByteEnum2.Value1.value, 5])
-    def test_validate_member__valid(self, mock_is_member, enum_class, value):
-        mock_is_member.return_value = True
-        assert enum_class.validate_member(value) is None
-        mock_is_member.assert_called_once_with(value)
+    def test_validate_member__valid_instance(self, enum_class):
+        assert all([enum_class.validate_member(member) == member for member in enum_class])
 
-    @patch(f"{SCRIPT_LOCATION}.ValidatedEnum.is_member")
     @pytest.mark.parametrize("enum_class", [ExampleByteEnum1, ExampleByteEnum2])
-    @pytest.mark.parametrize("value", [None, ExampleByteEnum1.A, ExampleByteEnum2.Value1.value, 5])
-    def test_validate_member__invalid(self, mock_is_member, enum_class, value):
-        mock_is_member.return_value = False
+    def test_validate_member__valid_value(self, enum_class):
+        assert all([enum_class.validate_member(member.value) == member for member in enum_class])
+
+    @pytest.mark.parametrize("enum_class, not_member", [
+        (ExampleByteEnum1, ExampleByteEnum2.Value1),
+        (ExampleByteEnum1, ExampleByteEnum2.Value2.value),
+        (ExampleByteEnum1, "not a member"),
+        (ExampleByteEnum2, ExampleByteEnum1.A),
+        (ExampleByteEnum2, ExampleByteEnum1.B.value),
+        (ExampleByteEnum2, "some crap"),
+    ])
+    def test_validate_member__invalid(self, enum_class, not_member):
         with pytest.raises(ValueError):
-            enum_class.validate_member(value)
-        mock_is_member.assert_called_once_with(value)
+            enum_class.validate_member(not_member)
 
 
 class TestExtendableEnum:
@@ -223,22 +225,27 @@ def test_is_member__false(self, enum_class, not_member):
 
     # validate_member
 
-    @patch(f"{SCRIPT_LOCATION}.ValidatedEnum.is_member")
     @pytest.mark.parametrize("enum_class", [ExtendableByteEnumWithValidated, ValidatedIntEnum])
-    @pytest.mark.parametrize("value", [None, ExtendableByteEnumWithValidated.V1, ValidatedIntEnum.Int1.value, 5])
-    def test_validate_member__valid(self, mock_is_member, enum_class, value):
-        mock_is_member.return_value = True
-        assert enum_class.validate_member(value) is None
-        mock_is_member.assert_called_once_with(value)
+    def test_validate_member__valid_instance(self, enum_class):
+        assert all([enum_class.validate_member(member) == member for member in enum_class])
 
-    @patch(f"{SCRIPT_LOCATION}.ValidatedEnum.is_member")
     @pytest.mark.parametrize("enum_class", [ExtendableByteEnumWithValidated, ValidatedIntEnum])
-    @pytest.mark.parametrize("value", [None, ExtendableByteEnumWithValidated.V1, ValidatedIntEnum.Int1.value, 5])
-    def test_validate_member__invalid(self, mock_is_member, enum_class, value):
-        mock_is_member.return_value = False
+    def test_validate_member__valid_value(self, enum_class):
+        assert all([enum_class.validate_member(member.value) == member for member in enum_class])
+
+    @pytest.mark.parametrize("enum_class, not_member", [
+        (ExtendableByteEnumWithValidated, ExtendableStrEnum.Text1),
+        (ExtendableByteEnumWithValidated, "not a member"),
+        (ExtendableByteEnumWithValidated, 0xFF),
+        (ExtendableByteEnumWithValidated, 0x00),
+        (ValidatedIntEnum, -1),
+        (ValidatedIntEnum, ExtendableByteEnumWithValidated.V1),
+        (ValidatedIntEnum, None),
+        (ValidatedIntEnum, "some crap"),
+    ])
+    def test_validate_member__invalid(self, enum_class, not_member):
         with pytest.raises(ValueError):
-            enum_class.validate_member(value)
-        mock_is_member.assert_called_once_with(value)
+            enum_class.validate_member(not_member)
 
     # add_member