diff --git a/Modules/clinic/overlapped.c.h b/Modules/clinic/overlapped.c.h
new file mode 100644
index 0000000..efecd90
--- /dev/null
+++ b/Modules/clinic/overlapped.c.h
@@ -0,0 +1,908 @@
+/*[clinic input]
+preserve
+[clinic start generated code]*/
+
+PyDoc_STRVAR(_overlapped_CreateIoCompletionPort__doc__,
+"CreateIoCompletionPort($module, handle, port, key, concurrency, /)\n"
+"--\n"
+"\n"
+"Create a completion port or register a handle with a port.");
+
+#define _OVERLAPPED_CREATEIOCOMPLETIONPORT_METHODDEF    \
+    {"CreateIoCompletionPort", (PyCFunction)(void(*)(void))_overlapped_CreateIoCompletionPort, METH_FASTCALL, _overlapped_CreateIoCompletionPort__doc__},
+
+static PyObject *
+_overlapped_CreateIoCompletionPort_impl(PyObject *module, HANDLE FileHandle,
+                                        HANDLE ExistingCompletionPort,
+                                        ULONG_PTR CompletionKey,
+                                        DWORD NumberOfConcurrentThreads);
+
+static PyObject *
+_overlapped_CreateIoCompletionPort(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    HANDLE FileHandle;
+    HANDLE ExistingCompletionPort;
+    ULONG_PTR CompletionKey;
+    DWORD NumberOfConcurrentThreads;
+
+    if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE""F_HANDLE""F_ULONG_PTR"k:CreateIoCompletionPort",
+        &FileHandle, &ExistingCompletionPort, &CompletionKey, &NumberOfConcurrentThreads)) {
+        goto exit;
+    }
+    return_value = _overlapped_CreateIoCompletionPort_impl(module, FileHandle, ExistingCompletionPort, CompletionKey, NumberOfConcurrentThreads);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_overlapped_GetQueuedCompletionStatus__doc__,
+"GetQueuedCompletionStatus($module, port, msecs, /)\n"
+"--\n"
+"\n"
+"Get a message from completion port.\n"
+"\n"
+"Wait for up to msecs milliseconds.");
+
+#define _OVERLAPPED_GETQUEUEDCOMPLETIONSTATUS_METHODDEF    \
+    {"GetQueuedCompletionStatus", (PyCFunction)(void(*)(void))_overlapped_GetQueuedCompletionStatus, METH_FASTCALL, _overlapped_GetQueuedCompletionStatus__doc__},
+
+static PyObject *
+_overlapped_GetQueuedCompletionStatus_impl(PyObject *module,
+                                           HANDLE CompletionPort,
+                                           DWORD Milliseconds);
+
+static PyObject *
+_overlapped_GetQueuedCompletionStatus(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    HANDLE CompletionPort;
+    DWORD Milliseconds;
+
+    if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE"k:GetQueuedCompletionStatus",
+        &CompletionPort, &Milliseconds)) {
+        goto exit;
+    }
+    return_value = _overlapped_GetQueuedCompletionStatus_impl(module, CompletionPort, Milliseconds);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_overlapped_PostQueuedCompletionStatus__doc__,
+"PostQueuedCompletionStatus($module, port, bytes, key, address, /)\n"
+"--\n"
+"\n"
+"Post a message to completion port.");
+
+#define _OVERLAPPED_POSTQUEUEDCOMPLETIONSTATUS_METHODDEF    \
+    {"PostQueuedCompletionStatus", (PyCFunction)(void(*)(void))_overlapped_PostQueuedCompletionStatus, METH_FASTCALL, _overlapped_PostQueuedCompletionStatus__doc__},
+
+static PyObject *
+_overlapped_PostQueuedCompletionStatus_impl(PyObject *module,
+                                            HANDLE CompletionPort,
+                                            DWORD NumberOfBytes,
+                                            ULONG_PTR CompletionKey,
+                                            OVERLAPPED *Overlapped);
+
+static PyObject *
+_overlapped_PostQueuedCompletionStatus(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    HANDLE CompletionPort;
+    DWORD NumberOfBytes;
+    ULONG_PTR CompletionKey;
+    OVERLAPPED *Overlapped;
+
+    if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE"k"F_ULONG_PTR""F_POINTER":PostQueuedCompletionStatus",
+        &CompletionPort, &NumberOfBytes, &CompletionKey, &Overlapped)) {
+        goto exit;
+    }
+    return_value = _overlapped_PostQueuedCompletionStatus_impl(module, CompletionPort, NumberOfBytes, CompletionKey, Overlapped);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_overlapped_RegisterWaitWithQueue__doc__,
+"RegisterWaitWithQueue($module, Object, CompletionPort, Overlapped,\n"
+"                      Timeout, /)\n"
+"--\n"
+"\n"
+"Register wait for Object; when complete CompletionPort is notified.");
+
+#define _OVERLAPPED_REGISTERWAITWITHQUEUE_METHODDEF    \
+    {"RegisterWaitWithQueue", (PyCFunction)(void(*)(void))_overlapped_RegisterWaitWithQueue, METH_FASTCALL, _overlapped_RegisterWaitWithQueue__doc__},
+
+static PyObject *
+_overlapped_RegisterWaitWithQueue_impl(PyObject *module, HANDLE Object,
+                                       HANDLE CompletionPort,
+                                       OVERLAPPED *Overlapped,
+                                       DWORD Milliseconds);
+
+static PyObject *
+_overlapped_RegisterWaitWithQueue(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    HANDLE Object;
+    HANDLE CompletionPort;
+    OVERLAPPED *Overlapped;
+    DWORD Milliseconds;
+
+    if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE""F_HANDLE""F_POINTER"k:RegisterWaitWithQueue",
+        &Object, &CompletionPort, &Overlapped, &Milliseconds)) {
+        goto exit;
+    }
+    return_value = _overlapped_RegisterWaitWithQueue_impl(module, Object, CompletionPort, Overlapped, Milliseconds);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_overlapped_UnregisterWait__doc__,
+"UnregisterWait($module, WaitHandle, /)\n"
+"--\n"
+"\n"
+"Unregister wait handle.");
+
+#define _OVERLAPPED_UNREGISTERWAIT_METHODDEF    \
+    {"UnregisterWait", (PyCFunction)_overlapped_UnregisterWait, METH_O, _overlapped_UnregisterWait__doc__},
+
+static PyObject *
+_overlapped_UnregisterWait_impl(PyObject *module, HANDLE WaitHandle);
+
+static PyObject *
+_overlapped_UnregisterWait(PyObject *module, PyObject *arg)
+{
+    PyObject *return_value = NULL;
+    HANDLE WaitHandle;
+
+    if (!PyArg_Parse(arg, ""F_HANDLE":UnregisterWait", &WaitHandle)) {
+        goto exit;
+    }
+    return_value = _overlapped_UnregisterWait_impl(module, WaitHandle);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_overlapped_UnregisterWaitEx__doc__,
+"UnregisterWaitEx($module, WaitHandle, Event, /)\n"
+"--\n"
+"\n"
+"Unregister wait handle.");
+
+#define _OVERLAPPED_UNREGISTERWAITEX_METHODDEF    \
+    {"UnregisterWaitEx", (PyCFunction)(void(*)(void))_overlapped_UnregisterWaitEx, METH_FASTCALL, _overlapped_UnregisterWaitEx__doc__},
+
+static PyObject *
+_overlapped_UnregisterWaitEx_impl(PyObject *module, HANDLE WaitHandle,
+                                  HANDLE Event);
+
+static PyObject *
+_overlapped_UnregisterWaitEx(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    HANDLE WaitHandle;
+    HANDLE Event;
+
+    if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE""F_HANDLE":UnregisterWaitEx",
+        &WaitHandle, &Event)) {
+        goto exit;
+    }
+    return_value = _overlapped_UnregisterWaitEx_impl(module, WaitHandle, Event);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_overlapped_CreateEvent__doc__,
+"CreateEvent($module, EventAttributes, ManualReset, InitialState, Name,\n"
+"            /)\n"
+"--\n"
+"\n"
+"Create an event.\n"
+"\n"
+"EventAttributes must be None.");
+
+#define _OVERLAPPED_CREATEEVENT_METHODDEF    \
+    {"CreateEvent", (PyCFunction)(void(*)(void))_overlapped_CreateEvent, METH_FASTCALL, _overlapped_CreateEvent__doc__},
+
+static PyObject *
+_overlapped_CreateEvent_impl(PyObject *module, PyObject *EventAttributes,
+                             BOOL ManualReset, BOOL InitialState,
+                             const Py_UNICODE *Name);
+
+static PyObject *
+_overlapped_CreateEvent(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    PyObject *EventAttributes;
+    BOOL ManualReset;
+    BOOL InitialState;
+    const Py_UNICODE *Name;
+
+    if (!_PyArg_ParseStack(args, nargs, "OiiO&:CreateEvent",
+        &EventAttributes, &ManualReset, &InitialState, _PyUnicode_WideCharString_Opt_Converter, &Name)) {
+        goto exit;
+    }
+    return_value = _overlapped_CreateEvent_impl(module, EventAttributes, ManualReset, InitialState, Name);
+
+exit:
+    /* Cleanup for Name */
+    #if !USE_UNICODE_WCHAR_CACHE
+    PyMem_Free((void *)Name);
+    #endif /* USE_UNICODE_WCHAR_CACHE */
+
+    return return_value;
+}
+
+PyDoc_STRVAR(_overlapped_SetEvent__doc__,
+"SetEvent($module, Handle, /)\n"
+"--\n"
+"\n"
+"Set event.");
+
+#define _OVERLAPPED_SETEVENT_METHODDEF    \
+    {"SetEvent", (PyCFunction)_overlapped_SetEvent, METH_O, _overlapped_SetEvent__doc__},
+
+static PyObject *
+_overlapped_SetEvent_impl(PyObject *module, HANDLE Handle);
+
+static PyObject *
+_overlapped_SetEvent(PyObject *module, PyObject *arg)
+{
+    PyObject *return_value = NULL;
+    HANDLE Handle;
+
+    if (!PyArg_Parse(arg, ""F_HANDLE":SetEvent", &Handle)) {
+        goto exit;
+    }
+    return_value = _overlapped_SetEvent_impl(module, Handle);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_overlapped_ResetEvent__doc__,
+"ResetEvent($module, Handle, /)\n"
+"--\n"
+"\n"
+"Reset event.");
+
+#define _OVERLAPPED_RESETEVENT_METHODDEF    \
+    {"ResetEvent", (PyCFunction)_overlapped_ResetEvent, METH_O, _overlapped_ResetEvent__doc__},
+
+static PyObject *
+_overlapped_ResetEvent_impl(PyObject *module, HANDLE Handle);
+
+static PyObject *
+_overlapped_ResetEvent(PyObject *module, PyObject *arg)
+{
+    PyObject *return_value = NULL;
+    HANDLE Handle;
+
+    if (!PyArg_Parse(arg, ""F_HANDLE":ResetEvent", &Handle)) {
+        goto exit;
+    }
+    return_value = _overlapped_ResetEvent_impl(module, Handle);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_overlapped_BindLocal__doc__,
+"BindLocal($module, handle, family, /)\n"
+"--\n"
+"\n"
+"Bind a socket handle to an arbitrary local port.\n"
+"\n"
+"family should be AF_INET or AF_INET6.");
+
+#define _OVERLAPPED_BINDLOCAL_METHODDEF    \
+    {"BindLocal", (PyCFunction)(void(*)(void))_overlapped_BindLocal, METH_FASTCALL, _overlapped_BindLocal__doc__},
+
+static PyObject *
+_overlapped_BindLocal_impl(PyObject *module, HANDLE Socket, int Family);
+
+static PyObject *
+_overlapped_BindLocal(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    HANDLE Socket;
+    int Family;
+
+    if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE"i:BindLocal",
+        &Socket, &Family)) {
+        goto exit;
+    }
+    return_value = _overlapped_BindLocal_impl(module, Socket, Family);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_overlapped_FormatMessage__doc__,
+"FormatMessage($module, error_code, /)\n"
+"--\n"
+"\n"
+"Return error message for an error code.");
+
+#define _OVERLAPPED_FORMATMESSAGE_METHODDEF    \
+    {"FormatMessage", (PyCFunction)_overlapped_FormatMessage, METH_O, _overlapped_FormatMessage__doc__},
+
+static PyObject *
+_overlapped_FormatMessage_impl(PyObject *module, DWORD code);
+
+static PyObject *
+_overlapped_FormatMessage(PyObject *module, PyObject *arg)
+{
+    PyObject *return_value = NULL;
+    DWORD code;
+
+    if (!PyArg_Parse(arg, "k:FormatMessage", &code)) {
+        goto exit;
+    }
+    return_value = _overlapped_FormatMessage_impl(module, code);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_overlapped_Overlapped__doc__,
+"Overlapped(event=_overlapped.INVALID_HANDLE_VALUE)\n"
+"--\n"
+"\n"
+"OVERLAPPED structure wrapper.");
+
+static PyObject *
+_overlapped_Overlapped_impl(PyTypeObject *type, HANDLE event);
+
+static PyObject *
+_overlapped_Overlapped(PyTypeObject *type, PyObject *args, PyObject *kwargs)
+{
+    PyObject *return_value = NULL;
+    static const char * const _keywords[] = {"event", NULL};
+    static _PyArg_Parser _parser = {"|"F_HANDLE":Overlapped", _keywords, 0};
+    HANDLE event = INVALID_HANDLE_VALUE;
+
+    if (!_PyArg_ParseTupleAndKeywordsFast(args, kwargs, &_parser,
+        &event)) {
+        goto exit;
+    }
+    return_value = _overlapped_Overlapped_impl(type, event);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_overlapped_Overlapped_cancel__doc__,
+"cancel($self, /)\n"
+"--\n"
+"\n"
+"Cancel overlapped operation.");
+
+#define _OVERLAPPED_OVERLAPPED_CANCEL_METHODDEF    \
+    {"cancel", (PyCFunction)_overlapped_Overlapped_cancel, METH_NOARGS, _overlapped_Overlapped_cancel__doc__},
+
+static PyObject *
+_overlapped_Overlapped_cancel_impl(OverlappedObject *self);
+
+static PyObject *
+_overlapped_Overlapped_cancel(OverlappedObject *self, PyObject *Py_UNUSED(ignored))
+{
+    return _overlapped_Overlapped_cancel_impl(self);
+}
+
+PyDoc_STRVAR(_overlapped_Overlapped_getresult__doc__,
+"getresult($self, wait=False, /)\n"
+"--\n"
+"\n"
+"Retrieve result of operation.\n"
+"\n"
+"If wait is true then it blocks until the operation is finished.  If wait\n"
+"is false and the operation is still pending then an error is raised.");
+
+#define _OVERLAPPED_OVERLAPPED_GETRESULT_METHODDEF    \
+    {"getresult", (PyCFunction)(void(*)(void))_overlapped_Overlapped_getresult, METH_FASTCALL, _overlapped_Overlapped_getresult__doc__},
+
+static PyObject *
+_overlapped_Overlapped_getresult_impl(OverlappedObject *self, BOOL wait);
+
+static PyObject *
+_overlapped_Overlapped_getresult(OverlappedObject *self, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    BOOL wait = FALSE;
+
+    if (!_PyArg_ParseStack(args, nargs, "|i:getresult",
+        &wait)) {
+        goto exit;
+    }
+    return_value = _overlapped_Overlapped_getresult_impl(self, wait);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_overlapped_Overlapped_ReadFile__doc__,
+"ReadFile($self, handle, size, /)\n"
+"--\n"
+"\n"
+"Start overlapped read.");
+
+#define _OVERLAPPED_OVERLAPPED_READFILE_METHODDEF    \
+    {"ReadFile", (PyCFunction)(void(*)(void))_overlapped_Overlapped_ReadFile, METH_FASTCALL, _overlapped_Overlapped_ReadFile__doc__},
+
+static PyObject *
+_overlapped_Overlapped_ReadFile_impl(OverlappedObject *self, HANDLE handle,
+                                     DWORD size);
+
+static PyObject *
+_overlapped_Overlapped_ReadFile(OverlappedObject *self, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    HANDLE handle;
+    DWORD size;
+
+    if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE"k:ReadFile",
+        &handle, &size)) {
+        goto exit;
+    }
+    return_value = _overlapped_Overlapped_ReadFile_impl(self, handle, size);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_overlapped_Overlapped_ReadFileInto__doc__,
+"ReadFileInto($self, handle, buf, /)\n"
+"--\n"
+"\n"
+"Start overlapped receive.");
+
+#define _OVERLAPPED_OVERLAPPED_READFILEINTO_METHODDEF    \
+    {"ReadFileInto", (PyCFunction)(void(*)(void))_overlapped_Overlapped_ReadFileInto, METH_FASTCALL, _overlapped_Overlapped_ReadFileInto__doc__},
+
+static PyObject *
+_overlapped_Overlapped_ReadFileInto_impl(OverlappedObject *self,
+                                         HANDLE handle, PyObject *bufobj);
+
+static PyObject *
+_overlapped_Overlapped_ReadFileInto(OverlappedObject *self, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    HANDLE handle;
+    PyObject *bufobj;
+
+    if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE"O:ReadFileInto",
+        &handle, &bufobj)) {
+        goto exit;
+    }
+    return_value = _overlapped_Overlapped_ReadFileInto_impl(self, handle, bufobj);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_overlapped_Overlapped_WSARecv__doc__,
+"WSARecv($self, handle, size, flags=0, /)\n"
+"--\n"
+"\n"
+"Start overlapped receive.");
+
+#define _OVERLAPPED_OVERLAPPED_WSARECV_METHODDEF    \
+    {"WSARecv", (PyCFunction)(void(*)(void))_overlapped_Overlapped_WSARecv, METH_FASTCALL, _overlapped_Overlapped_WSARecv__doc__},
+
+static PyObject *
+_overlapped_Overlapped_WSARecv_impl(OverlappedObject *self, HANDLE handle,
+                                    DWORD size, DWORD flags);
+
+static PyObject *
+_overlapped_Overlapped_WSARecv(OverlappedObject *self, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    HANDLE handle;
+    DWORD size;
+    DWORD flags = 0;
+
+    if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE"k|k:WSARecv",
+        &handle, &size, &flags)) {
+        goto exit;
+    }
+    return_value = _overlapped_Overlapped_WSARecv_impl(self, handle, size, flags);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_overlapped_Overlapped_WSARecvInto__doc__,
+"WSARecvInto($self, handle, buf, flags, /)\n"
+"--\n"
+"\n"
+"Start overlapped receive.");
+
+#define _OVERLAPPED_OVERLAPPED_WSARECVINTO_METHODDEF    \
+    {"WSARecvInto", (PyCFunction)(void(*)(void))_overlapped_Overlapped_WSARecvInto, METH_FASTCALL, _overlapped_Overlapped_WSARecvInto__doc__},
+
+static PyObject *
+_overlapped_Overlapped_WSARecvInto_impl(OverlappedObject *self,
+                                        HANDLE handle, PyObject *bufobj,
+                                        DWORD flags);
+
+static PyObject *
+_overlapped_Overlapped_WSARecvInto(OverlappedObject *self, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    HANDLE handle;
+    PyObject *bufobj;
+    DWORD flags;
+
+    if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE"Ok:WSARecvInto",
+        &handle, &bufobj, &flags)) {
+        goto exit;
+    }
+    return_value = _overlapped_Overlapped_WSARecvInto_impl(self, handle, bufobj, flags);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_overlapped_Overlapped_WriteFile__doc__,
+"WriteFile($self, handle, buf, /)\n"
+"--\n"
+"\n"
+"Start overlapped write.");
+
+#define _OVERLAPPED_OVERLAPPED_WRITEFILE_METHODDEF    \
+    {"WriteFile", (PyCFunction)(void(*)(void))_overlapped_Overlapped_WriteFile, METH_FASTCALL, _overlapped_Overlapped_WriteFile__doc__},
+
+static PyObject *
+_overlapped_Overlapped_WriteFile_impl(OverlappedObject *self, HANDLE handle,
+                                      PyObject *bufobj);
+
+static PyObject *
+_overlapped_Overlapped_WriteFile(OverlappedObject *self, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    HANDLE handle;
+    PyObject *bufobj;
+
+    if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE"O:WriteFile",
+        &handle, &bufobj)) {
+        goto exit;
+    }
+    return_value = _overlapped_Overlapped_WriteFile_impl(self, handle, bufobj);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_overlapped_Overlapped_WSASend__doc__,
+"WSASend($self, handle, buf, flags, /)\n"
+"--\n"
+"\n"
+"Start overlapped send.");
+
+#define _OVERLAPPED_OVERLAPPED_WSASEND_METHODDEF    \
+    {"WSASend", (PyCFunction)(void(*)(void))_overlapped_Overlapped_WSASend, METH_FASTCALL, _overlapped_Overlapped_WSASend__doc__},
+
+static PyObject *
+_overlapped_Overlapped_WSASend_impl(OverlappedObject *self, HANDLE handle,
+                                    PyObject *bufobj, DWORD flags);
+
+static PyObject *
+_overlapped_Overlapped_WSASend(OverlappedObject *self, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    HANDLE handle;
+    PyObject *bufobj;
+    DWORD flags;
+
+    if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE"Ok:WSASend",
+        &handle, &bufobj, &flags)) {
+        goto exit;
+    }
+    return_value = _overlapped_Overlapped_WSASend_impl(self, handle, bufobj, flags);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_overlapped_Overlapped_AcceptEx__doc__,
+"AcceptEx($self, listen_handle, accept_handle, /)\n"
+"--\n"
+"\n"
+"Start overlapped wait for client to connect.");
+
+#define _OVERLAPPED_OVERLAPPED_ACCEPTEX_METHODDEF    \
+    {"AcceptEx", (PyCFunction)(void(*)(void))_overlapped_Overlapped_AcceptEx, METH_FASTCALL, _overlapped_Overlapped_AcceptEx__doc__},
+
+static PyObject *
+_overlapped_Overlapped_AcceptEx_impl(OverlappedObject *self,
+                                     HANDLE ListenSocket,
+                                     HANDLE AcceptSocket);
+
+static PyObject *
+_overlapped_Overlapped_AcceptEx(OverlappedObject *self, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    HANDLE ListenSocket;
+    HANDLE AcceptSocket;
+
+    if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE""F_HANDLE":AcceptEx",
+        &ListenSocket, &AcceptSocket)) {
+        goto exit;
+    }
+    return_value = _overlapped_Overlapped_AcceptEx_impl(self, ListenSocket, AcceptSocket);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_overlapped_Overlapped_ConnectEx__doc__,
+"ConnectEx($self, client_handle, address_as_bytes, /)\n"
+"--\n"
+"\n"
+"Start overlapped connect.\n"
+"\n"
+"client_handle should be unbound.");
+
+#define _OVERLAPPED_OVERLAPPED_CONNECTEX_METHODDEF    \
+    {"ConnectEx", (PyCFunction)(void(*)(void))_overlapped_Overlapped_ConnectEx, METH_FASTCALL, _overlapped_Overlapped_ConnectEx__doc__},
+
+static PyObject *
+_overlapped_Overlapped_ConnectEx_impl(OverlappedObject *self,
+                                      HANDLE ConnectSocket,
+                                      PyObject *AddressObj);
+
+static PyObject *
+_overlapped_Overlapped_ConnectEx(OverlappedObject *self, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    HANDLE ConnectSocket;
+    PyObject *AddressObj;
+
+    if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE"O!:ConnectEx",
+        &ConnectSocket, &PyTuple_Type, &AddressObj)) {
+        goto exit;
+    }
+    return_value = _overlapped_Overlapped_ConnectEx_impl(self, ConnectSocket, AddressObj);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_overlapped_Overlapped_DisconnectEx__doc__,
+"DisconnectEx($self, handle, flags, /)\n"
+"--\n"
+"\n");
+
+#define _OVERLAPPED_OVERLAPPED_DISCONNECTEX_METHODDEF    \
+    {"DisconnectEx", (PyCFunction)(void(*)(void))_overlapped_Overlapped_DisconnectEx, METH_FASTCALL, _overlapped_Overlapped_DisconnectEx__doc__},
+
+static PyObject *
+_overlapped_Overlapped_DisconnectEx_impl(OverlappedObject *self,
+                                         HANDLE Socket, DWORD flags);
+
+static PyObject *
+_overlapped_Overlapped_DisconnectEx(OverlappedObject *self, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    HANDLE Socket;
+    DWORD flags;
+
+    if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE"k:DisconnectEx",
+        &Socket, &flags)) {
+        goto exit;
+    }
+    return_value = _overlapped_Overlapped_DisconnectEx_impl(self, Socket, flags);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_overlapped_Overlapped_TransmitFile__doc__,
+"TransmitFile($self, socket, file, offset, offset_high, count_to_write,\n"
+"             count_per_send, flags, /)\n"
+"--\n"
+"\n"
+"Transmit file data over a connected socket.");
+
+#define _OVERLAPPED_OVERLAPPED_TRANSMITFILE_METHODDEF    \
+    {"TransmitFile", (PyCFunction)(void(*)(void))_overlapped_Overlapped_TransmitFile, METH_FASTCALL, _overlapped_Overlapped_TransmitFile__doc__},
+
+static PyObject *
+_overlapped_Overlapped_TransmitFile_impl(OverlappedObject *self,
+                                         HANDLE Socket, HANDLE File,
+                                         DWORD offset, DWORD offset_high,
+                                         DWORD count_to_write,
+                                         DWORD count_per_send, DWORD flags);
+
+static PyObject *
+_overlapped_Overlapped_TransmitFile(OverlappedObject *self, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    HANDLE Socket;
+    HANDLE File;
+    DWORD offset;
+    DWORD offset_high;
+    DWORD count_to_write;
+    DWORD count_per_send;
+    DWORD flags;
+
+    if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE""F_HANDLE"kkkkk:TransmitFile",
+        &Socket, &File, &offset, &offset_high, &count_to_write, &count_per_send, &flags)) {
+        goto exit;
+    }
+    return_value = _overlapped_Overlapped_TransmitFile_impl(self, Socket, File, offset, offset_high, count_to_write, count_per_send, flags);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_overlapped_Overlapped_ConnectNamedPipe__doc__,
+"ConnectNamedPipe($self, handle, /)\n"
+"--\n"
+"\n"
+"Start overlapped wait for a client to connect.");
+
+#define _OVERLAPPED_OVERLAPPED_CONNECTNAMEDPIPE_METHODDEF    \
+    {"ConnectNamedPipe", (PyCFunction)_overlapped_Overlapped_ConnectNamedPipe, METH_O, _overlapped_Overlapped_ConnectNamedPipe__doc__},
+
+static PyObject *
+_overlapped_Overlapped_ConnectNamedPipe_impl(OverlappedObject *self,
+                                             HANDLE Pipe);
+
+static PyObject *
+_overlapped_Overlapped_ConnectNamedPipe(OverlappedObject *self, PyObject *arg)
+{
+    PyObject *return_value = NULL;
+    HANDLE Pipe;
+
+    if (!PyArg_Parse(arg, ""F_HANDLE":ConnectNamedPipe", &Pipe)) {
+        goto exit;
+    }
+    return_value = _overlapped_Overlapped_ConnectNamedPipe_impl(self, Pipe);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_overlapped_Overlapped_ConnectPipe__doc__,
+"ConnectPipe($self, addr, /)\n"
+"--\n"
+"\n"
+"Connect to the pipe for asynchronous I/O (overlapped).");
+
+#define _OVERLAPPED_OVERLAPPED_CONNECTPIPE_METHODDEF    \
+    {"ConnectPipe", (PyCFunction)_overlapped_Overlapped_ConnectPipe, METH_O, _overlapped_Overlapped_ConnectPipe__doc__},
+
+static PyObject *
+_overlapped_Overlapped_ConnectPipe_impl(OverlappedObject *self,
+                                        const Py_UNICODE *Address);
+
+static PyObject *
+_overlapped_Overlapped_ConnectPipe(OverlappedObject *self, PyObject *arg)
+{
+    PyObject *return_value = NULL;
+    const Py_UNICODE *Address;
+
+    if (!PyUnicode_Check(arg)) {
+        _PyArg_BadArgument("ConnectPipe", "argument", "str", arg);
+        goto exit;
+    }
+    #if USE_UNICODE_WCHAR_CACHE
+    Address = _PyUnicode_AsUnicode(arg);
+    #else /* USE_UNICODE_WCHAR_CACHE */
+    Address = PyUnicode_AsWideCharString(arg, NULL);
+    #endif /* USE_UNICODE_WCHAR_CACHE */
+    if (Address == NULL) {
+        goto exit;
+    }
+    return_value = _overlapped_Overlapped_ConnectPipe_impl(self, Address);
+
+exit:
+    /* Cleanup for Address */
+    #if !USE_UNICODE_WCHAR_CACHE
+    PyMem_Free((void *)Address);
+    #endif /* USE_UNICODE_WCHAR_CACHE */
+
+    return return_value;
+}
+
+PyDoc_STRVAR(_overlapped_WSAConnect__doc__,
+"WSAConnect($module, client_handle, address_as_bytes, /)\n"
+"--\n"
+"\n"
+"Bind a remote address to a connectionless (UDP) socket.");
+
+#define _OVERLAPPED_WSACONNECT_METHODDEF    \
+    {"WSAConnect", (PyCFunction)(void(*)(void))_overlapped_WSAConnect, METH_FASTCALL, _overlapped_WSAConnect__doc__},
+
+static PyObject *
+_overlapped_WSAConnect_impl(PyObject *module, HANDLE ConnectSocket,
+                            PyObject *AddressObj);
+
+static PyObject *
+_overlapped_WSAConnect(PyObject *module, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    HANDLE ConnectSocket;
+    PyObject *AddressObj;
+
+    if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE"O:WSAConnect",
+        &ConnectSocket, &AddressObj)) {
+        goto exit;
+    }
+    return_value = _overlapped_WSAConnect_impl(module, ConnectSocket, AddressObj);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_overlapped_Overlapped_WSASendTo__doc__,
+"WSASendTo($self, handle, buf, flags, address_as_bytes, /)\n"
+"--\n"
+"\n"
+"Start overlapped sendto over a connectionless (UDP) socket.");
+
+#define _OVERLAPPED_OVERLAPPED_WSASENDTO_METHODDEF    \
+    {"WSASendTo", (PyCFunction)(void(*)(void))_overlapped_Overlapped_WSASendTo, METH_FASTCALL, _overlapped_Overlapped_WSASendTo__doc__},
+
+static PyObject *
+_overlapped_Overlapped_WSASendTo_impl(OverlappedObject *self, HANDLE handle,
+                                      PyObject *bufobj, DWORD flags,
+                                      PyObject *AddressObj);
+
+static PyObject *
+_overlapped_Overlapped_WSASendTo(OverlappedObject *self, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    HANDLE handle;
+    PyObject *bufobj;
+    DWORD flags;
+    PyObject *AddressObj;
+
+    if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE"OkO:WSASendTo",
+        &handle, &bufobj, &flags, &AddressObj)) {
+        goto exit;
+    }
+    return_value = _overlapped_Overlapped_WSASendTo_impl(self, handle, bufobj, flags, AddressObj);
+
+exit:
+    return return_value;
+}
+
+PyDoc_STRVAR(_overlapped_Overlapped_WSARecvFrom__doc__,
+"WSARecvFrom($self, handle, size, flags=0, /)\n"
+"--\n"
+"\n"
+"Start overlapped receive.");
+
+#define _OVERLAPPED_OVERLAPPED_WSARECVFROM_METHODDEF    \
+    {"WSARecvFrom", (PyCFunction)(void(*)(void))_overlapped_Overlapped_WSARecvFrom, METH_FASTCALL, _overlapped_Overlapped_WSARecvFrom__doc__},
+
+static PyObject *
+_overlapped_Overlapped_WSARecvFrom_impl(OverlappedObject *self,
+                                        HANDLE handle, DWORD size,
+                                        DWORD flags);
+
+static PyObject *
+_overlapped_Overlapped_WSARecvFrom(OverlappedObject *self, PyObject *const *args, Py_ssize_t nargs)
+{
+    PyObject *return_value = NULL;
+    HANDLE handle;
+    DWORD size;
+    DWORD flags = 0;
+
+    if (!_PyArg_ParseStack(args, nargs, ""F_HANDLE"k|k:WSARecvFrom",
+        &handle, &size, &flags)) {
+        goto exit;
+    }
+    return_value = _overlapped_Overlapped_WSARecvFrom_impl(self, handle, size, flags);
+
+exit:
+    return return_value;
+}
+/*[clinic end generated code: output=ee2ec2f93c8d334b input=a9049054013a1b77]*/
diff --git a/Modules/overlapped.c b/Modules/overlapped.c
index eed8fbf..9c4e2da 100644
--- a/Modules/overlapped.c
+++ b/Modules/overlapped.c
@@ -37,6 +37,36 @@
 
 #define T_HANDLE T_POINTER
 
