             try await waitUntilCanSendWriteWithoutResponse(for: characteristic.peripheral)
         }
         try await write(data, withResponse: withResponse, for: characteristic)
+    }
+    
+    public func discoverDescriptors(
+        for characteristic: DarwinCentral.Characteristic
+    ) async throws -> [DarwinCentral.Descriptor] {
+        return try await withThrowingContinuation(for: characteristic.peripheral) { [weak self] continuation in
+            guard let self = self else { return }
+            self.async {
+                let operation = Operation.DiscoverDescriptors(
+                    characteristic: characteristic,
+                    continuation: continuation
+                )
+                self.enqueue(.discoverDescriptors(operation), for: characteristic.peripheral)
+            }
+        }
+    }
+    
+    public func readValue(
+        for descriptor: DarwinCentral.Descriptor
+    ) async throws -> Data {
+        return try await withThrowingContinuation(for: descriptor.peripheral) { [weak self] continuation in
+            guard let self = self else { return }
+            self.async {
+                let operation = Operation.ReadDescriptor(
+                    descriptor: descriptor,
+                    continuation: continuation
+                )
+                self.enqueue(.readDescriptor(operation), for: descriptor.peripheral)
+            }
+        }
+    }
+    
+    public func writeValue(
+        _ data: Data,
+        for descriptor: DarwinCentral.Descriptor
+    ) async throws {
+        return try await withThrowingContinuation(for: descriptor.peripheral) { [weak self] continuation in
+            guard let self = self else { return }
+            self.async {
+                let operation = Operation.WriteDescriptor(
+                    descriptor: descriptor,
+                    data: data,
+                    continuation: continuation
+                )
+                self.enqueue(.writeDescriptor(operation), for: descriptor.peripheral)
+            }
+        }
     }
     
     public func notify(

    
    struct WriteDescriptor {
        let descriptor: DarwinCentral.Descriptor
        let continuation: PeripheralContinuation<(), Error>
    }
    

    }
    
    func execute(_ operation: Operation.DiscoverDescriptors) -> Bool {
        log("Peripheral \(operation.characteristic.peripheral) will discover descriptors of characteristic \(operation.characteristic.uuid)")
        // check power on
        guard validateState(.poweredOn, for: operation.continuation) else {
            return false
        }
        // get peripheral
        guard let peripheralObject = validatePeripheral(operation.characteristic.peripheral, for: operation.continuation) else {
            return false
        }
        // check connected
        guard validateConnected(peripheralObject, for: operation.continuation) else {
            return false
        }
        // get characteristic
        guard let characteristicObject = validateCharacteristic(operation.characteristic, for: operation.continuation) else {
            return false
        }
        // discover
        peripheralObject.discoverDescriptors(for: characteristicObject)
        return true
    }
    
    func execute(_ operation: Operation.ReadDescriptor) -> Bool {
        log("Peripheral \(operation.descriptor.peripheral) will read descriptor \(operation.descriptor.uuid)")
        // check power on
        guard validateState(.poweredOn, for: operation.continuation) else {
            return false
        }
        // get peripheral
        guard let peripheralObject = validatePeripheral(operation.descriptor.peripheral, for: operation.continuation) else {
            return false
        }
        // check connected
        guard validateConnected(peripheralObject, for: operation.continuation) else {
            return false
        }
        // get descriptor
        guard let descriptorObject = validateDescriptor(operation.descriptor, for: operation.continuation) else {
            return false
        }
        // write
        peripheralObject.readValue(for: descriptorObject)
        return true
    }
    
    func execute(_ operation: Operation.WriteDescriptor) -> Bool {
        log("Peripheral \(operation.descriptor.peripheral) will write descriptor \(operation.descriptor.uuid)")
        // check power on
        guard validateState(.poweredOn, for: operation.continuation) else {
            return false
        }
        // get peripheral
        guard let peripheralObject = validatePeripheral(operation.descriptor.peripheral, for: operation.continuation) else {
            return false
        }
        // check connected
        guard validateConnected(peripheralObject, for: operation.continuation) else {
            return false
        }
        // get descriptor
        guard let descriptorObject = validateDescriptor(operation.descriptor, for: operation.continuation) else {
            return false
        }
        // write
        peripheralObject.writeValue(operation.data, for: descriptorObject)
        return true
    }
    
    func execute(_ operation: Operation.WriteWithoutResponseReady) -> Bool {
