         guard let (_ , gattCharacteristic) = cache.characteristic(for: characteristic.id)
             else { throw CentralError.invalidAttribute(characteristic.uuid) }
         
-        // Gatt Descriptors
-        let descriptors: [GATTClient.Descriptor]
-        
-        if gattCharacteristic.descriptors.values.contains(where: { $0.attribute.uuid == .clientCharacteristicConfiguration }) {
-            
-            descriptors = Array(gattCharacteristic.descriptors.values.map { $0.attribute })
-            
-        } else {
-            
-            // fetch descriptors
-            let _ = try discoverDescriptors(for: characteristic, timeout: timeout)
-            
-            // get updated cache
-            if let cache = self.cache.characteristic(for: characteristic.id)?.1.descriptors.values.map({ $0.attribute }) {
-                
-                descriptors = Array(cache)
-                
-            } else {
-                
-                descriptors = []
-            }
-        }
-        
-        let notify: GATTClient.Notification?
-        let indicate: GATTClient.Notification?
-        
-        /**
-         If the specified characteristic is configured to allow both notifications and indications, calling this method enables notifications only. You can disable notifications and indications for a characteristic’s value by calling this method with the enabled parameter set to false.
-         */
-        
-        if gattCharacteristic.attribute.properties.contains(.notify) {
-            
-            notify = notification
-            indicate = nil
-            
-        } else if gattCharacteristic.attribute.properties.contains(.indicate) {
-            
-            notify = nil
-            indicate = notification
-            
-        } else {
-            
-            notify = nil
-            indicate = nil
-            
-            assertionFailure("Cannot enable notification or indication for characteristic \(characteristic.uuid)")
-            return
-        }
-        
-        // GATT request
-        try _async(timeout: timeout) {
-            client.clientCharacteristicConfiguration(notification: notify,
-                                                     indication: indicate,
-                                                     for: gattCharacteristic.attribute,
-                                                     descriptors: descriptors,
-                                                     completion: $0)
-        }
+        // GATT request
+        try await withCheckedThrowingContinuation { [weak self] (continuation: CheckedContinuation<(), Error>) in
+            guard let self = self else { return }
+            client.clientCharacteristicConfiguration(
+                notification: notification,
+                indication: indication,
+                for: gattCharacteristic.attribute,
+                descriptors: descriptors) { clientResponse in
+                continuation.resume(with: clientResponse)
+            }
+        }
+        
     }
 }
 

    }
}

#endif
*/

            else { throw CentralError.invalidAttribute(characteristic.uuid) }
        
        // GATT request
        return try await withCheckedThrowingContinuation { [weak self] (continuation: CheckedContinuation<Data, Error>) in
            guard let self = self else { return }
            self.client.readCharacteristic(gattCharacteristic.attribute) { clientResponse in
                continuation.resume(with: clientResponse)
            }
        }
    }
    
    public func writeValue(
        _ data: Data,
        for characteristic: Characteristic<Peripheral, UInt16>,
        withResponse: Bool
    ) async throws {
        
        assert(characteristic.peripheral == peripheral)
        
