     }
 
     /**
-        Converts the body's contents into a `Stream`
+        Converts the body's contents into a `ReceivingStream`
         that can be received in chunks.
     */
-    public mutating func becomeReceiver() throws -> Stream {
+    public mutating func becomeReceiver() throws -> ReceivingStream {
         switch self {
         case .receiver(let stream):
             return stream

                return (self, closure)
            }
        case .asyncReceiver(let receiver):
            let closure: ((AsyncStream, ((Void) throws -> Void) -> Void) -> Void) = { sender, result in
                _ = AsyncDrain(for: receiver, timingOut: deadline) { getData in
                    do {
                        let drain = try getData()

                     Represents a `Data` object containing
                     a byte array.

    - receiver:      Contains a `ReceivingStream` that can be drained
                     in chunks to access the body's data.

    - sender:        Contains a closure that accepts a `SendingStream`
                     object to which the body's data should be sent.
 
    - asyncReceiver: Contains a `AsyncReceivingStream` that can be drained
                     in chunks to access the body's data.
 
    - asyncSender:   Contains a closure that accepts a `AsyncSendingStream`
                     object to which the body's data should be sent.
 
*/
public enum Body {
    case buffer(Data)
    case receiver(ReceivingStream)
    case sender((SendingStream) throws -> Void)
    case asyncReceiver(AsyncReceivingStream)
    case asyncSender((AsyncSendingStream, ((Void) throws -> Void) -> Void) -> Void)
}

public enum BodyError: ErrorProtocol {
