      
      ![Image](https://github.com/PureSwift/Bluetooth/raw/master/Assets/Notifications.png)
      */
-    public func clientCharacteristicConfiguration(notification: Notification?,
-                                                  indication: Notification?,
-                                                  for characteristic: Characteristic,
-                                                  descriptors: [GATTClient.Descriptor],
-                                                  completion: @escaping (GATTClientResponse<()>) -> ()) {
+    public func clientCharacteristicConfiguration(
+        notification: Notification?,
+        indication: Notification?,
+        for characteristic: Characteristic,
+        descriptors: [GATTClient.Descriptor]
+    ) async throws {
         
         guard let descriptor = descriptors.first(where: { $0.uuid == .clientCharacteristicConfiguration })
             else { completion(.failure(GATTClientError.clientCharacteristicConfigurationNotAllowed(characteristic))); return }

    
    // MARK: - Private Methods
    
    @inline(__always)
    private func registerATTHandlers() {
        
        // value notifications / indications
        connection.register { [weak self] in self?.notification($0) }
        connection.register { [weak self] in self?.indication($0) }
    }
    
    @inline(__always)
    private func send <Request: ATTProtocolDataUnit, Response> (_ request: Request, response: @escaping (ATTResponse<Response>) -> ()) {
        
        let log = self.log
        
        log?("Request: \(request)")
        
        let callback: (AnyATTResponse) -> () = {
            log?("Response: \($0.rawValue)")
            response(ATTResponse<Response>($0))
        }
        
        let responseType: ATTProtocolDataUnit.Type = Response.self
        
        guard let _ = connection.send(request, response: (callback, responseType))
            else { fatalError("Could not add PDU to queue: \(request)") }
    }
    
    @inline(__always)
    private func send <Request: ATTProtocolDataUnit> (_ request: Request) {
        
        log?("Request: \(request)")
        
        guard let _ = connection.send(request)
            else { fatalError("Could not add PDU to queue: \(request)") }
    }
    
    internal func endHandle(for characteristic: Characteristic,
                            service: (declaration: Service, characteristics: [Characteristic])) -> UInt16 {
        
        // calculate ending handle of characteristic
        
        let end: UInt16
        
        guard let index = service.characteristics.firstIndex(where: { $0.handle.declaration == characteristic.handle.declaration })

        
        let operation = ReadMultipleOperation(characteristics: characteristics, completion: completion)
        
        send(pdu) { [unowned self] in
            self.readMultipleResponse($0, operation: operation)
        }
    }
    
    /**