+/*[python input]
+class OVERLAPPED_converter(CConverter):
+    type = 'OVERLAPPED *'
+    format_unit = '"F_POINTER"'
+
+class HANDLE_converter(CConverter):
+    type = 'HANDLE'
+    format_unit = '"F_HANDLE"'
+
+class ULONG_PTR_converter(CConverter):
+    type = 'ULONG_PTR'
+    format_unit = '"F_ULONG_PTR"'
+
+class DWORD_converter(CConverter):
+    type = 'DWORD'
+    format_unit = 'k'
+
+class BOOL_converter(CConverter):
+    type = 'BOOL'
+    format_unit = 'i'
+[python start generated code]*/
+/*[python end generated code: output=da39a3ee5e6b4b0d input=83bb8c2c2514f2a8]*/
+
+/*[clinic input]
+module _overlapped
+class _overlapped.Overlapped "OverlappedObject *" "&OverlappedType"
+[clinic start generated code]*/
+/*[clinic end generated code: output=da39a3ee5e6b4b0d input=92e5a799db35b96c]*/
+
+
 enum {TYPE_NONE, TYPE_NOT_STARTED, TYPE_READ, TYPE_READINTO, TYPE_WRITE,
       TYPE_ACCEPT, TYPE_CONNECT, TYPE_DISCONNECT, TYPE_CONNECT_NAMED_PIPE,
       TYPE_WAIT_NAMED_PIPE_AND_CONNECT, TYPE_TRANSMIT_FILE, TYPE_READ_FROM,
@@ -150,25 +180,27 @@
  * Completion port stuff
  */
 
-PyDoc_STRVAR(
-    CreateIoCompletionPort_doc,
-    "CreateIoCompletionPort(handle, port, key, concurrency) -> port\n\n"
-    "Create a completion port or register a handle with a port.");
+/*[clinic input]
+_overlapped.CreateIoCompletionPort
+
+    handle as FileHandle: HANDLE
+    port as ExistingCompletionPort: HANDLE
+    key as CompletionKey: ULONG_PTR
+    concurrency as NumberOfConcurrentThreads: DWORD
+    /
+
+Create a completion port or register a handle with a port.
+[clinic start generated code]*/
 
 static PyObject *
-overlapped_CreateIoCompletionPort(PyObject *self, PyObject *args)
+_overlapped_CreateIoCompletionPort_impl(PyObject *module, HANDLE FileHandle,
+                                        HANDLE ExistingCompletionPort,
+                                        ULONG_PTR CompletionKey,
+                                        DWORD NumberOfConcurrentThreads)
+/*[clinic end generated code: output=24ede2b0f05e5433 input=847bae4d0efe1976]*/
 {
-    HANDLE FileHandle;
-    HANDLE ExistingCompletionPort;
-    ULONG_PTR CompletionKey;
-    DWORD NumberOfConcurrentThreads;
     HANDLE ret;
 
-    if (!PyArg_ParseTuple(args, F_HANDLE F_HANDLE F_ULONG_PTR F_DWORD,
-                          &FileHandle, &ExistingCompletionPort, &CompletionKey,
-                          &NumberOfConcurrentThreads))
-        return NULL;
-
     Py_BEGIN_ALLOW_THREADS
     ret = CreateIoCompletionPort(FileHandle, ExistingCompletionPort,
                                  CompletionKey, NumberOfConcurrentThreads);
@@ -179,26 +211,30 @@
     return Py_BuildValue(F_HANDLE, ret);
 }
 
-PyDoc_STRVAR(
-    GetQueuedCompletionStatus_doc,
-    "GetQueuedCompletionStatus(port, msecs) -> (err, bytes, key, address)\n\n"
-    "Get a message from completion port.  Wait for up to msecs milliseconds.");
+/*[clinic input]
+_overlapped.GetQueuedCompletionStatus
+
+    port as CompletionPort: HANDLE
+    msecs as Milliseconds: DWORD
+    /
+
+Get a message from completion port.
+
+Wait for up to msecs milliseconds.
+[clinic start generated code]*/
 
 static PyObject *
-overlapped_GetQueuedCompletionStatus(PyObject *self, PyObject *args)
+_overlapped_GetQueuedCompletionStatus_impl(PyObject *module,
+                                           HANDLE CompletionPort,
+                                           DWORD Milliseconds)
+/*[clinic end generated code: output=68314171628dddb7 input=94a042d14c4f6410]*/
 {
-    HANDLE CompletionPort = NULL;
     DWORD NumberOfBytes = 0;
     ULONG_PTR CompletionKey = 0;
     OVERLAPPED *Overlapped = NULL;
-    DWORD Milliseconds;
     DWORD err;
     BOOL ret;
 
-    if (!PyArg_ParseTuple(args, F_HANDLE F_DWORD,
-                          &CompletionPort, &Milliseconds))
-        return NULL;
-
     Py_BEGIN_ALLOW_THREADS
     ret = GetQueuedCompletionStatus(CompletionPort, &NumberOfBytes,
                                     &CompletionKey, &Overlapped, Milliseconds);
@@ -215,25 +251,28 @@
                          err, NumberOfBytes, CompletionKey, Overlapped);
 }
 
