bumble 0.0.211__py3-none-any.whl → 0.0.213__py3-none-any.whl

bumble/l2cap.py

@@ -24,21 +24,19 @@ import struct
 
 from collections import deque
 from typing import (
-    Dict,
-    Type,
-    List,
     Optional,
-    Tuple,
     Callable,
     Any,
     Union,
-    Deque,
     Iterable,
     SupportsBytes,
+    TypeVar,
+    ClassVar,
     TYPE_CHECKING,
 )
 
 from bumble import utils
+from bumble import hci
 from bumble.colors import color
 from bumble.core import (
     InvalidStateError,
@@ -47,13 +45,6 @@ from bumble.core import (
     OutOfResourcesError,
     ProtocolError,
 )
-from bumble.hci import (
-    HCI_LE_Connection_Update_Command,
-    HCI_Object,
-    Role,
-    key_with_value,
-    name_or_number,
-)
 
 if TYPE_CHECKING:
     from bumble.device import Connection
@@ -98,54 +89,29 @@ L2CAP_PSM_DYNAMIC_RANGE_END   = 0xFFFF
 L2CAP_LE_PSM_DYNAMIC_RANGE_START = 0x0080
 L2CAP_LE_PSM_DYNAMIC_RANGE_END   = 0x00FF
 
-# Frame types
-L2CAP_COMMAND_REJECT                       = 0x01
-L2CAP_CONNECTION_REQUEST                   = 0x02
-L2CAP_CONNECTION_RESPONSE                  = 0x03
-L2CAP_CONFIGURE_REQUEST                    = 0x04
-L2CAP_CONFIGURE_RESPONSE                   = 0x05
-L2CAP_DISCONNECTION_REQUEST                = 0x06
-L2CAP_DISCONNECTION_RESPONSE               = 0x07
-L2CAP_ECHO_REQUEST                         = 0x08
-L2CAP_ECHO_RESPONSE                        = 0x09
-L2CAP_INFORMATION_REQUEST                  = 0x0A
-L2CAP_INFORMATION_RESPONSE                 = 0x0B
-L2CAP_CREATE_CHANNEL_REQUEST               = 0x0C
-L2CAP_CREATE_CHANNEL_RESPONSE              = 0x0D
-L2CAP_MOVE_CHANNEL_REQUEST                 = 0x0E
-L2CAP_MOVE_CHANNEL_RESPONSE                = 0x0F
-L2CAP_MOVE_CHANNEL_CONFIRMATION            = 0x10
-L2CAP_MOVE_CHANNEL_CONFIRMATION_RESPONSE   = 0x11
-L2CAP_CONNECTION_PARAMETER_UPDATE_REQUEST  = 0x12
-L2CAP_CONNECTION_PARAMETER_UPDATE_RESPONSE = 0x13
-L2CAP_LE_CREDIT_BASED_CONNECTION_REQUEST   = 0x14
-L2CAP_LE_CREDIT_BASED_CONNECTION_RESPONSE  = 0x15
-L2CAP_LE_FLOW_CONTROL_CREDIT               = 0x16
-
-L2CAP_CONTROL_FRAME_NAMES = {
-    L2CAP_COMMAND_REJECT:                       'L2CAP_COMMAND_REJECT',
-    L2CAP_CONNECTION_REQUEST:                   'L2CAP_CONNECTION_REQUEST',
-    L2CAP_CONNECTION_RESPONSE:                  'L2CAP_CONNECTION_RESPONSE',
-    L2CAP_CONFIGURE_REQUEST:                    'L2CAP_CONFIGURE_REQUEST',
-    L2CAP_CONFIGURE_RESPONSE:                   'L2CAP_CONFIGURE_RESPONSE',
-    L2CAP_DISCONNECTION_REQUEST:                'L2CAP_DISCONNECTION_REQUEST',
-    L2CAP_DISCONNECTION_RESPONSE:               'L2CAP_DISCONNECTION_RESPONSE',
-    L2CAP_ECHO_REQUEST:                         'L2CAP_ECHO_REQUEST',
-    L2CAP_ECHO_RESPONSE:                        'L2CAP_ECHO_RESPONSE',
-    L2CAP_INFORMATION_REQUEST:                  'L2CAP_INFORMATION_REQUEST',
-    L2CAP_INFORMATION_RESPONSE:                 'L2CAP_INFORMATION_RESPONSE',
-    L2CAP_CREATE_CHANNEL_REQUEST:               'L2CAP_CREATE_CHANNEL_REQUEST',
-    L2CAP_CREATE_CHANNEL_RESPONSE:              'L2CAP_CREATE_CHANNEL_RESPONSE',
-    L2CAP_MOVE_CHANNEL_REQUEST:                 'L2CAP_MOVE_CHANNEL_REQUEST',
-    L2CAP_MOVE_CHANNEL_RESPONSE:                'L2CAP_MOVE_CHANNEL_RESPONSE',
-    L2CAP_MOVE_CHANNEL_CONFIRMATION:            'L2CAP_MOVE_CHANNEL_CONFIRMATION',
-    L2CAP_MOVE_CHANNEL_CONFIRMATION_RESPONSE:   'L2CAP_MOVE_CHANNEL_CONFIRMATION_RESPONSE',
-    L2CAP_CONNECTION_PARAMETER_UPDATE_REQUEST:  'L2CAP_CONNECTION_PARAMETER_UPDATE_REQUEST',
-    L2CAP_CONNECTION_PARAMETER_UPDATE_RESPONSE: 'L2CAP_CONNECTION_PARAMETER_UPDATE_RESPONSE',
-    L2CAP_LE_CREDIT_BASED_CONNECTION_REQUEST:   'L2CAP_LE_CREDIT_BASED_CONNECTION_REQUEST',
-    L2CAP_LE_CREDIT_BASED_CONNECTION_RESPONSE:  'L2CAP_LE_CREDIT_BASED_CONNECTION_RESPONSE',
-    L2CAP_LE_FLOW_CONTROL_CREDIT:               'L2CAP_LE_FLOW_CONTROL_CREDIT'
-}
+class CommandCode(hci.SpecableEnum):
+    L2CAP_COMMAND_REJECT                       = 0x01
+    L2CAP_CONNECTION_REQUEST                   = 0x02
+    L2CAP_CONNECTION_RESPONSE                  = 0x03
+    L2CAP_CONFIGURE_REQUEST                    = 0x04
+    L2CAP_CONFIGURE_RESPONSE                   = 0x05
+    L2CAP_DISCONNECTION_REQUEST                = 0x06
+    L2CAP_DISCONNECTION_RESPONSE               = 0x07
+    L2CAP_ECHO_REQUEST                         = 0x08
+    L2CAP_ECHO_RESPONSE                        = 0x09
+    L2CAP_INFORMATION_REQUEST                  = 0x0A
+    L2CAP_INFORMATION_RESPONSE                 = 0x0B
+    L2CAP_CREATE_CHANNEL_REQUEST               = 0x0C
+    L2CAP_CREATE_CHANNEL_RESPONSE              = 0x0D
+    L2CAP_MOVE_CHANNEL_REQUEST                 = 0x0E
+    L2CAP_MOVE_CHANNEL_RESPONSE                = 0x0F
+    L2CAP_MOVE_CHANNEL_CONFIRMATION            = 0x10
+    L2CAP_MOVE_CHANNEL_CONFIRMATION_RESPONSE   = 0x11
+    L2CAP_CONNECTION_PARAMETER_UPDATE_REQUEST  = 0x12
+    L2CAP_CONNECTION_PARAMETER_UPDATE_RESPONSE = 0x13
+    L2CAP_LE_CREDIT_BASED_CONNECTION_REQUEST   = 0x14
+    L2CAP_LE_CREDIT_BASED_CONNECTION_RESPONSE  = 0x15
+    L2CAP_LE_FLOW_CONTROL_CREDIT               = 0x16
 
 L2CAP_CONNECTION_PARAMETERS_ACCEPTED_RESULT = 0x0000
 L2CAP_CONNECTION_PARAMETERS_REJECTED_RESULT = 0x0001
@@ -237,46 +203,47 @@ class L2CAP_PDU:
 
 
 # -----------------------------------------------------------------------------
+@dataclasses.dataclass
 class L2CAP_Control_Frame:
     '''
     See Bluetooth spec @ Vol 3, Part A - 4 SIGNALING PACKET FORMATS
     '''
 
-    classes: Dict[int, Type[L2CAP_Control_Frame]] = {}
-    code = 0
-    name: str
+    classes: ClassVar[dict[int, type[L2CAP_Control_Frame]]] = {}
+    fields: ClassVar[hci.Fields] = ()
+    code: int = dataclasses.field(default=0, init=False)
+    name: str = dataclasses.field(default='', init=False)
+    _data: Optional[bytes] = dataclasses.field(default=None, init=False)
 
-    @staticmethod
-    def from_bytes(pdu: bytes) -> L2CAP_Control_Frame:
-        code = pdu[0]
+    identifier: int
+
+    @classmethod
+    def from_bytes(cls, pdu: bytes) -> L2CAP_Control_Frame:
+        code, identifier, length = struct.unpack_from("<BBH", pdu)
 
-        cls = L2CAP_Control_Frame.classes.get(code)
-        if cls is None:
+        subclass = L2CAP_Control_Frame.classes.get(code)
+        if subclass is None:
             instance = L2CAP_Control_Frame(pdu)
-            instance.name = L2CAP_Control_Frame.code_name(code)
-            instance.code = code
+            instance.code = CommandCode(code)
+            instance.name = instance.code.name
             return instance
-        self = cls.__new__(cls)
-        L2CAP_Control_Frame.__init__(self, pdu)
-        self.identifier = pdu[1]
-        length = struct.unpack_from('<H', pdu, 2)[0]
-        if length + 4 != len(pdu):
+        frame = subclass(
+            **hci.HCI_Object.dict_from_bytes(pdu, 4, subclass.fields),
+            identifier=identifier,
+        )
+        frame.identifier = identifier
+        frame.data = pdu[4:]
+        if length != len(pdu):
             logger.warning(
                 color(
                     f'!!! length mismatch: expected {len(pdu) - 4} but got {length}',
                     'red',
                 )
             )
-        if hasattr(self, 'fields'):
-            self.init_from_bytes(pdu, 4)
-        return self
-
-    @staticmethod
-    def code_name(code: int) -> str:
-        return name_or_number(L2CAP_CONTROL_FRAME_NAMES, code)
+        return frame
 
     @staticmethod
-    def decode_configuration_options(data: bytes) -> List[Tuple[int, bytes]]:
+    def decode_configuration_options(data: bytes) -> list[tuple[int, bytes]]:
         options = []
         while len(data) >= 2:
             value_type = data[0]
@@ -288,119 +255,91 @@ class L2CAP_Control_Frame:
         return options
 
     @staticmethod
-    def encode_configuration_options(options: List[Tuple[int, bytes]]) -> bytes:
+    def encode_configuration_options(options: list[tuple[int, bytes]]) -> bytes:
         return b''.join(
             [bytes([option[0], len(option[1])]) + option[1] for option in options]
         )
 
-    @staticmethod
-    def subclass(fields):
-        def inner(cls):
-            cls.name = cls.__name__.upper()
-            cls.code = key_with_value(L2CAP_CONTROL_FRAME_NAMES, cls.name)
-            if cls.code is None:
-                raise KeyError(
-                    f'Control Frame name {cls.name} '
-                    'not found in L2CAP_CONTROL_FRAME_NAMES'
-                )
-            cls.fields = fields
+    _ControlFrame = TypeVar('_ControlFrame', bound='L2CAP_Control_Frame')
 
-            # Register a factory for this class
-            L2CAP_Control_Frame.classes[cls.code] = cls
+    @classmethod
+    def subclass(cls, subclass: type[_ControlFrame]) -> type[_ControlFrame]:
+        subclass.name = subclass.__name__.upper()
+        subclass.code = CommandCode[subclass.name]
+        subclass.fields = hci.HCI_Object.fields_from_dataclass(subclass)
 
-            return cls
+        # Register a factory for this class
+        L2CAP_Control_Frame.classes[subclass.code] = subclass
 
-        return inner
+        return subclass
 
-    def __init__(self, pdu=None, **kwargs) -> None:
+    def __init__(self, pdu: Optional[bytes] = None, **kwargs) -> None:
         self.identifier = kwargs.get('identifier', 0)
-        if hasattr(self, 'fields'):
+        if self.fields:
             if kwargs:
-                HCI_Object.init_from_fields(self, self.fields, kwargs)
+                hci.HCI_Object.init_from_fields(self, self.fields, kwargs)
             if pdu is None:
-                data = HCI_Object.dict_to_bytes(kwargs, self.fields)
+                data = hci.HCI_Object.dict_to_bytes(kwargs, self.fields)
                 pdu = (
                     bytes([self.code, self.identifier])
                     + struct.pack('<H', len(data))
                     + data
                 )
-        self.pdu = pdu
+        self.data = pdu[4:] if pdu else b''
 
-    def init_from_bytes(self, pdu, offset):
-        return HCI_Object.init_from_bytes(self, pdu, offset, self.fields)
+    @property
+    def data(self) -> bytes:
+        if self._data is None:
+            self._data = hci.HCI_Object.dict_to_bytes(self.__dict__, self.fields)
+        return self._data
+
+    @data.setter
+    def data(self, parameters: bytes) -> None:
+        self._data = parameters
 
     def __bytes__(self) -> bytes:
-        return self.pdu
+        return (
+            struct.pack('<BBH', self.code, self.identifier, len(self.data) + 4)
+            + self.data
+        )
 
     def __str__(self) -> str:
         result = f'{color(self.name, "yellow")} [ID={self.identifier}]'
         if fields := getattr(self, 'fields', None):
-            result += ':\n' + HCI_Object.format_fields(self.__dict__, fields, '  ')
+            result += ':\n' + hci.HCI_Object.format_fields(self.__dict__, fields, '  ')
         else:
-            if len(self.pdu) > 1:
-                result += f': {self.pdu.hex()}'
+            if len(self.data) > 1:
+                result += f': {self.data.hex()}'
         return result
 
 
 # -----------------------------------------------------------------------------
-@L2CAP_Control_Frame.subclass(
-    # pylint: disable=unnecessary-lambda
-    [
-        (
-            'reason',
-            {'size': 2, 'mapper': lambda x: L2CAP_Command_Reject.reason_name(x)},
-        ),
-        ('data', '*'),
-    ]
-)
+@L2CAP_Control_Frame.subclass
+@dataclasses.dataclass
 class L2CAP_Command_Reject(L2CAP_Control_Frame):
     '''
     See Bluetooth spec @ Vol 3, Part A - 4.1 COMMAND REJECT
     '''
 
-    COMMAND_NOT_UNDERSTOOD = 0x0000
-    SIGNALING_MTU_EXCEEDED = 0x0001
-    INVALID_CID_IN_REQUEST = 0x0002
+    class Reason(hci.SpecableEnum):
+        COMMAND_NOT_UNDERSTOOD = 0x0000
+        SIGNALING_MTU_EXCEEDED = 0x0001
+        INVALID_CID_IN_REQUEST = 0x0002
 
-    REASON_NAMES = {
-        COMMAND_NOT_UNDERSTOOD: 'COMMAND_NOT_UNDERSTOOD',
-        SIGNALING_MTU_EXCEEDED: 'SIGNALING_MTU_EXCEEDED',
-        INVALID_CID_IN_REQUEST: 'INVALID_CID_IN_REQUEST',
-    }
-
-    @staticmethod
-    def reason_name(reason: int) -> str:
-        return name_or_number(L2CAP_Command_Reject.REASON_NAMES, reason)
+    reason: int = dataclasses.field(metadata=Reason.type_metadata(2))
+    data: bytes = dataclasses.field(metadata=hci.metadata('*'))
 
 
 # -----------------------------------------------------------------------------
-@L2CAP_Control_Frame.subclass(
-    # pylint: disable=unnecessary-lambda
-    [
-        (
-            'psm',
-            {
-                'parser': lambda data, offset: L2CAP_Connection_Request.parse_psm(
-                    data, offset
-                ),
-                'serializer': lambda value: L2CAP_Connection_Request.serialize_psm(
-                    value
-                ),
-            },
-        ),
-        ('source_cid', 2),
-    ]
-)
+@L2CAP_Control_Frame.subclass
+@dataclasses.dataclass
 class L2CAP_Connection_Request(L2CAP_Control_Frame):
     '''
     See Bluetooth spec @ Vol 3, Part A - 4.2 CONNECTION REQUEST
     '''
 
-    psm: int
-    source_cid: int
-
     @staticmethod
-    def parse_psm(data: bytes, offset: int = 0) -> Tuple[int, int]:
+    def parse_psm(data: bytes, offset: int = 0) -> tuple[int, int]:
         psm_length = 2
         psm = data[offset] | data[offset + 1] << 8
 
@@ -421,156 +360,138 @@ class L2CAP_Connection_Request(L2CAP_Control_Frame):
 
         return serialized
 
+    psm: int = dataclasses.field(
+        metadata=hci.metadata(
+            {
+                'parser': lambda data, offset: L2CAP_Connection_Request.parse_psm(
+                    data, offset
+                ),
+                'serializer': lambda value: L2CAP_Connection_Request.serialize_psm(
+                    value
+                ),
+            }
+        )
+    )
+    source_cid: int = dataclasses.field(metadata=hci.metadata(2))
+
 
 # -----------------------------------------------------------------------------
-@L2CAP_Control_Frame.subclass(
-    # pylint: disable=unnecessary-lambda
-    [
-        ('destination_cid', 2),
-        ('source_cid', 2),
-        (
-            'result',
-            {'size': 2, 'mapper': lambda x: L2CAP_Connection_Response.result_name(x)},
-        ),
-        ('status', 2),
-    ]
-)
+@L2CAP_Control_Frame.subclass
+@dataclasses.dataclass
 class L2CAP_Connection_Response(L2CAP_Control_Frame):
     '''
     See Bluetooth spec @ Vol 3, Part A - 4.3 CONNECTION RESPONSE
     '''
 
-    source_cid: int
-    destination_cid: int
-    status: int
-    result: int
-
-    CONNECTION_SUCCESSFUL = 0x0000
-    CONNECTION_PENDING = 0x0001
-    CONNECTION_REFUSED_PSM_NOT_SUPPORTED = 0x0002
-    CONNECTION_REFUSED_SECURITY_BLOCK = 0x0003
-    CONNECTION_REFUSED_NO_RESOURCES_AVAILABLE = 0x0004
-    CONNECTION_REFUSED_INVALID_SOURCE_CID = 0x0006
-    CONNECTION_REFUSED_SOURCE_CID_ALREADY_ALLOCATED = 0x0007
-    CONNECTION_REFUSED_UNACCEPTABLE_PARAMETERS = 0x000B
-
-    # pylint: disable=line-too-long
-    RESULT_NAMES = {
-        CONNECTION_SUCCESSFUL: 'CONNECTION_SUCCESSFUL',
-        CONNECTION_PENDING: 'CONNECTION_PENDING',
-        CONNECTION_REFUSED_PSM_NOT_SUPPORTED: 'CONNECTION_REFUSED_PSM_NOT_SUPPORTED',
-        CONNECTION_REFUSED_SECURITY_BLOCK: 'CONNECTION_REFUSED_SECURITY_BLOCK',
-        CONNECTION_REFUSED_NO_RESOURCES_AVAILABLE: 'CONNECTION_REFUSED_NO_RESOURCES_AVAILABLE',
-        CONNECTION_REFUSED_INVALID_SOURCE_CID: 'CONNECTION_REFUSED_INVALID_SOURCE_CID',
-        CONNECTION_REFUSED_SOURCE_CID_ALREADY_ALLOCATED: 'CONNECTION_REFUSED_SOURCE_CID_ALREADY_ALLOCATED',
-        CONNECTION_REFUSED_UNACCEPTABLE_PARAMETERS: 'CONNECTION_REFUSED_UNACCEPTABLE_PARAMETERS',
-    }
+    class Result(hci.SpecableEnum):
+        CONNECTION_SUCCESSFUL = 0x0000
+        CONNECTION_PENDING = 0x0001
+        CONNECTION_REFUSED_PSM_NOT_SUPPORTED = 0x0002
+        CONNECTION_REFUSED_SECURITY_BLOCK = 0x0003
+        CONNECTION_REFUSED_NO_RESOURCES_AVAILABLE = 0x0004
+        CONNECTION_REFUSED_INVALID_SOURCE_CID = 0x0006
+        CONNECTION_REFUSED_SOURCE_CID_ALREADY_ALLOCATED = 0x0007
+        CONNECTION_REFUSED_UNACCEPTABLE_PARAMETERS = 0x000B
 
-    @staticmethod
-    def result_name(result: int) -> str:
-        return name_or_number(L2CAP_Connection_Response.RESULT_NAMES, result)
+    destination_cid: int = dataclasses.field(metadata=hci.metadata(2))
+    source_cid: int = dataclasses.field(metadata=hci.metadata(2))
+    result: int = dataclasses.field(metadata=Result.type_metadata(2))
+    status: int = dataclasses.field(metadata=hci.metadata(2))
 
 
 # -----------------------------------------------------------------------------
-@L2CAP_Control_Frame.subclass([('destination_cid', 2), ('flags', 2), ('options', '*')])
+@L2CAP_Control_Frame.subclass
+@dataclasses.dataclass
 class L2CAP_Configure_Request(L2CAP_Control_Frame):
     '''
     See Bluetooth spec @ Vol 3, Part A - 4.4 CONFIGURATION REQUEST
     '''
 
+    destination_cid: int = dataclasses.field(metadata=hci.metadata(2))
+    flags: int = dataclasses.field(metadata=hci.metadata(2))
+    options: bytes = dataclasses.field(metadata=hci.metadata('*'))
+
 
 # -----------------------------------------------------------------------------
-@L2CAP_Control_Frame.subclass(
-    # pylint: disable=unnecessary-lambda
-    [
-        ('source_cid', 2),
-        ('flags', 2),
-        (
-            'result',
-            {'size': 2, 'mapper': lambda x: L2CAP_Configure_Response.result_name(x)},
-        ),
-        ('options', '*'),
-    ]
-)
+@L2CAP_Control_Frame.subclass
+@dataclasses.dataclass
 class L2CAP_Configure_Response(L2CAP_Control_Frame):
     '''
     See Bluetooth spec @ Vol 3, Part A - 4.5 CONFIGURATION RESPONSE
     '''
 
-    SUCCESS = 0x0000
-    FAILURE_UNACCEPTABLE_PARAMETERS = 0x0001
-    FAILURE_REJECTED = 0x0002
-    FAILURE_UNKNOWN_OPTIONS = 0x0003
-    PENDING = 0x0004
-    FAILURE_FLOW_SPEC_REJECTED = 0x0005
-
-    RESULT_NAMES = {
-        SUCCESS: 'SUCCESS',
-        FAILURE_UNACCEPTABLE_PARAMETERS: 'FAILURE_UNACCEPTABLE_PARAMETERS',
-        FAILURE_REJECTED: 'FAILURE_REJECTED',
-        FAILURE_UNKNOWN_OPTIONS: 'FAILURE_UNKNOWN_OPTIONS',
-        PENDING: 'PENDING',
-        FAILURE_FLOW_SPEC_REJECTED: 'FAILURE_FLOW_SPEC_REJECTED',
-    }
+    class Result(hci.SpecableEnum):
+        SUCCESS = 0x0000
+        FAILURE_UNACCEPTABLE_PARAMETERS = 0x0001
+        FAILURE_REJECTED = 0x0002
+        FAILURE_UNKNOWN_OPTIONS = 0x0003
+        PENDING = 0x0004
+        FAILURE_FLOW_SPEC_REJECTED = 0x0005
 
-    @staticmethod
-    def result_name(result: int) -> str:
-        return name_or_number(L2CAP_Configure_Response.RESULT_NAMES, result)
+    source_cid: int = dataclasses.field(metadata=hci.metadata(2))
+    flags: int = dataclasses.field(metadata=hci.metadata(2))
+    result: int = dataclasses.field(metadata=Result.type_metadata(2))
+    options: bytes = dataclasses.field(metadata=hci.metadata('*'))
 
 
 # -----------------------------------------------------------------------------
-@L2CAP_Control_Frame.subclass([('destination_cid', 2), ('source_cid', 2)])
+@L2CAP_Control_Frame.subclass
+@dataclasses.dataclass
 class L2CAP_Disconnection_Request(L2CAP_Control_Frame):
     '''
     See Bluetooth spec @ Vol 3, Part A - 4.6 DISCONNECTION REQUEST
     '''
 
+    destination_cid: int = dataclasses.field(metadata=hci.metadata(2))
+    source_cid: int = dataclasses.field(metadata=hci.metadata(2))
+
 
 # -----------------------------------------------------------------------------
-@L2CAP_Control_Frame.subclass([('destination_cid', 2), ('source_cid', 2)])
+@L2CAP_Control_Frame.subclass
+@dataclasses.dataclass
 class L2CAP_Disconnection_Response(L2CAP_Control_Frame):
     '''
     See Bluetooth spec @ Vol 3, Part A - 4.7 DISCONNECTION RESPONSE
     '''
 
+    destination_cid: int = dataclasses.field(metadata=hci.metadata(2))
+    source_cid: int = dataclasses.field(metadata=hci.metadata(2))
+
 
 # -----------------------------------------------------------------------------
-@L2CAP_Control_Frame.subclass([('data', '*')])
+@L2CAP_Control_Frame.subclass
+@dataclasses.dataclass
 class L2CAP_Echo_Request(L2CAP_Control_Frame):
     '''
     See Bluetooth spec @ Vol 3, Part A - 4.8 ECHO REQUEST
     '''
 
+    data: bytes = dataclasses.field(metadata=hci.metadata('*'))
+
 
 # -----------------------------------------------------------------------------
-@L2CAP_Control_Frame.subclass([('data', '*')])
+@L2CAP_Control_Frame.subclass
+@dataclasses.dataclass
 class L2CAP_Echo_Response(L2CAP_Control_Frame):
     '''
     See Bluetooth spec @ Vol 3, Part A - 4.9 ECHO RESPONSE
     '''
 
+    data: bytes = dataclasses.field(metadata=hci.metadata('*'))
+
 
 # -----------------------------------------------------------------------------
-@L2CAP_Control_Frame.subclass(
-    [
-        (
-            'info_type',
-            {
-                'size': 2,
-                # pylint: disable-next=unnecessary-lambda
-                'mapper': lambda x: L2CAP_Information_Request.info_type_name(x),
-            },
-        )
-    ]
-)
+@L2CAP_Control_Frame.subclass
+@dataclasses.dataclass
 class L2CAP_Information_Request(L2CAP_Control_Frame):
     '''
     See Bluetooth spec @ Vol 3, Part A - 4.10 INFORMATION REQUEST
     '''
 
-    CONNECTIONLESS_MTU = 0x0001
-    EXTENDED_FEATURES_SUPPORTED = 0x0002
-    FIXED_CHANNELS_SUPPORTED = 0x0003
+    class InfoType(hci.SpecableEnum):
+        CONNECTIONLESS_MTU = 0x0001
+        EXTENDED_FEATURES_SUPPORTED = 0x0002
+        FIXED_CHANNELS_SUPPORTED = 0x0003
 
     EXTENDED_FEATURE_FLOW_MODE_CONTROL = 0x0001
     EXTENDED_FEATURE_RETRANSMISSION_MODE = 0x0002
@@ -584,139 +505,108 @@ class L2CAP_Information_Request(L2CAP_Control_Frame):
     EXTENDED_FEATURE_UNICAST_CONNECTIONLESS_DATA = 0x0200
     EXTENDED_FEATURE_ENHANCED_CREDIT_BASE_FLOW_CONTROL = 0x0400
 
-    INFO_TYPE_NAMES = {
-        CONNECTIONLESS_MTU: 'CONNECTIONLESS_MTU',
-        EXTENDED_FEATURES_SUPPORTED: 'EXTENDED_FEATURES_SUPPORTED',
-        FIXED_CHANNELS_SUPPORTED: 'FIXED_CHANNELS_SUPPORTED',
-    }
-
-    @staticmethod
-    def info_type_name(info_type: int) -> str:
-        return name_or_number(L2CAP_Information_Request.INFO_TYPE_NAMES, info_type)
+    info_type: int = dataclasses.field(metadata=InfoType.type_metadata(2))
 
 
 # -----------------------------------------------------------------------------
-@L2CAP_Control_Frame.subclass(
-    [
-        ('info_type', {'size': 2, 'mapper': L2CAP_Information_Request.info_type_name}),
-        (
-            'result',
-            # pylint: disable-next=unnecessary-lambda
-            {'size': 2, 'mapper': lambda x: L2CAP_Information_Response.result_name(x)},
-        ),
-        ('data', '*'),
-    ]
-)
+@L2CAP_Control_Frame.subclass
+@dataclasses.dataclass
 class L2CAP_Information_Response(L2CAP_Control_Frame):
     '''
     See Bluetooth spec @ Vol 3, Part A - 4.11 INFORMATION RESPONSE
     '''
 
-    SUCCESS = 0x00
-    NOT_SUPPORTED = 0x01
-
-    RESULT_NAMES = {SUCCESS: 'SUCCESS', NOT_SUPPORTED: 'NOT_SUPPORTED'}
+    class Result(hci.SpecableEnum):
+        SUCCESS = 0x00
+        NOT_SUPPORTED = 0x01
 
-    @staticmethod
-    def result_name(result: int) -> str:
-        return name_or_number(L2CAP_Information_Response.RESULT_NAMES, result)
+    info_type: int = dataclasses.field(
+        metadata=L2CAP_Information_Request.InfoType.type_metadata(2)
+    )
+    result: int = dataclasses.field(metadata=Result.type_metadata(2))
+    data: bytes = dataclasses.field(metadata=hci.metadata('*'))
 
 
 # -----------------------------------------------------------------------------
-@L2CAP_Control_Frame.subclass(
-    [('interval_min', 2), ('interval_max', 2), ('latency', 2), ('timeout', 2)]
-)
+@L2CAP_Control_Frame.subclass
+@dataclasses.dataclass
 class L2CAP_Connection_Parameter_Update_Request(L2CAP_Control_Frame):
     '''
     See Bluetooth spec @ Vol 3, Part A - 4.20 CONNECTION PARAMETER UPDATE REQUEST
     '''
 
+    interval_min: int = dataclasses.field(metadata=hci.metadata(2))
+    interval_max: int = dataclasses.field(metadata=hci.metadata(2))
+    latency: int = dataclasses.field(metadata=hci.metadata(2))
+    timeout: int = dataclasses.field(metadata=hci.metadata(2))
+
 
 # -----------------------------------------------------------------------------
-@L2CAP_Control_Frame.subclass([('result', 2)])
+@L2CAP_Control_Frame.subclass
+@dataclasses.dataclass
 class L2CAP_Connection_Parameter_Update_Response(L2CAP_Control_Frame):
     '''
     See Bluetooth spec @ Vol 3, Part A - 4.21 CONNECTION PARAMETER UPDATE RESPONSE
     '''
 
+    result: int = dataclasses.field(metadata=hci.metadata(2))
+
 
 # -----------------------------------------------------------------------------
-@L2CAP_Control_Frame.subclass(
-    [('le_psm', 2), ('source_cid', 2), ('mtu', 2), ('mps', 2), ('initial_credits', 2)]
-)
+@L2CAP_Control_Frame.subclass
+@dataclasses.dataclass
 class L2CAP_LE_Credit_Based_Connection_Request(L2CAP_Control_Frame):
     '''
     See Bluetooth spec @ Vol 3, Part A - 4.22 LE CREDIT BASED CONNECTION REQUEST
     (CODE 0x14)
     '''
 
-    source_cid: int
+    le_psm: int = dataclasses.field(metadata=hci.metadata(2))
+    source_cid: int = dataclasses.field(metadata=hci.metadata(2))
+    mtu: int = dataclasses.field(metadata=hci.metadata(2))
+    mps: int = dataclasses.field(metadata=hci.metadata(2))
+    initial_credits: int = dataclasses.field(metadata=hci.metadata(2))
 
 
 # -----------------------------------------------------------------------------
-@L2CAP_Control_Frame.subclass(
-    # pylint: disable=unnecessary-lambda,line-too-long
-    [
-        ('destination_cid', 2),
-        ('mtu', 2),
-        ('mps', 2),
-        ('initial_credits', 2),
-        (
-            'result',
-            {
-                'size': 2,
-                'mapper': lambda x: L2CAP_LE_Credit_Based_Connection_Response.result_name(
-                    x
-                ),
-            },
-        ),
-    ]
-)
+@L2CAP_Control_Frame.subclass
+@dataclasses.dataclass
 class L2CAP_LE_Credit_Based_Connection_Response(L2CAP_Control_Frame):
     '''
     See Bluetooth spec @ Vol 3, Part A - 4.23 LE CREDIT BASED CONNECTION RESPONSE
     (CODE 0x15)
     '''
 
-    CONNECTION_SUCCESSFUL = 0x0000
-    CONNECTION_REFUSED_LE_PSM_NOT_SUPPORTED = 0x0002
-    CONNECTION_REFUSED_NO_RESOURCES_AVAILABLE = 0x0004
-    CONNECTION_REFUSED_INSUFFICIENT_AUTHENTICATION = 0x0005
-    CONNECTION_REFUSED_INSUFFICIENT_AUTHORIZATION = 0x0006
-    CONNECTION_REFUSED_INSUFFICIENT_ENCRYPTION_KEY_SIZE = 0x0007
-    CONNECTION_REFUSED_INSUFFICIENT_ENCRYPTION = 0x0008
-    CONNECTION_REFUSED_INVALID_SOURCE_CID = 0x0009
-    CONNECTION_REFUSED_SOURCE_CID_ALREADY_ALLOCATED = 0x000A
-    CONNECTION_REFUSED_UNACCEPTABLE_PARAMETERS = 0x000B
-
-    # pylint: disable=line-too-long
-    RESULT_NAMES = {
-        CONNECTION_SUCCESSFUL: 'CONNECTION_SUCCESSFUL',
-        CONNECTION_REFUSED_LE_PSM_NOT_SUPPORTED: 'CONNECTION_REFUSED_LE_PSM_NOT_SUPPORTED',
-        CONNECTION_REFUSED_NO_RESOURCES_AVAILABLE: 'CONNECTION_REFUSED_NO_RESOURCES_AVAILABLE',
-        CONNECTION_REFUSED_INSUFFICIENT_AUTHENTICATION: 'CONNECTION_REFUSED_INSUFFICIENT_AUTHENTICATION',
-        CONNECTION_REFUSED_INSUFFICIENT_AUTHORIZATION: 'CONNECTION_REFUSED_INSUFFICIENT_AUTHORIZATION',
-        CONNECTION_REFUSED_INSUFFICIENT_ENCRYPTION_KEY_SIZE: 'CONNECTION_REFUSED_INSUFFICIENT_ENCRYPTION_KEY_SIZE',
-        CONNECTION_REFUSED_INSUFFICIENT_ENCRYPTION: 'CONNECTION_REFUSED_INSUFFICIENT_ENCRYPTION',
-        CONNECTION_REFUSED_INVALID_SOURCE_CID: 'CONNECTION_REFUSED_INVALID_SOURCE_CID',
-        CONNECTION_REFUSED_SOURCE_CID_ALREADY_ALLOCATED: 'CONNECTION_REFUSED_SOURCE_CID_ALREADY_ALLOCATED',
-        CONNECTION_REFUSED_UNACCEPTABLE_PARAMETERS: 'CONNECTION_REFUSED_UNACCEPTABLE_PARAMETERS',
-    }
-
-    @staticmethod
-    def result_name(result: int) -> str:
-        return name_or_number(
-            L2CAP_LE_Credit_Based_Connection_Response.RESULT_NAMES, result
-        )
+    class Result(hci.SpecableEnum):
+        CONNECTION_SUCCESSFUL = 0x0000
+        CONNECTION_REFUSED_LE_PSM_NOT_SUPPORTED = 0x0002
+        CONNECTION_REFUSED_NO_RESOURCES_AVAILABLE = 0x0004
+        CONNECTION_REFUSED_INSUFFICIENT_AUTHENTICATION = 0x0005
+        CONNECTION_REFUSED_INSUFFICIENT_AUTHORIZATION = 0x0006
+        CONNECTION_REFUSED_INSUFFICIENT_ENCRYPTION_KEY_SIZE = 0x0007
+        CONNECTION_REFUSED_INSUFFICIENT_ENCRYPTION = 0x0008
+        CONNECTION_REFUSED_INVALID_SOURCE_CID = 0x0009
+        CONNECTION_REFUSED_SOURCE_CID_ALREADY_ALLOCATED = 0x000A
+        CONNECTION_REFUSED_UNACCEPTABLE_PARAMETERS = 0x000B
+
+    destination_cid: int = dataclasses.field(metadata=hci.metadata(2))
+    mtu: int = dataclasses.field(metadata=hci.metadata(2))
+    mps: int = dataclasses.field(metadata=hci.metadata(2))
+    initial_credits: int = dataclasses.field(metadata=hci.metadata(2))
+    result: int = dataclasses.field(metadata=Result.type_metadata(2))
 
 
 # -----------------------------------------------------------------------------
-@L2CAP_Control_Frame.subclass([('cid', 2), ('credits', 2)])
+@L2CAP_Control_Frame.subclass
+@dataclasses.dataclass
 class L2CAP_LE_Flow_Control_Credit(L2CAP_Control_Frame):
     '''
     See Bluetooth spec @ Vol 3, Part A - 4.24 LE FLOW CONTROL CREDIT (CODE 0x16)
     '''
 
+    cid: int = dataclasses.field(metadata=hci.metadata(2))
+    credits: int = dataclasses.field(metadata=hci.metadata(2))
+
 
 # -----------------------------------------------------------------------------
 class ClassicChannel(utils.EventEmitter):
@@ -744,6 +634,9 @@ class ClassicChannel(utils.EventEmitter):
         WAIT_FINAL_RSP = 0x16
         WAIT_CONTROL_IND = 0x17
 
+    EVENT_OPEN = "open"
+    EVENT_CLOSE = "close"
+
     connection_result: Optional[asyncio.Future[None]]
     disconnection_result: Optional[asyncio.Future[None]]
     response: Optional[asyncio.Future[bytes]]
@@ -820,9 +713,7 @@ class ClassicChannel(utils.EventEmitter):
 
         # Wait for the connection to succeed or fail
         try:
-            return await utils.cancel_on_event(
-                self.connection, 'disconnection', self.connection_result
-            )
+            return await self.connection.cancel_on_disconnection(self.connection_result)
         finally:
             self.connection_result = None
 
@@ -847,7 +738,7 @@ class ClassicChannel(utils.EventEmitter):
     def abort(self) -> None:
         if self.state == self.State.OPEN:
             self._change_state(self.State.CLOSED)
-            self.emit('close')
+            self.emit(self.EVENT_CLOSE)
 
     def send_configure_request(self) -> None:
         options = L2CAP_Control_Frame.encode_configuration_options(
@@ -867,7 +758,7 @@ class ClassicChannel(utils.EventEmitter):
             )
         )
 
