             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(

    }
    
    func execute(_ operation: Operation.DiscoverDescriptors) -> Bool {
        // TODO: Discover Descriptor
        fatalError()
    }
    
    func execute(_ operation: Operation.ReadDescriptor) -> Bool {
        // TODO: Read Descriptor
        fatalError()
    }
    
    func execute(_ operation: Operation.WriteDescriptor) -> Bool {
        // TODO: Write Descriptor
        fatalError()
    }
    
    func execute(_ operation: Operation.WriteWithoutResponseReady) -> Bool {

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