-PyDoc_STRVAR(
-    PostQueuedCompletionStatus_doc,
-    "PostQueuedCompletionStatus(port, bytes, key, address) -> None\n\n"
-    "Post a message to completion port.");
+/*[clinic input]
+_overlapped.PostQueuedCompletionStatus
+
+    port as CompletionPort: HANDLE
+    bytes as NumberOfBytes: DWORD
+    key as CompletionKey: ULONG_PTR
+    address as Overlapped: OVERLAPPED
+    /
+
+Post a message to completion port.
+[clinic start generated code]*/
 
 static PyObject *
-overlapped_PostQueuedCompletionStatus(PyObject *self, PyObject *args)
+_overlapped_PostQueuedCompletionStatus_impl(PyObject *module,
+                                            HANDLE CompletionPort,
+                                            DWORD NumberOfBytes,
+                                            ULONG_PTR CompletionKey,
+                                            OVERLAPPED *Overlapped)
+/*[clinic end generated code: output=93e73f2933a43e9e input=e936202d87937aca]*/
 {
-    HANDLE CompletionPort;
-    DWORD NumberOfBytes;
-    ULONG_PTR CompletionKey;
-    OVERLAPPED *Overlapped;
     BOOL ret;
 
-    if (!PyArg_ParseTuple(args, F_HANDLE F_DWORD F_ULONG_PTR F_POINTER,
-                          &CompletionPort, &NumberOfBytes, &CompletionKey,
-                          &Overlapped))
-        return NULL;
-
     Py_BEGIN_ALLOW_THREADS
     ret = PostQueuedCompletionStatus(CompletionPort, NumberOfBytes,
                                      CompletionKey, Overlapped);
@@ -264,26 +303,27 @@
     PyMem_RawFree(p);
 }
 