-    def on_connection_request(self, request) -> None:
+    def on_connection_request(self, request: L2CAP_Connection_Request) -> None:
         self.destination_cid = request.source_cid
         self._change_state(self.State.WAIT_CONNECT)
         self.send_control_frame(
@@ -875,7 +766,7 @@ class ClassicChannel(utils.EventEmitter):
                 identifier=request.identifier,
                 destination_cid=self.source_cid,
                 source_cid=self.destination_cid,
-                result=L2CAP_Connection_Response.CONNECTION_SUCCESSFUL,
+                result=L2CAP_Connection_Response.Result.CONNECTION_SUCCESSFUL,
                 status=0x0000,
             )
         )
@@ -883,30 +774,31 @@ class ClassicChannel(utils.EventEmitter):
         self.send_configure_request()
         self._change_state(self.State.WAIT_CONFIG_REQ_RSP)
 
-    def on_connection_response(self, response):
+    def on_connection_response(self, response: L2CAP_Connection_Response):
         if self.state != self.State.WAIT_CONNECT_RSP:
             logger.warning(color('invalid state', 'red'))
             return
 
-        if response.result == L2CAP_Connection_Response.CONNECTION_SUCCESSFUL:
+        if response.result == L2CAP_Connection_Response.Result.CONNECTION_SUCCESSFUL:
             self.destination_cid = response.destination_cid
             self._change_state(self.State.WAIT_CONFIG)
             self.send_configure_request()
             self._change_state(self.State.WAIT_CONFIG_REQ_RSP)
