     }
     
     public func send(data: C7.Data) throws {
-        try send(data, flush: true, timingOut: never)
+        try send(data, flush: true, deadline: never)
     }
     
     public func flush() throws {
-        try flush(never)
+        try flush(timingOut: never)
     }
 
-    public func flush(timingOut: timingOut) throws {
+    public func flush(timingOut deadline: Deadline) throws {
         let socket = try getSocket()
         try assertNotClosed()
         
-        tcpflush(socket, timingOut)
+        tcpflush(socket, deadline)
         try TCPError.assertNoError()
     }
 
-    public func send(data: Data, flush: Bool = true, timingOut: timingOut = never) throws {
+    public func send(data: Data, flush: Bool = true, deadline: Deadline = never) throws {
         let socket = try getSocket()
         try assertNotClosed()
         
         let bytesProcessed = data.withUnsafeBufferPointer {
-            tcpsend(socket, $0.baseAddress, $0.count, timingOut)
+            tcpsend(socket, $0.baseAddress, $0.count, deadline)
         }
 
         try TCPError.assertNoSendErrorWithData(data, bytesProcessed: bytesProcessed)

        }
    }

    public func receive(upTo byteCount: Int, timingOut: timingOut = never) throws -> Data {
        let socket = try getSocket()
        try assertNotClosed()

        var data = Data.bufferWithSize(byteCount)
        let bytesProcessed = data.withUnsafeMutableBufferPointer {
            tcprecv(socket, $0.baseAddress, $0.count, timingOut)
        }

        try TCPError.assertNoReceiveErrorWithData(data, bytesProcessed: bytesProcessed)
        return Data(data.prefix(bytesProcessed))
    }

    public func receive(lowWaterMark lowWaterMark: Int, highWaterMark: Int, timingOut: timingOut = never) throws -> Data {
        let socket = try getSocket()
        try assertNotClosed()



        var data = Data.bufferWithSize(highWaterMark)
        let bytesProcessed = data.withUnsafeMutableBufferPointer {
            tcprecvlh(socket, $0.baseAddress, lowWaterMark, highWaterMark, deadline)
        }

        try TCPError.assertNoReceiveErrorWithData(data, bytesProcessed: bytesProcessed)
        return Data(data.prefix(bytesProcessed))
    }

    public func receive(upTo byteCount: Int, untilDelimiter delimiter: String, timingOut deadline: Deadline = never) throws -> Data {
        let socket = try getSocket()
        try assertNotClosed()

        
        var data = Data.bufferWithSize(byteCount)
        let bytesProcessed = data.withUnsafeMutableBufferPointer {
            tcprecvuntil(socket, $0.baseAddress, $0.count, delimiter, delimiter.utf8.count, deadline)
        }

        try TCPError.assertNoReceiveErrorWithData(data, bytesProcessed: bytesProcessed)