-PyDoc_STRVAR(
-    RegisterWaitWithQueue_doc,
-    "RegisterWaitWithQueue(Object, CompletionPort, Overlapped, Timeout)\n"
-    "    -> WaitHandle\n\n"
-    "Register wait for Object; when complete CompletionPort is notified.\n");
+/*[clinic input]
+_overlapped.RegisterWaitWithQueue
+
+    Object: HANDLE
+    CompletionPort: HANDLE
+    Overlapped: OVERLAPPED
+    Timeout as Milliseconds: DWORD
+    /
+
+Register wait for Object; when complete CompletionPort is notified.
+[clinic start generated code]*/
 
 static PyObject *
-overlapped_RegisterWaitWithQueue(PyObject *self, PyObject *args)
+_overlapped_RegisterWaitWithQueue_impl(PyObject *module, HANDLE Object,
+                                       HANDLE CompletionPort,
+                                       OVERLAPPED *Overlapped,
+                                       DWORD Milliseconds)
+/*[clinic end generated code: output=c2ace732e447fe45 input=2dd4efee44abe8ee]*/
 {
     HANDLE NewWaitObject;
-    HANDLE Object;
-    ULONG Milliseconds;
-    struct PostCallbackData data, *pdata;
-
-    if (!PyArg_ParseTuple(args, F_HANDLE F_HANDLE F_POINTER F_DWORD,
-                          &Object,
-                          &data.CompletionPort,
-                          &data.Overlapped,
-                          &Milliseconds))
-        return NULL;
+    struct PostCallbackData data = {CompletionPort, Overlapped}, *pdata;
 
     /* Use PyMem_RawMalloc() rather than PyMem_Malloc(), since
        PostToQueueCallback() will call PyMem_Free() from a new C thread
@@ -306,20 +346,21 @@
     return Py_BuildValue(F_HANDLE, NewWaitObject);
 }
 
-PyDoc_STRVAR(
-    UnregisterWait_doc,
-    "UnregisterWait(WaitHandle) -> None\n\n"
-    "Unregister wait handle.\n");
+/*[clinic input]
+_overlapped.UnregisterWait
+
+    WaitHandle: HANDLE
+    /
+
+Unregister wait handle.
+[clinic start generated code]*/
 
 static PyObject *
-overlapped_UnregisterWait(PyObject *self, PyObject *args)
+_overlapped_UnregisterWait_impl(PyObject *module, HANDLE WaitHandle)
+/*[clinic end generated code: output=ec90cd955a9a617d input=a56709544cb2df0f]*/
 {
-    HANDLE WaitHandle;
     BOOL ret;
 
-    if (!PyArg_ParseTuple(args, F_HANDLE, &WaitHandle))
-        return NULL;
-
     Py_BEGIN_ALLOW_THREADS
     ret = UnregisterWait(WaitHandle);
     Py_END_ALLOW_THREADS
@@ -329,20 +370,23 @@
     Py_RETURN_NONE;
 }
 
-PyDoc_STRVAR(
-    UnregisterWaitEx_doc,
-    "UnregisterWaitEx(WaitHandle, Event) -> None\n\n"
-    "Unregister wait handle.\n");
+/*[clinic input]
+_overlapped.UnregisterWaitEx
+
+    WaitHandle: HANDLE
+    Event: HANDLE
+    /
+
+Unregister wait handle.
+[clinic start generated code]*/
 
 static PyObject *
-overlapped_UnregisterWaitEx(PyObject *self, PyObject *args)
+_overlapped_UnregisterWaitEx_impl(PyObject *module, HANDLE WaitHandle,
+                                  HANDLE Event)
+/*[clinic end generated code: output=2e3d84c1d5f65b92 input=953cddc1de50fab9]*/
 {
-    HANDLE WaitHandle, Event;
     BOOL ret;
 
-    if (!PyArg_ParseTuple(args, F_HANDLE F_HANDLE, &WaitHandle, &Event))
-        return NULL;
-
     Py_BEGIN_ALLOW_THREADS
     ret = UnregisterWaitEx(WaitHandle, Event);
     Py_END_ALLOW_THREADS
@@ -356,26 +400,28 @@
  * Event functions -- currently only used by tests
  */
 
-PyDoc_STRVAR(
-    CreateEvent_doc,
-    "CreateEvent(EventAttributes, ManualReset, InitialState, Name)"
-    " -> Handle\n\n"
-    "Create an event.  EventAttributes must be None.\n");
+/*[clinic input]
+_overlapped.CreateEvent
+
+    EventAttributes: object
+    ManualReset: BOOL
+    InitialState: BOOL
+    Name: Py_UNICODE(accept={str, NoneType})
+    /
+
+Create an event.
+
+EventAttributes must be None.
+[clinic start generated code]*/
 
 static PyObject *
-overlapped_CreateEvent(PyObject *self, PyObject *args)
+_overlapped_CreateEvent_impl(PyObject *module, PyObject *EventAttributes,
+                             BOOL ManualReset, BOOL InitialState,
+                             const Py_UNICODE *Name)
+/*[clinic end generated code: output=8e04f0916c17b13d input=dbc36ae14375ba24]*/
 {
-    PyObject *EventAttributes;
-    BOOL ManualReset;
-    BOOL InitialState;
-    Py_UNICODE *Name;
     HANDLE Event;
 
-    if (!PyArg_ParseTuple(args, "O" F_BOOL F_BOOL "Z",
-                          &EventAttributes, &ManualReset,
-                          &InitialState, &Name))
-        return NULL;
-
     if (EventAttributes != Py_None) {
         PyErr_SetString(PyExc_ValueError, "EventAttributes must be None");
         return NULL;
@@ -390,20 +436,21 @@
     return Py_BuildValue(F_HANDLE, Event);
 }
 
-PyDoc_STRVAR(
-    SetEvent_doc,
-    "SetEvent(Handle) -> None\n\n"
-    "Set event.\n");
+/*[clinic input]
+_overlapped.SetEvent
+
+    Handle: HANDLE
+    /
+
+Set event.
+[clinic start generated code]*/
 
 static PyObject *
-overlapped_SetEvent(PyObject *self, PyObject *args)
+_overlapped_SetEvent_impl(PyObject *module, HANDLE Handle)
+/*[clinic end generated code: output=5b8d974216b0e569 input=d8b0d26eb7391e80]*/
 {
-    HANDLE Handle;
     BOOL ret;
 
-    if (!PyArg_ParseTuple(args, F_HANDLE, &Handle))
-        return NULL;
-
     Py_BEGIN_ALLOW_THREADS
     ret = SetEvent(Handle);
     Py_END_ALLOW_THREADS
@@ -413,20 +460,21 @@
     Py_RETURN_NONE;
 }
 
-PyDoc_STRVAR(
-    ResetEvent_doc,
-    "ResetEvent(Handle) -> None\n\n"
-    "Reset event.\n");
+/*[clinic input]
+_overlapped.ResetEvent
+
+    Handle: HANDLE
+    /
+
+Reset event.
+[clinic start generated code]*/
 
 static PyObject *
-overlapped_ResetEvent(PyObject *self, PyObject *args)
+_overlapped_ResetEvent_impl(PyObject *module, HANDLE Handle)
+/*[clinic end generated code: output=066537a8405cddb2 input=d4e089c9ba84ff2f]*/
 {
-    HANDLE Handle;
     BOOL ret;
 
-    if (!PyArg_ParseTuple(args, F_HANDLE, &Handle))
-        return NULL;
-
     Py_BEGIN_ALLOW_THREADS
     ret = ResetEvent(Handle);
     Py_END_ALLOW_THREADS
@@ -440,36 +488,40 @@
  * Bind socket handle to local port without doing slow getaddrinfo()
  */
 
-PyDoc_STRVAR(
-    BindLocal_doc,
-    "BindLocal(handle, family) -> None\n\n"
-    "Bind a socket handle to an arbitrary local port.\n"
-    "family should AF_INET or AF_INET6.\n");
+/*[clinic input]
+_overlapped.BindLocal
+
+    handle as Socket: HANDLE
+    family as Family: int
+    /
+
+Bind a socket handle to an arbitrary local port.
+
+family should be AF_INET or AF_INET6.
+[clinic start generated code]*/
 
 static PyObject *
-overlapped_BindLocal(PyObject *self, PyObject *args)
+_overlapped_BindLocal_impl(PyObject *module, HANDLE Socket, int Family)
+/*[clinic end generated code: output=edb93862697aed9c input=a0e7b5c2f541170c]*/
 {
-    SOCKET Socket;
-    int Family;
     BOOL ret;
 
-    if (!PyArg_ParseTuple(args, F_HANDLE "i", &Socket, &Family))
-        return NULL;
-
     if (Family == AF_INET) {
         struct sockaddr_in addr;
         memset(&addr, 0, sizeof(addr));
         addr.sin_family = AF_INET;
         addr.sin_port = 0;
         addr.sin_addr.S_un.S_addr = INADDR_ANY;
-        ret = bind(Socket, (SOCKADDR*)&addr, sizeof(addr)) != SOCKET_ERROR;
+        ret = bind((SOCKET)Socket, (SOCKADDR*)&addr, sizeof(addr))
+                != SOCKET_ERROR;
     } else if (Family == AF_INET6) {
         struct sockaddr_in6 addr;
         memset(&addr, 0, sizeof(addr));
         addr.sin6_family = AF_INET6;
         addr.sin6_port = 0;
         addr.sin6_addr = in6addr_any;
-        ret = bind(Socket, (SOCKADDR*)&addr, sizeof(addr)) != SOCKET_ERROR;
+        ret = bind((SOCKET)Socket, (SOCKADDR*)&addr, sizeof(addr))
+                != SOCKET_ERROR;
     } else {
         PyErr_SetString(PyExc_ValueError, "expected tuple of length 2 or 4");
         return NULL;
@@ -484,21 +536,23 @@
  * Windows equivalent of os.strerror() -- compare _ctypes/callproc.c
  */
 
-PyDoc_STRVAR(
-    FormatMessage_doc,
-    "FormatMessage(error_code) -> error_message\n\n"
-    "Return error message for an error code.");
+/*[clinic input]
+_overlapped.FormatMessage
+
+    error_code as code: DWORD
+    /
+
+Return error message for an error code.
+[clinic start generated code]*/
 
 static PyObject *
-overlapped_FormatMessage(PyObject *ignore, PyObject *args)
+_overlapped_FormatMessage_impl(PyObject *module, DWORD code)
+/*[clinic end generated code: output=02c964ff22407c6b input=644bb5b80326179e]*/
 {
-    DWORD code, n;
+    DWORD n;
     WCHAR *lpMsgBuf;
     PyObject *res;
 
-    if (!PyArg_ParseTuple(args, F_DWORD, &code))
-        return NULL;
-
     n = FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER |
                        FORMAT_MESSAGE_FROM_SYSTEM |
                        FORMAT_MESSAGE_IGNORE_INSERTS,
@@ -538,19 +592,20 @@
  * for overlapped I/O
  */
 
-PyDoc_STRVAR(
-    Overlapped_doc,
-    "Overlapped object");
+/*[clinic input]
+@classmethod
+_overlapped.Overlapped.__new__
+
+    event: HANDLE(c_default='INVALID_HANDLE_VALUE') = _overlapped.INVALID_HANDLE_VALUE
+
+OVERLAPPED structure wrapper.
+[clinic start generated code]*/
 
 static PyObject *
-Overlapped_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
+_overlapped_Overlapped_impl(PyTypeObject *type, HANDLE event)
+/*[clinic end generated code: output=6da60504a18eb421 input=26b8a7429e629e95]*/
 {
     OverlappedObject *self;
-    HANDLE event = INVALID_HANDLE_VALUE;
-    static char *kwlist[] = {"event", NULL};
-
-    if (!PyArg_ParseTupleAndKeywords(args, kwds, "|" F_HANDLE, kwlist, &event))
-        return NULL;
 
     if (event == INVALID_HANDLE_VALUE) {
         event = CreateEvent(NULL, TRUE, FALSE, NULL);
@@ -720,13 +775,15 @@
     }
 }
 
-PyDoc_STRVAR(
-    Overlapped_cancel_doc,
-    "cancel() -> None\n\n"
-    "Cancel overlapped operation");
+/*[clinic input]
+_overlapped.Overlapped.cancel
+
+Cancel overlapped operation.
+[clinic start generated code]*/
 
 static PyObject *
-Overlapped_cancel(OverlappedObject *self, PyObject *Py_UNUSED(ignored))
+_overlapped_Overlapped_cancel_impl(OverlappedObject *self)
+/*[clinic end generated code: output=54ad7aeece89901c input=80eb67c7b57dbcf1]*/
 {
     BOOL ret = TRUE;
 
@@ -749,25 +806,27 @@
     Py_RETURN_NONE;
 }
 
-PyDoc_STRVAR(
-    Overlapped_getresult_doc,
-    "getresult(wait=False) -> result\n\n"
-    "Retrieve result of operation.  If wait is true then it blocks\n"
-    "until the operation is finished.  If wait is false and the\n"
-    "operation is still pending then an error is raised.");
+/*[clinic input]
+_overlapped.Overlapped.getresult
+
+    wait: BOOL(c_default='FALSE') = False
+    /
+
+Retrieve result of operation.
+
+If wait is true then it blocks until the operation is finished.  If wait
+is false and the operation is still pending then an error is raised.
+[clinic start generated code]*/
 
 static PyObject *
-Overlapped_getresult(OverlappedObject *self, PyObject *args)
+_overlapped_Overlapped_getresult_impl(OverlappedObject *self, BOOL wait)
+/*[clinic end generated code: output=8c9bd04d08994f6c input=aa5b03e9897ca074]*/
 {
-    BOOL wait = FALSE;
     DWORD transferred = 0;
     BOOL ret;
     DWORD err;
     PyObject *addr;
 
-    if (!PyArg_ParseTuple(args, "|" F_BOOL, &wait))
-        return NULL;
-
     if (self->type == TYPE_NONE) {
         PyErr_SetString(PyExc_ValueError, "operation not yet attempted");
         return NULL;
@@ -879,21 +938,23 @@
     }
 }
 
-PyDoc_STRVAR(
-    Overlapped_ReadFile_doc,
-    "ReadFile(handle, size) -> Overlapped[message]\n\n"
-    "Start overlapped read");
+/*[clinic input]
+_overlapped.Overlapped.ReadFile
+
+    handle: HANDLE
+    size: DWORD
+    /
+
+Start overlapped read.
+[clinic start generated code]*/
 
 static PyObject *
-Overlapped_ReadFile(OverlappedObject *self, PyObject *args)
+_overlapped_Overlapped_ReadFile_impl(OverlappedObject *self, HANDLE handle,
+                                     DWORD size)
+/*[clinic end generated code: output=4c8557e16941e4ae input=98c495baa0342425]*/
 {
-    HANDLE handle;
-    DWORD size;
     PyObject *buf;
 
-    if (!PyArg_ParseTuple(args, F_HANDLE F_DWORD, &handle, &size))
-        return NULL;
-
     if (self->type != TYPE_NONE) {
         PyErr_SetString(PyExc_ValueError, "operation already attempted");
         return NULL;
@@ -913,20 +974,21 @@
     return do_ReadFile(self, handle, PyBytes_AS_STRING(buf), size);
 }
 
-PyDoc_STRVAR(
-    Overlapped_ReadFileInto_doc,
-    "ReadFileInto(handle, buf) -> Overlapped[bytes_transferred]\n\n"
-    "Start overlapped receive");
+/*[clinic input]
+_overlapped.Overlapped.ReadFileInto
+
+    handle: HANDLE
+    buf as bufobj: object
+    /
+
+Start overlapped receive.
+[clinic start generated code]*/
 
 static PyObject *
-Overlapped_ReadFileInto(OverlappedObject *self, PyObject *args)
+_overlapped_Overlapped_ReadFileInto_impl(OverlappedObject *self,
+                                         HANDLE handle, PyObject *bufobj)
+/*[clinic end generated code: output=1e9e712e742e5b2a input=16f6cc268d1d0387]*/
 {
-    HANDLE handle;
-    PyObject *bufobj;
-
-    if (!PyArg_ParseTuple(args, F_HANDLE "O", &handle, &bufobj))
-        return NULL;
-
     if (self->type != TYPE_NONE) {
         PyErr_SetString(PyExc_ValueError, "operation already attempted");
         return NULL;
@@ -982,23 +1044,24 @@
     }
 }
 
-PyDoc_STRVAR(
-    Overlapped_WSARecv_doc,
-    "RecvFile(handle, size, flags) -> Overlapped[message]\n\n"
-    "Start overlapped receive");
+/*[clinic input]
+_overlapped.Overlapped.WSARecv
+
+    handle: HANDLE
+    size: DWORD
+    flags: DWORD = 0
+    /
+
+Start overlapped receive.
+[clinic start generated code]*/
 
 static PyObject *
-Overlapped_WSARecv(OverlappedObject *self, PyObject *args)
+_overlapped_Overlapped_WSARecv_impl(OverlappedObject *self, HANDLE handle,
+                                    DWORD size, DWORD flags)
+/*[clinic end generated code: output=3a5e9c61ff040906 input=8c04e506cc3d741a]*/
 {
-    HANDLE handle;
-    DWORD size;
-    DWORD flags = 0;
     PyObject *buf;
 
-    if (!PyArg_ParseTuple(args, F_HANDLE F_DWORD "|" F_DWORD,
-                          &handle, &size, &flags))
-        return NULL;
-
     if (self->type != TYPE_NONE) {
         PyErr_SetString(PyExc_ValueError, "operation already attempted");
         return NULL;
@@ -1018,22 +1081,23 @@
     return do_WSARecv(self, handle, PyBytes_AS_STRING(buf), size, flags);
 }
 
-PyDoc_STRVAR(
-    Overlapped_WSARecvInto_doc,
-    "WSARecvInto(handle, buf, flags) -> Overlapped[bytes_transferred]\n\n"
-    "Start overlapped receive");
+/*[clinic input]
+_overlapped.Overlapped.WSARecvInto
+
+    handle: HANDLE
+    buf as bufobj: object
+    flags: DWORD
+    /
+
+Start overlapped receive.
+[clinic start generated code]*/
 
 static PyObject *
-Overlapped_WSARecvInto(OverlappedObject *self, PyObject *args)
+_overlapped_Overlapped_WSARecvInto_impl(OverlappedObject *self,
+                                        HANDLE handle, PyObject *bufobj,
+                                        DWORD flags)
+/*[clinic end generated code: output=9a438abc436fe87c input=4f87c38fc381d525]*/
 {
-    HANDLE handle;
-    PyObject *bufobj;
-    DWORD flags;
-
-    if (!PyArg_ParseTuple(args, F_HANDLE "O" F_DWORD,
-                          &handle, &bufobj, &flags))
-        return NULL;
-
     if (self->type != TYPE_NONE) {
         PyErr_SetString(PyExc_ValueError, "operation already attempted");
         return NULL;
@@ -1057,23 +1121,25 @@
                       (DWORD)self->user_buffer.len, flags);
 }
 
-PyDoc_STRVAR(
-    Overlapped_WriteFile_doc,
-    "WriteFile(handle, buf) -> Overlapped[bytes_transferred]\n\n"
-    "Start overlapped write");
+/*[clinic input]
+_overlapped.Overlapped.WriteFile
+
+    handle: HANDLE
+    buf as bufobj: object
+    /
+
+Start overlapped write.
+[clinic start generated code]*/
 
 static PyObject *
-Overlapped_WriteFile(OverlappedObject *self, PyObject *args)
+_overlapped_Overlapped_WriteFile_impl(OverlappedObject *self, HANDLE handle,
+                                      PyObject *bufobj)
+/*[clinic end generated code: output=c376230b6120d877 input=b8d9a7608d8a1e72]*/
 {
-    HANDLE handle;
-    PyObject *bufobj;
     DWORD written;
     BOOL ret;
     DWORD err;
 
-    if (!PyArg_ParseTuple(args, F_HANDLE "O", &handle, &bufobj))
-        return NULL;
-
     if (self->type != TYPE_NONE) {
         PyErr_SetString(PyExc_ValueError, "operation already attempted");
         return NULL;
@@ -1110,26 +1176,27 @@
     }
 }
 
-PyDoc_STRVAR(
-    Overlapped_WSASend_doc,
-    "WSASend(handle, buf, flags) -> Overlapped[bytes_transferred]\n\n"
-    "Start overlapped send");
+/*[clinic input]
+_overlapped.Overlapped.WSASend
+
+    handle: HANDLE
+    buf as bufobj: object
+    flags: DWORD
+    /
+
+Start overlapped send.
+[clinic start generated code]*/
 
 static PyObject *
-Overlapped_WSASend(OverlappedObject *self, PyObject *args)
+_overlapped_Overlapped_WSASend_impl(OverlappedObject *self, HANDLE handle,
+                                    PyObject *bufobj, DWORD flags)
+/*[clinic end generated code: output=316031c7467040cc input=932e7cba6d18f708]*/
 {
-    HANDLE handle;
-    PyObject *bufobj;
-    DWORD flags;
     DWORD written;
     WSABUF wsabuf;
     int ret;
     DWORD err;
 
-    if (!PyArg_ParseTuple(args, F_HANDLE "O" F_DWORD,
-                          &handle, &bufobj, &flags))
-        return NULL;
-
     if (self->type != TYPE_NONE) {
         PyErr_SetString(PyExc_ValueError, "operation already attempted");
         return NULL;
@@ -1167,26 +1234,28 @@
     }
 }
 
-PyDoc_STRVAR(
-    Overlapped_AcceptEx_doc,
-    "AcceptEx(listen_handle, accept_handle) -> Overlapped[address_as_bytes]\n\n"
-    "Start overlapped wait for client to connect");
+/*[clinic input]
+_overlapped.Overlapped.AcceptEx
+
+    listen_handle as ListenSocket: HANDLE
+    accept_handle as AcceptSocket: HANDLE
+    /
+
+Start overlapped wait for client to connect.
+[clinic start generated code]*/
 
 static PyObject *
-Overlapped_AcceptEx(OverlappedObject *self, PyObject *args)
+_overlapped_Overlapped_AcceptEx_impl(OverlappedObject *self,
+                                     HANDLE ListenSocket,
+                                     HANDLE AcceptSocket)
+/*[clinic end generated code: output=9a7381d4232af889 input=b83473224fc3a1c5]*/
 {
-    SOCKET ListenSocket;
-    SOCKET AcceptSocket;
     DWORD BytesReceived;
     DWORD size;
     PyObject *buf;
     BOOL ret;
     DWORD err;
 
-    if (!PyArg_ParseTuple(args, F_HANDLE F_HANDLE,
-                          &ListenSocket, &AcceptSocket))
-        return NULL;
-
     if (self->type != TYPE_NONE) {
         PyErr_SetString(PyExc_ValueError, "operation already attempted");
         return NULL;
@@ -1198,12 +1267,13 @@
         return NULL;
 
     self->type = TYPE_ACCEPT;
-    self->handle = (HANDLE)ListenSocket;
+    self->handle = ListenSocket;
     self->allocated_buffer = buf;
 
     Py_BEGIN_ALLOW_THREADS
-    ret = Py_AcceptEx(ListenSocket, AcceptSocket, PyBytes_AS_STRING(buf),
-                      0, size, size, &BytesReceived, &self->overlapped);
+    ret = Py_AcceptEx((SOCKET)ListenSocket, (SOCKET)AcceptSocket,
+                      PyBytes_AS_STRING(buf), 0, size, size, &BytesReceived,
+                      &self->overlapped);
     Py_END_ALLOW_THREADS
 
     self->error = err = ret ? ERROR_SUCCESS : WSAGetLastError();
@@ -1257,28 +1327,30 @@
     return -1;
 }
 
-PyDoc_STRVAR(
-    Overlapped_ConnectEx_doc,
-    "ConnectEx(client_handle, address_as_bytes) -> Overlapped[None]\n\n"
-    "Start overlapped connect.  client_handle should be unbound.");
+/*[clinic input]
+_overlapped.Overlapped.ConnectEx
+
+    client_handle as ConnectSocket: HANDLE
+    address_as_bytes as AddressObj: object(subclass_of='&PyTuple_Type')
+    /
+
+Start overlapped connect.
+
+client_handle should be unbound.
+[clinic start generated code]*/
 
 static PyObject *
-Overlapped_ConnectEx(OverlappedObject *self, PyObject *args)
+_overlapped_Overlapped_ConnectEx_impl(OverlappedObject *self,
+                                      HANDLE ConnectSocket,
+                                      PyObject *AddressObj)
+/*[clinic end generated code: output=5aebbbdb4f022833 input=d6bbd2d84b156fc1]*/
 {
-    SOCKET ConnectSocket;
-    PyObject *AddressObj;
     char AddressBuf[sizeof(struct sockaddr_in6)];
     SOCKADDR *Address = (SOCKADDR*)AddressBuf;
     int Length;
     BOOL ret;
     DWORD err;
 
-    if (!PyArg_ParseTuple(args, F_HANDLE "O!:ConnectEx",
-                          &ConnectSocket, &PyTuple_Type, &AddressObj))
-    {
-        return NULL;
-    }
-
     if (self->type != TYPE_NONE) {
         PyErr_SetString(PyExc_ValueError, "operation already attempted");
         return NULL;
@@ -1290,10 +1362,10 @@
         return NULL;
 
     self->type = TYPE_CONNECT;
-    self->handle = (HANDLE)ConnectSocket;
+    self->handle = ConnectSocket;
 
     Py_BEGIN_ALLOW_THREADS
-    ret = Py_ConnectEx(ConnectSocket, Address, Length,
+    ret = Py_ConnectEx((SOCKET)ConnectSocket, Address, Length,
                        NULL, 0, NULL, &self->overlapped);
     Py_END_ALLOW_THREADS
 
@@ -1308,32 +1380,33 @@
     }
 }
 
-PyDoc_STRVAR(
-    Overlapped_DisconnectEx_doc,
-    "DisconnectEx(handle, flags) -> Overlapped[None]\n\n"
-    "Start overlapped connect.  client_handle should be unbound.");
+/*[clinic input]
+_overlapped.Overlapped.DisconnectEx
+
+    handle as Socket: HANDLE
+    flags: DWORD
+    /
+
+[clinic start generated code]*/
 
 static PyObject *
-Overlapped_DisconnectEx(OverlappedObject *self, PyObject *args)
+_overlapped_Overlapped_DisconnectEx_impl(OverlappedObject *self,
+                                         HANDLE Socket, DWORD flags)
+/*[clinic end generated code: output=8d64ddb8c93c2126 input=680845cdcdf820eb]*/
 {
-    SOCKET Socket;
-    DWORD flags;
     BOOL ret;
     DWORD err;
 
-    if (!PyArg_ParseTuple(args, F_HANDLE F_DWORD, &Socket, &flags))
-        return NULL;
-
     if (self->type != TYPE_NONE) {
         PyErr_SetString(PyExc_ValueError, "operation already attempted");
         return NULL;
     }
 
     self->type = TYPE_DISCONNECT;
-    self->handle = (HANDLE)Socket;
+    self->handle = Socket;
 
     Py_BEGIN_ALLOW_THREADS
-    ret = Py_DisconnectEx(Socket, &self->overlapped, flags, 0);
+    ret = Py_DisconnectEx((SOCKET)Socket, &self->overlapped, flags, 0);
     Py_END_ALLOW_THREADS
 
     self->error = err = ret ? ERROR_SUCCESS : WSAGetLastError();
@@ -1347,48 +1420,45 @@
     }
 }
 
-PyDoc_STRVAR(
-    Overlapped_TransmitFile_doc,
-    "TransmitFile(socket, file, offset, offset_high, "
-    "count_to_write, count_per_send, flags) "
-    "-> Overlapped[None]\n\n"
-    "Transmit file data over a connected socket.");
+/*[clinic input]
+_overlapped.Overlapped.TransmitFile
+
+    socket as Socket: HANDLE
+    file as File: HANDLE
+    offset: DWORD
+    offset_high: DWORD
+    count_to_write: DWORD
+    count_per_send: DWORD
+    flags: DWORD
+    /
+
+Transmit file data over a connected socket.
+[clinic start generated code]*/
 
 static PyObject *
-Overlapped_TransmitFile(OverlappedObject *self, PyObject *args)
+_overlapped_Overlapped_TransmitFile_impl(OverlappedObject *self,
+                                         HANDLE Socket, HANDLE File,
+                                         DWORD offset, DWORD offset_high,
+                                         DWORD count_to_write,
+                                         DWORD count_per_send, DWORD flags)
+/*[clinic end generated code: output=03f3ca5512e678fd input=7e6f97b391f60e8c]*/
 {
-    SOCKET Socket;
-    HANDLE File;
-    DWORD offset;
-    DWORD offset_high;
-    DWORD count_to_write;
-    DWORD count_per_send;
-    DWORD flags;
     BOOL ret;
     DWORD err;
 
-    if (!PyArg_ParseTuple(args,
-                          F_HANDLE F_HANDLE F_DWORD F_DWORD
-                          F_DWORD F_DWORD F_DWORD,
-                          &Socket, &File, &offset, &offset_high,
-                          &count_to_write, &count_per_send,
-                          &flags))
-        return NULL;
-
     if (self->type != TYPE_NONE) {
         PyErr_SetString(PyExc_ValueError, "operation already attempted");
         return NULL;
     }
 
     self->type = TYPE_TRANSMIT_FILE;
-    self->handle = (HANDLE)Socket;
+    self->handle = Socket;
     self->overlapped.Offset = offset;
     self->overlapped.OffsetHigh = offset_high;
 
     Py_BEGIN_ALLOW_THREADS
-    ret = Py_TransmitFile(Socket, File, count_to_write, count_per_send,
-                          &self->overlapped,
-                          NULL, flags);
+    ret = Py_TransmitFile((SOCKET)Socket, File, count_to_write,
+                          count_per_send, &self->overlapped, NULL, flags);
     Py_END_ALLOW_THREADS
 
     self->error = err = ret ? ERROR_SUCCESS : WSAGetLastError();
@@ -1402,21 +1472,23 @@
     }
 }
 
-PyDoc_STRVAR(
-    Overlapped_ConnectNamedPipe_doc,
-    "ConnectNamedPipe(handle) -> Overlapped[None]\n\n"
-    "Start overlapped wait for a client to connect.");
+/*[clinic input]
+_overlapped.Overlapped.ConnectNamedPipe
+
+    handle as Pipe: HANDLE
+    /
+
+Start overlapped wait for a client to connect.
+[clinic start generated code]*/
 
 static PyObject *
-Overlapped_ConnectNamedPipe(OverlappedObject *self, PyObject *args)
+_overlapped_Overlapped_ConnectNamedPipe_impl(OverlappedObject *self,
+                                             HANDLE Pipe)
+/*[clinic end generated code: output=3e69adfe55818abe input=8b0d4cef8a72f7bc]*/
 {
-    HANDLE Pipe;
     BOOL ret;
     DWORD err;
 
-    if (!PyArg_ParseTuple(args, F_HANDLE, &Pipe))
-        return NULL;
-
     if (self->type != TYPE_NONE) {
         PyErr_SetString(PyExc_ValueError, "operation already attempted");
         return NULL;
@@ -1443,25 +1515,22 @@
     }
 }
 
-PyDoc_STRVAR(
-    ConnectPipe_doc,
-    "ConnectPipe(addr) -> pipe_handle\n\n"
-    "Connect to the pipe for asynchronous I/O (overlapped).");
+/*[clinic input]
+_overlapped.Overlapped.ConnectPipe
+
+    addr as Address: Py_UNICODE
+    /
+
+Connect to the pipe for asynchronous I/O (overlapped).
+[clinic start generated code]*/
 
 static PyObject *
-overlapped_ConnectPipe(PyObject *self, PyObject *args)
+_overlapped_Overlapped_ConnectPipe_impl(OverlappedObject *self,
+                                        const Py_UNICODE *Address)
+/*[clinic end generated code: output=3cc9661667d459d4 input=167c06a274efcefc]*/
 {
-    PyObject *AddressObj;
-    wchar_t *Address;
     HANDLE PipeHandle;
 
-    if (!PyArg_ParseTuple(args, "U",  &AddressObj))
-        return NULL;
-
-    Address = PyUnicode_AsWideCharString(AddressObj, NULL);
-    if (Address == NULL)
-        return NULL;
-
     Py_BEGIN_ALLOW_THREADS
     PipeHandle = CreateFileW(Address,
                              GENERIC_READ | GENERIC_WRITE,
@@ -1469,7 +1538,6 @@
                              FILE_FLAG_OVERLAPPED, NULL);
     Py_END_ALLOW_THREADS
 
-    PyMem_Free(Address);
     if (PipeHandle == INVALID_HANDLE_VALUE)
         return SetFromWindowsErr(0);
     return Py_BuildValue(F_HANDLE, PipeHandle);
@@ -1512,29 +1580,31 @@
 
 // UDP functions
 
-PyDoc_STRVAR(
-    WSAConnect_doc,
-    "WSAConnect(client_handle, address_as_bytes) -> Overlapped[None]\n\n"
-    "Bind a remote address to a connectionless (UDP) socket");
-
 /*
  * Note: WSAConnect does not support Overlapped I/O so this function should
  * _only_ be used for connectionless sockets (UDP).
  */
+
+/*[clinic input]
+_overlapped.WSAConnect
+
+    client_handle as ConnectSocket: HANDLE
+    address_as_bytes as AddressObj: object
+    /
+
+Bind a remote address to a connectionless (UDP) socket.
+[clinic start generated code]*/
+
 static PyObject *
-overlapped_WSAConnect(PyObject *self, PyObject *args)
+_overlapped_WSAConnect_impl(PyObject *module, HANDLE ConnectSocket,
+                            PyObject *AddressObj)
+/*[clinic end generated code: output=ea0b4391e94dad63 input=169f8075e9ae7fa4]*/
 {
-    SOCKET ConnectSocket;
-    PyObject *AddressObj;
     char AddressBuf[sizeof(struct sockaddr_in6)];
     SOCKADDR *Address = (SOCKADDR*)AddressBuf;
     int Length;
     int err;
 
-    if (!PyArg_ParseTuple(args, F_HANDLE "O", &ConnectSocket, &AddressObj)) {
-        return NULL;
-    }
-
     Length = sizeof(AddressBuf);
     Length = parse_address(AddressObj, Address, Length);
     if (Length < 0) {
@@ -1544,7 +1614,7 @@
     Py_BEGIN_ALLOW_THREADS
     // WSAConnect does not support overlapped I/O so this call will
     // successfully complete immediately.
-    err = WSAConnect(ConnectSocket, Address, Length,
+    err = WSAConnect((SOCKET)ConnectSocket, Address, Length,
                         NULL, NULL, NULL, NULL);
     Py_END_ALLOW_THREADS
 
@@ -1556,19 +1626,24 @@
     }
 }
 
-PyDoc_STRVAR(
-    Overlapped_WSASendTo_doc,
-    "WSASendTo(handle, buf, flags, address_as_bytes) -> "
-    "Overlapped[bytes_transferred]\n\n"
-    "Start overlapped sendto over a connectionless (UDP) socket");
+/*[clinic input]
+_overlapped.Overlapped.WSASendTo
+
+    handle: HANDLE
+    buf as bufobj: object
+    flags: DWORD
+    address_as_bytes as AddressObj: object
+    /
+
+Start overlapped sendto over a connectionless (UDP) socket.
+[clinic start generated code]*/
 
 static PyObject *
-Overlapped_WSASendTo(OverlappedObject *self, PyObject *args)
+_overlapped_Overlapped_WSASendTo_impl(OverlappedObject *self, HANDLE handle,
+                                      PyObject *bufobj, DWORD flags,
+                                      PyObject *AddressObj)
+/*[clinic end generated code: output=fe0ff55eb60d65e1 input=f709e6ecebd9bc18]*/
 {
-    HANDLE handle;
-    PyObject *bufobj;
-    DWORD flags;
-    PyObject *AddressObj;
     char AddressBuf[sizeof(struct sockaddr_in6)];
     SOCKADDR *Address = (SOCKADDR*)AddressBuf;
     int AddressLength;
@@ -1577,12 +1652,6 @@
     int ret;
     DWORD err;
 
-    if (!PyArg_ParseTuple(args, F_HANDLE "O" F_DWORD "O",
-                          &handle, &bufobj, &flags, &AddressObj))
-    {
-        return NULL;
-    }
-
     // Parse the "to" address
     AddressLength = sizeof(AddressBuf);
     AddressLength = parse_address(AddressObj, Address, AddressLength);
@@ -1637,24 +1706,29 @@
     "RecvFile(handle, size, flags) -> Overlapped[(message, (host, port))]\n\n"
     "Start overlapped receive");
 
+/*[clinic input]
+_overlapped.Overlapped.WSARecvFrom
+
+    handle: HANDLE
+    size: DWORD
+    flags: DWORD = 0
+    /
+
+Start overlapped receive.
+[clinic start generated code]*/
+
 static PyObject *
-Overlapped_WSARecvFrom(OverlappedObject *self, PyObject *args)
+_overlapped_Overlapped_WSARecvFrom_impl(OverlappedObject *self,
+                                        HANDLE handle, DWORD size,
+                                        DWORD flags)
+/*[clinic end generated code: output=13832a2025b86860 input=1b2663fa130e0286]*/
 {
-    HANDLE handle;
-    DWORD size;
-    DWORD flags = 0;
     DWORD nread;
     PyObject *buf;
     WSABUF wsabuf;
     int ret;
     DWORD err;
 
-    if (!PyArg_ParseTuple(args, F_HANDLE F_DWORD "|" F_DWORD,
-                          &handle, &size, &flags))
-    {
-        return NULL;
-    }
-
     if (self->type != TYPE_NONE) {
         PyErr_SetString(PyExc_ValueError, "operation already attempted");
         return NULL;
@@ -1700,38 +1774,24 @@
     }
 }
 
+#include "clinic/overlapped.c.h"
 
 static PyMethodDef Overlapped_methods[] = {
-    {"getresult", (PyCFunction) Overlapped_getresult,
-     METH_VARARGS, Overlapped_getresult_doc},
-    {"cancel", (PyCFunction) Overlapped_cancel,
-     METH_NOARGS, Overlapped_cancel_doc},
-    {"ReadFile", (PyCFunction) Overlapped_ReadFile,
-     METH_VARARGS, Overlapped_ReadFile_doc},
-    {"ReadFileInto", (PyCFunction) Overlapped_ReadFileInto,
-     METH_VARARGS, Overlapped_ReadFileInto_doc},
-    {"WSARecv", (PyCFunction) Overlapped_WSARecv,
-     METH_VARARGS, Overlapped_WSARecv_doc},
-    {"WSARecvInto", (PyCFunction) Overlapped_WSARecvInto,
-     METH_VARARGS, Overlapped_WSARecvInto_doc},
-    {"WriteFile", (PyCFunction) Overlapped_WriteFile,
-     METH_VARARGS, Overlapped_WriteFile_doc},
-    {"WSASend", (PyCFunction) Overlapped_WSASend,
-     METH_VARARGS, Overlapped_WSASend_doc},
-    {"AcceptEx", (PyCFunction) Overlapped_AcceptEx,
-     METH_VARARGS, Overlapped_AcceptEx_doc},
-    {"ConnectEx", (PyCFunction) Overlapped_ConnectEx,
-     METH_VARARGS, Overlapped_ConnectEx_doc},
-    {"DisconnectEx", (PyCFunction) Overlapped_DisconnectEx,
-     METH_VARARGS, Overlapped_DisconnectEx_doc},
-    {"TransmitFile", (PyCFunction) Overlapped_TransmitFile,
-     METH_VARARGS, Overlapped_TransmitFile_doc},
-    {"ConnectNamedPipe", (PyCFunction) Overlapped_ConnectNamedPipe,
-     METH_VARARGS, Overlapped_ConnectNamedPipe_doc},
-    {"WSARecvFrom", (PyCFunction) Overlapped_WSARecvFrom,
-     METH_VARARGS, Overlapped_WSARecvFrom_doc },
-    {"WSASendTo", (PyCFunction) Overlapped_WSASendTo,
-     METH_VARARGS, Overlapped_WSASendTo_doc },
+    _OVERLAPPED_OVERLAPPED_GETRESULT_METHODDEF
+    _OVERLAPPED_OVERLAPPED_CANCEL_METHODDEF
+    _OVERLAPPED_OVERLAPPED_READFILE_METHODDEF
+    _OVERLAPPED_OVERLAPPED_READFILEINTO_METHODDEF
+    _OVERLAPPED_OVERLAPPED_WSARECV_METHODDEF
+    _OVERLAPPED_OVERLAPPED_WSARECVINTO_METHODDEF
+    _OVERLAPPED_OVERLAPPED_WRITEFILE_METHODDEF
+    _OVERLAPPED_OVERLAPPED_WSASEND_METHODDEF
+    _OVERLAPPED_OVERLAPPED_ACCEPTEX_METHODDEF
+    _OVERLAPPED_OVERLAPPED_CONNECTEX_METHODDEF
+    _OVERLAPPED_OVERLAPPED_DISCONNECTEX_METHODDEF
+    _OVERLAPPED_OVERLAPPED_TRANSMITFILE_METHODDEF
+    _OVERLAPPED_OVERLAPPED_CONNECTNAMEDPIPE_METHODDEF
+    _OVERLAPPED_OVERLAPPED_WSARECVFROM_METHODDEF
+    _OVERLAPPED_OVERLAPPED_WSASENDTO_METHODDEF
     {NULL}
 };
 
@@ -1774,7 +1834,7 @@
     /* tp_setattro       */ 0,
     /* tp_as_buffer      */ 0,
     /* tp_flags          */ Py_TPFLAGS_DEFAULT,
-    /* tp_doc            */ "OVERLAPPED structure wrapper",
+    /* tp_doc            */ _overlapped_Overlapped__doc__,
     /* tp_traverse       */ (traverseproc)Overlapped_traverse,
     /* tp_clear          */ 0,
     /* tp_richcompare    */ 0,
@@ -1791,36 +1851,23 @@
     /* tp_dictoffset     */ 0,
     /* tp_init           */ 0,
     /* tp_alloc          */ 0,
-    /* tp_new            */ Overlapped_new,
+    /* tp_new            */ _overlapped_Overlapped,
 };
 
 static PyMethodDef overlapped_functions[] = {
-    {"CreateIoCompletionPort", overlapped_CreateIoCompletionPort,
-     METH_VARARGS, CreateIoCompletionPort_doc},
-    {"GetQueuedCompletionStatus", overlapped_GetQueuedCompletionStatus,
-     METH_VARARGS, GetQueuedCompletionStatus_doc},
-    {"PostQueuedCompletionStatus", overlapped_PostQueuedCompletionStatus,
-     METH_VARARGS, PostQueuedCompletionStatus_doc},
-    {"FormatMessage", overlapped_FormatMessage,
-     METH_VARARGS, FormatMessage_doc},
-    {"BindLocal", overlapped_BindLocal,
-     METH_VARARGS, BindLocal_doc},
-    {"RegisterWaitWithQueue", overlapped_RegisterWaitWithQueue,
-     METH_VARARGS, RegisterWaitWithQueue_doc},
-    {"UnregisterWait", overlapped_UnregisterWait,
-     METH_VARARGS, UnregisterWait_doc},
-    {"UnregisterWaitEx", overlapped_UnregisterWaitEx,
-     METH_VARARGS, UnregisterWaitEx_doc},
-    {"CreateEvent", overlapped_CreateEvent,
-     METH_VARARGS, CreateEvent_doc},
-    {"SetEvent", overlapped_SetEvent,
-     METH_VARARGS, SetEvent_doc},
-    {"ResetEvent", overlapped_ResetEvent,
-     METH_VARARGS, ResetEvent_doc},
-    {"ConnectPipe", overlapped_ConnectPipe,
-     METH_VARARGS, ConnectPipe_doc},
-    {"WSAConnect", overlapped_WSAConnect,
-     METH_VARARGS, WSAConnect_doc},
+    _OVERLAPPED_CREATEIOCOMPLETIONPORT_METHODDEF
+    _OVERLAPPED_GETQUEUEDCOMPLETIONSTATUS_METHODDEF
+    _OVERLAPPED_POSTQUEUEDCOMPLETIONSTATUS_METHODDEF
+    _OVERLAPPED_FORMATMESSAGE_METHODDEF
+    _OVERLAPPED_BINDLOCAL_METHODDEF
+    _OVERLAPPED_REGISTERWAITWITHQUEUE_METHODDEF
+    _OVERLAPPED_UNREGISTERWAIT_METHODDEF
+    _OVERLAPPED_UNREGISTERWAITEX_METHODDEF
+    _OVERLAPPED_CREATEEVENT_METHODDEF
+    _OVERLAPPED_SETEVENT_METHODDEF
+    _OVERLAPPED_RESETEVENT_METHODDEF
+    _OVERLAPPED_OVERLAPPED_CONNECTPIPE_METHODDEF
+    _OVERLAPPED_WSACONNECT_METHODDEF
     {NULL}
 };