-        elif response.result == L2CAP_Connection_Response.CONNECTION_PENDING:
+        elif response.result == L2CAP_Connection_Response.Result.CONNECTION_PENDING:
             pass
         else:
             self._change_state(self.State.CLOSED)
-            self.connection_result.set_exception(
-                ProtocolError(
-                    response.result,
-                    'l2cap',
-                    L2CAP_Connection_Response.result_name(response.result),
+            if self.connection_result:
+                self.connection_result.set_exception(
+                    ProtocolError(
+                        response.result,
+                        'l2cap',
+                        L2CAP_Connection_Response.Result(response.result).name,
+                    )
                 )
-            )
-            self.connection_result = None
+                self.connection_result = None
 
-    def on_configure_request(self, request) -> None:
+    def on_configure_request(self, request: L2CAP_Configure_Request) -> None:
         if self.state not in (
             self.State.WAIT_CONFIG,
             self.State.WAIT_CONFIG_REQ,
@@ -927,7 +819,7 @@ class ClassicChannel(utils.EventEmitter):
                 identifier=request.identifier,
                 source_cid=self.destination_cid,
                 flags=0x0000,
-                result=L2CAP_Configure_Response.SUCCESS,
+                result=L2CAP_Configure_Response.Result.SUCCESS,
                 options=request.options,  # TODO: don't accept everything blindly
             )
         )
@@ -940,12 +832,12 @@ class ClassicChannel(utils.EventEmitter):
             if self.connection_result:
                 self.connection_result.set_result(None)
                 self.connection_result = None
-            self.emit('open')
+            self.emit(self.EVENT_OPEN)
         elif self.state == self.State.WAIT_CONFIG_REQ_RSP:
             self._change_state(self.State.WAIT_CONFIG_RSP)
 
-    def on_configure_response(self, response) -> None:
-        if response.result == L2CAP_Configure_Response.SUCCESS:
+    def on_configure_response(self, response: L2CAP_Configure_Response) -> None:
+        if response.result == L2CAP_Configure_Response.Result.SUCCESS:
             if self.state == self.State.WAIT_CONFIG_REQ_RSP:
                 self._change_state(self.State.WAIT_CONFIG_REQ)
             elif self.state in (
@@ -956,11 +848,12 @@ class ClassicChannel(utils.EventEmitter):
                 if self.connection_result:
                     self.connection_result.set_result(None)
                     self.connection_result = None
-                self.emit('open')
+                self.emit(self.EVENT_OPEN)
             else:
                 logger.warning(color('invalid state', 'red'))
         elif (
-            response.result == L2CAP_Configure_Response.FAILURE_UNACCEPTABLE_PARAMETERS
+            response.result
+            == L2CAP_Configure_Response.Result.FAILURE_UNACCEPTABLE_PARAMETERS
         ):
             # Re-configure with what's suggested in the response
             self.send_control_frame(
@@ -975,13 +868,13 @@ class ClassicChannel(utils.EventEmitter):
             logger.warning(
                 color(
                     '!!! configuration rejected: '
-                    f'{L2CAP_Configure_Response.result_name(response.result)}',
+                    f'{L2CAP_Configure_Response.Result(response.result).name}',
                     'red',
                 )
             )
             # TODO: decide how to fail gracefully
 
-    def on_disconnection_request(self, request) -> None:
+    def on_disconnection_request(self, request: L2CAP_Disconnection_Request) -> None:
         if self.state in (self.State.OPEN, self.State.WAIT_DISCONNECT):
             self.send_control_frame(
                 L2CAP_Disconnection_Response(
@@ -991,12 +884,12 @@ class ClassicChannel(utils.EventEmitter):
                 )
             )
             self._change_state(self.State.CLOSED)
-            self.emit('close')
+            self.emit(self.EVENT_CLOSE)
             self.manager.on_channel_closed(self)
         else:
             logger.warning(color('invalid state', 'red'))
 
-    def on_disconnection_response(self, response) -> None:
+    def on_disconnection_response(self, response: L2CAP_Disconnection_Response) -> None:
         if self.state != self.State.WAIT_DISCONNECT:
             logger.warning(color('invalid state', 'red'))
             return
@@ -1012,7 +905,7 @@ class ClassicChannel(utils.EventEmitter):
         if self.disconnection_result:
             self.disconnection_result.set_result(None)
             self.disconnection_result = None
-        self.emit('close')
+        self.emit(self.EVENT_CLOSE)
         self.manager.on_channel_closed(self)
 
     def __str__(self) -> str:
@@ -1038,7 +931,7 @@ class LeCreditBasedChannel(utils.EventEmitter):
         DISCONNECTED = 4
         CONNECTION_ERROR = 5
 
-    out_queue: Deque[bytes]
+    out_queue: deque[bytes]
     connection_result: Optional[asyncio.Future[LeCreditBasedChannel]]
     disconnection_result: Optional[asyncio.Future[None]]
     in_sdu: Optional[bytes]
@@ -1047,6 +940,9 @@ class LeCreditBasedChannel(utils.EventEmitter):
     connection: Connection
     sink: Optional[Callable[[bytes], Any]]
 
+    EVENT_OPEN = "open"
+    EVENT_CLOSE = "close"
+
     def __init__(
         self,
         manager: ChannelManager,
@@ -1098,9 +994,9 @@ class LeCreditBasedChannel(utils.EventEmitter):
         self.state = new_state
 
         if new_state == self.State.CONNECTED:
-            self.emit('open')
+            self.emit(self.EVENT_OPEN)
         elif new_state == self.State.DISCONNECTED:
-            self.emit('close')
+            self.emit(self.EVENT_CLOSE)
 
     def send_pdu(self, pdu: Union[SupportsBytes, bytes]) -> None:
         self.manager.send_pdu(self.connection, self.destination_cid, pdu)
@@ -1226,7 +1122,9 @@ class LeCreditBasedChannel(utils.EventEmitter):
         self.in_sdu = None
         self.in_sdu_length = 0
 
-    def on_connection_response(self, response) -> None:
+    def on_connection_response(
+        self, response: L2CAP_LE_Credit_Based_Connection_Response
+    ) -> None:
         # Look for a matching pending response result
         if self.connection_result is None:
             logger.warning(
@@ -1236,7 +1134,7 @@ class LeCreditBasedChannel(utils.EventEmitter):
 
         if (
             response.result
-            == L2CAP_LE_Credit_Based_Connection_Response.CONNECTION_SUCCESSFUL
+            == L2CAP_LE_Credit_Based_Connection_Response.Result.CONNECTION_SUCCESSFUL
         ):
             self.destination_cid = response.destination_cid
             self.peer_mtu = response.mtu
@@ -1250,9 +1148,9 @@ class LeCreditBasedChannel(utils.EventEmitter):
                 ProtocolError(
                     response.result,
                     'l2cap',
-                    L2CAP_LE_Credit_Based_Connection_Response.result_name(
+                    L2CAP_LE_Credit_Based_Connection_Response.Result(
                         response.result
-                    ),
+                    ).name,
                 )
             )
             self._change_state(self.State.CONNECTION_ERROR)
@@ -1267,7 +1165,7 @@ class LeCreditBasedChannel(utils.EventEmitter):
         # Try to send more data if we have any queued up
         self.process_output()
 
-    def on_disconnection_request(self, request) -> None:
+    def on_disconnection_request(self, request: L2CAP_Disconnection_Request) -> None:
         self.send_control_frame(
             L2CAP_Disconnection_Response(
                 identifier=request.identifier,
@@ -1278,7 +1176,7 @@ class LeCreditBasedChannel(utils.EventEmitter):
         self._change_state(self.State.DISCONNECTED)
         self.flush_output()
 
-    def on_disconnection_response(self, response) -> None:
+    def on_disconnection_response(self, response: L2CAP_Disconnection_Response) -> None:
         if self.state != self.State.DISCONNECTING:
             logger.warning(color('invalid state', 'red'))
             return
@@ -1381,6 +1279,8 @@ class LeCreditBasedChannel(utils.EventEmitter):
 
 # -----------------------------------------------------------------------------
 class ClassicChannelServer(utils.EventEmitter):
+    EVENT_CONNECTION = "connection"
+
     def __init__(
         self,
         manager: ChannelManager,
@@ -1395,7 +1295,7 @@ class ClassicChannelServer(utils.EventEmitter):
         self.mtu = mtu
 
     def on_connection(self, channel: ClassicChannel) -> None:
-        self.emit('connection', channel)
+        self.emit(self.EVENT_CONNECTION, channel)
         if self.handler:
             self.handler(channel)
 
@@ -1406,6 +1306,8 @@ class ClassicChannelServer(utils.EventEmitter):
 
 # -----------------------------------------------------------------------------
 class LeCreditBasedChannelServer(utils.EventEmitter):
+    EVENT_CONNECTION = "connection"
+
     def __init__(
         self,
         manager: ChannelManager,
@@ -1424,7 +1326,7 @@ class LeCreditBasedChannelServer(utils.EventEmitter):
         self.mps = mps
 
     def on_connection(self, channel: LeCreditBasedChannel) -> None:
-        self.emit('connection', channel)
+        self.emit(self.EVENT_CONNECTION, channel)
         if self.handler:
             self.handler(channel)
 
@@ -1435,13 +1337,13 @@ class LeCreditBasedChannelServer(utils.EventEmitter):
 
 # -----------------------------------------------------------------------------
 class ChannelManager:
-    identifiers: Dict[int, int]
-    channels: Dict[int, Dict[int, Union[ClassicChannel, LeCreditBasedChannel]]]
-    servers: Dict[int, ClassicChannelServer]
-    le_coc_channels: Dict[int, Dict[int, LeCreditBasedChannel]]
-    le_coc_servers: Dict[int, LeCreditBasedChannelServer]
-    le_coc_requests: Dict[int, L2CAP_LE_Credit_Based_Connection_Request]
-    fixed_channels: Dict[int, Optional[Callable[[int, bytes], Any]]]
+    identifiers: dict[int, int]
+    channels: dict[int, dict[int, Union[ClassicChannel, LeCreditBasedChannel]]]
+    servers: dict[int, ClassicChannelServer]
+    le_coc_channels: dict[int, dict[int, LeCreditBasedChannel]]
+    le_coc_servers: dict[int, LeCreditBasedChannelServer]
+    le_coc_requests: dict[int, L2CAP_LE_Credit_Based_Connection_Request]
+    fixed_channels: dict[int, Optional[Callable[[int, bytes], Any]]]
     _host: Optional[Host]
     connection_parameters_update_response: Optional[asyncio.Future[int]]
 
@@ -1723,12 +1625,12 @@ class ChannelManager:
             )
 
     def on_l2cap_command_reject(
-        self, _connection: Connection, _cid: int, packet
+        self, _connection: Connection, _cid: int, packet: L2CAP_Command_Reject
     ) -> None:
         logger.warning(f'{color("!!! Command rejected:", "red")} {packet.reason}')
 
     def on_l2cap_connection_request(
-        self, connection: Connection, cid: int, request
+        self, connection: Connection, cid: int, request: L2CAP_Connection_Request
     ) -> None:
         # Check if there's a server for this PSM
         server = self.servers.get(request.psm)
@@ -1745,7 +1647,7 @@ class ChannelManager:
                         destination_cid=request.source_cid,
                         source_cid=0,
                         # pylint: disable=line-too-long
-                        result=L2CAP_Connection_Response.CONNECTION_REFUSED_NO_RESOURCES_AVAILABLE,
+                        result=L2CAP_Connection_Response.Result.CONNECTION_REFUSED_NO_RESOURCES_AVAILABLE,
                         status=0x0000,
                     ),
                 )
@@ -1776,13 +1678,16 @@ class ChannelManager:
                     destination_cid=request.source_cid,
                     source_cid=0,
                     # pylint: disable=line-too-long
-                    result=L2CAP_Connection_Response.CONNECTION_REFUSED_PSM_NOT_SUPPORTED,
+                    result=L2CAP_Connection_Response.Result.CONNECTION_REFUSED_PSM_NOT_SUPPORTED,
                     status=0x0000,
                 ),
             )
 
     def on_l2cap_connection_response(
-        self, connection: Connection, cid: int, response
+        self,
+        connection: Connection,
+        cid: int,
+        response: L2CAP_Connection_Response,
     ) -> None:
         if (
             channel := self.find_channel(connection.handle, response.source_cid)
@@ -1799,7 +1704,7 @@ class ChannelManager:
         channel.on_connection_response(response)
 
     def on_l2cap_configure_request(
-        self, connection: Connection, cid: int, request
+        self, connection: Connection, cid: int, request: L2CAP_Configure_Request
     ) -> None:
         if (
             channel := self.find_channel(connection.handle, request.destination_cid)
@@ -1816,7 +1721,7 @@ class ChannelManager:
         channel.on_configure_request(request)
 
     def on_l2cap_configure_response(
-        self, connection: Connection, cid: int, response
+        self, connection: Connection, cid: int, response: L2CAP_Configure_Response
     ) -> None:
         if (
             channel := self.find_channel(connection.handle, response.source_cid)
@@ -1833,7 +1738,7 @@ class ChannelManager:
         channel.on_configure_response(response)
 
     def on_l2cap_disconnection_request(
-        self, connection: Connection, cid: int, request
+        self, connection: Connection, cid: int, request: L2CAP_Disconnection_Request
     ) -> None:
         if (
             channel := self.find_channel(connection.handle, request.destination_cid)
@@ -1850,7 +1755,7 @@ class ChannelManager:
         channel.on_disconnection_request(request)
 
     def on_l2cap_disconnection_response(
-        self, connection: Connection, cid: int, response
+        self, connection: Connection, cid: int, response: L2CAP_Disconnection_Response
     ) -> None:
         if (
             channel := self.find_channel(connection.handle, response.source_cid)
@@ -1866,7 +1771,9 @@ class ChannelManager:
 
         channel.on_disconnection_response(response)
 
-    def on_l2cap_echo_request(self, connection: Connection, cid: int, request) -> None:
+    def on_l2cap_echo_request(
+        self, connection: Connection, cid: int, request: L2CAP_Echo_Request
+    ) -> None:
         logger.debug(f'<<< Echo request: data={request.data.hex()}')
         self.send_control_frame(
             connection,
@@ -1875,25 +1782,31 @@ class ChannelManager:
         )
 
     def on_l2cap_echo_response(
-        self, _connection: Connection, _cid: int, response
+        self, _connection: Connection, _cid: int, response: L2CAP_Echo_Response
     ) -> None:
         logger.debug(f'<<< Echo response: data={response.data.hex()}')
         # TODO notify listeners
 
     def on_l2cap_information_request(
-        self, connection: Connection, cid: int, request
+        self, connection: Connection, cid: int, request: L2CAP_Information_Request
     ) -> None:
-        if request.info_type == L2CAP_Information_Request.CONNECTIONLESS_MTU:
-            result = L2CAP_Information_Response.SUCCESS
+        if request.info_type == L2CAP_Information_Request.InfoType.CONNECTIONLESS_MTU:
+            result = L2CAP_Information_Response.Result.SUCCESS
             data = self.connectionless_mtu.to_bytes(2, 'little')
-        elif request.info_type == L2CAP_Information_Request.EXTENDED_FEATURES_SUPPORTED:
-            result = L2CAP_Information_Response.SUCCESS
+        elif (
+            request.info_type
+            == L2CAP_Information_Request.InfoType.EXTENDED_FEATURES_SUPPORTED
+        ):
+            result = L2CAP_Information_Response.Result.SUCCESS
             data = sum(self.extended_features).to_bytes(4, 'little')
-        elif request.info_type == L2CAP_Information_Request.FIXED_CHANNELS_SUPPORTED:
-            result = L2CAP_Information_Response.SUCCESS
+        elif (
+            request.info_type
+            == L2CAP_Information_Request.InfoType.FIXED_CHANNELS_SUPPORTED
+        ):
+            result = L2CAP_Information_Response.Result.SUCCESS
             data = sum(1 << cid for cid in self.fixed_channels).to_bytes(8, 'little')
         else:
-            result = L2CAP_Information_Response.NOT_SUPPORTED
+            result = L2CAP_Information_Response.Result.NOT_SUPPORTED
             data = b''
 
         self.send_control_frame(
@@ -1908,9 +1821,12 @@ class ChannelManager:
         )
 
     def on_l2cap_connection_parameter_update_request(
-        self, connection: Connection, cid: int, request
+        self,
+        connection: Connection,
+        cid: int,
+        request: L2CAP_Connection_Parameter_Update_Request,
     ):
-        if connection.role == Role.CENTRAL:
+        if connection.role == hci.Role.CENTRAL:
             self.send_control_frame(
                 connection,
                 cid,
@@ -1920,7 +1836,7 @@ class ChannelManager:
                 ),
             )
             self.host.send_command_sync(
-                HCI_LE_Connection_Update_Command(
+                hci.HCI_LE_Connection_Update_Command(
                     connection_handle=connection.handle,
                     connection_interval_min=request.interval_min,
                     connection_interval_max=request.interval_max,
@@ -1958,6 +1874,7 @@ class ChannelManager:
             connection,
             L2CAP_LE_SIGNALING_CID,
             L2CAP_Connection_Parameter_Update_Request(
+                identifier=self.next_identifier(connection),
                 interval_min=interval_min,
                 interval_max=interval_max,
                 latency=latency,
@@ -1967,7 +1884,10 @@ class ChannelManager:
         return await self.connection_parameters_update_response
 
     def on_l2cap_connection_parameter_update_response(
-        self, connection: Connection, cid: int, response
+        self,
+        connection: Connection,
+        cid: int,
+        response: L2CAP_Connection_Parameter_Update_Response,
     ) -> None:
         if self.connection_parameters_update_response:
             self.connection_parameters_update_response.set_result(response.result)
@@ -1981,7 +1901,10 @@ class ChannelManager:
             )
 
     def on_l2cap_le_credit_based_connection_request(
-        self, connection: Connection, cid: int, request
+        self,
+        connection: Connection,
+        cid: int,
+        request: L2CAP_LE_Credit_Based_Connection_Request,
     ) -> None:
         if request.le_psm in self.le_coc_servers:
             server = self.le_coc_servers[request.le_psm]
@@ -2002,7 +1925,7 @@ class ChannelManager:
                         mps=server.mps,
                         initial_credits=0,
                         # pylint: disable=line-too-long
-                        result=L2CAP_LE_Credit_Based_Connection_Response.CONNECTION_REFUSED_SOURCE_CID_ALREADY_ALLOCATED,
+                        result=L2CAP_LE_Credit_Based_Connection_Response.Result.CONNECTION_REFUSED_SOURCE_CID_ALREADY_ALLOCATED,
                     ),
                 )
                 return
@@ -2021,7 +1944,7 @@ class ChannelManager:
                         mps=server.mps,
                         initial_credits=0,
                         # pylint: disable=line-too-long
-                        result=L2CAP_LE_Credit_Based_Connection_Response.CONNECTION_REFUSED_NO_RESOURCES_AVAILABLE,
+                        result=L2CAP_LE_Credit_Based_Connection_Response.Result.CONNECTION_REFUSED_NO_RESOURCES_AVAILABLE,
                     ),
                 )
                 return
@@ -2059,7 +1982,7 @@ class ChannelManager:
                     mps=server.mps,
                     initial_credits=server.max_credits,
                     # pylint: disable=line-too-long
-                    result=L2CAP_LE_Credit_Based_Connection_Response.CONNECTION_SUCCESSFUL,
+                    result=L2CAP_LE_Credit_Based_Connection_Response.Result.CONNECTION_SUCCESSFUL,
                 ),
             )
 
@@ -2080,12 +2003,15 @@ class ChannelManager:
                     mps=L2CAP_LE_CREDIT_BASED_CONNECTION_DEFAULT_MPS,
                     initial_credits=0,
                     # pylint: disable=line-too-long
-                    result=L2CAP_LE_Credit_Based_Connection_Response.CONNECTION_REFUSED_LE_PSM_NOT_SUPPORTED,
+                    result=L2CAP_LE_Credit_Based_Connection_Response.Result.CONNECTION_REFUSED_LE_PSM_NOT_SUPPORTED,
                 ),
             )
 
     def on_l2cap_le_credit_based_connection_response(
-        self, connection: Connection, _cid: int, response
+        self,
+        connection: Connection,
+        _cid: int,
+        response: L2CAP_LE_Credit_Based_Connection_Response,
     ) -> None:
         # Find the pending request by identifier
         request = self.le_coc_requests.get(response.identifier)
@@ -2110,7 +2036,7 @@ class ChannelManager:
         channel.on_connection_response(response)
 
     def on_l2cap_le_flow_control_credit(
-        self, connection: Connection, _cid: int, credit
+        self, connection: Connection, _cid: int, credit: L2CAP_LE_Flow_Control_Credit
     ) -> None:
         channel = self.find_le_coc_channel(connection.handle, credit.cid)
         if channel is None: