linksocks 3.0.12__cp310-cp310-win_amd64.whl → 3.0.13__cp310-cp310-win_amd64.whl

linksockslib/linksockslib.go

@@ -1,7 +1,7 @@
 /*
 cgo stubs for package linksockslib.
 File is generated by gopy. Do not edit.
-gopy.EXE build -vm=C:\Users\RUNNER~1\AppData\Local\Temp\linksocks_pyvenv_t3urfovz\venv\Scripts\python.exe -output=D:\a\linksocks\linksocks\_bindings\python\linksockslib -name=linksockslib -no-make=true ./linksocks_go
+gopy.EXE build -vm=C:\Users\RUNNER~1\AppData\Local\Temp\linksocks_pyvenv_lyyt1kjp\venv\Scripts\python.exe -output=D:\a\linksocks\linksocks\_bindings\python\linksockslib -name=linksockslib -no-make=true ./linksocks_go
 */
 
 package main
@@ -5228,1275 +5228,1282 @@ func linksocks_BaseMessage_GetType(_handle CGoHandle) *C.char {
 
 // ---- Structs ---
 
-// --- wrapping struct: linksocks.LogEntry ---
+// --- wrapping struct: linksocks.ConnectorResponseMessage ---
 //
-//export linksocks_LogEntry_CTor
-func linksocks_LogEntry_CTor() CGoHandle {
-	return CGoHandle(handleFromPtr_linksocks_LogEntry(&linksocks.LogEntry{}))
+//export linksocks_ConnectorResponseMessage_CTor
+func linksocks_ConnectorResponseMessage_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_linksocks_ConnectorResponseMessage(&linksocks.ConnectorResponseMessage{}))
 }
 
-//export linksocks_LogEntry_LoggerID_Get
-func linksocks_LogEntry_LoggerID_Get(handle CGoHandle) *C.char {
-	op := ptrFromHandle_linksocks_LogEntry(handle)
-	return C.CString(op.LoggerID)
+//export linksocks_ConnectorResponseMessage_Success_Get
+func linksocks_ConnectorResponseMessage_Success_Get(handle CGoHandle) C.char {
+	op := ptrFromHandle_linksocks_ConnectorResponseMessage(handle)
+	return boolGoToPy(op.Success)
 }
 
-//export linksocks_LogEntry_LoggerID_Set
-func linksocks_LogEntry_LoggerID_Set(handle CGoHandle, val *C.char) {
-	op := ptrFromHandle_linksocks_LogEntry(handle)
-	op.LoggerID = C.GoString(val)
+//export linksocks_ConnectorResponseMessage_Success_Set
+func linksocks_ConnectorResponseMessage_Success_Set(handle CGoHandle, val C.char) {
+	op := ptrFromHandle_linksocks_ConnectorResponseMessage(handle)
+	op.Success = boolPyToGo(val)
 }
 
-//export linksocks_LogEntry_Message_Get
-func linksocks_LogEntry_Message_Get(handle CGoHandle) *C.char {
-	op := ptrFromHandle_linksocks_LogEntry(handle)
-	return C.CString(op.Message)
+//export linksocks_ConnectorResponseMessage_Error_Get
+func linksocks_ConnectorResponseMessage_Error_Get(handle CGoHandle) *C.char {
+	op := ptrFromHandle_linksocks_ConnectorResponseMessage(handle)
+	return C.CString(op.Error)
 }
 
-//export linksocks_LogEntry_Message_Set
-func linksocks_LogEntry_Message_Set(handle CGoHandle, val *C.char) {
-	op := ptrFromHandle_linksocks_LogEntry(handle)
-	op.Message = C.GoString(val)
+//export linksocks_ConnectorResponseMessage_Error_Set
+func linksocks_ConnectorResponseMessage_Error_Set(handle CGoHandle, val *C.char) {
+	op := ptrFromHandle_linksocks_ConnectorResponseMessage(handle)
+	op.Error = C.GoString(val)
 }
 
-//export linksocks_LogEntry_Time_Get
-func linksocks_LogEntry_Time_Get(handle CGoHandle) C.longlong {
-	op := ptrFromHandle_linksocks_LogEntry(handle)
-	return C.longlong(op.Time)
+//export linksocks_ConnectorResponseMessage_ChannelID_Get
+func linksocks_ConnectorResponseMessage_ChannelID_Get(handle CGoHandle) CGoHandle {
+	op := ptrFromHandle_linksocks_ConnectorResponseMessage(handle)
+	return handleFromPtr_uuid_UUID(&op.ChannelID)
 }
 
-//export linksocks_LogEntry_Time_Set
-func linksocks_LogEntry_Time_Set(handle CGoHandle, val C.longlong) {
-	op := ptrFromHandle_linksocks_LogEntry(handle)
-	op.Time = int64(val)
+//export linksocks_ConnectorResponseMessage_ConnectorToken_Get
+func linksocks_ConnectorResponseMessage_ConnectorToken_Get(handle CGoHandle) *C.char {
+	op := ptrFromHandle_linksocks_ConnectorResponseMessage(handle)
+	return C.CString(op.ConnectorToken)
 }
 
-// --- wrapping struct: linksocks.AuthResponseMessage ---
-//
-//export linksocks_AuthResponseMessage_CTor
-func linksocks_AuthResponseMessage_CTor() CGoHandle {
-	return CGoHandle(handleFromPtr_linksocks_AuthResponseMessage(&linksocks.AuthResponseMessage{}))
+//export linksocks_ConnectorResponseMessage_ConnectorToken_Set
+func linksocks_ConnectorResponseMessage_ConnectorToken_Set(handle CGoHandle, val *C.char) {
+	op := ptrFromHandle_linksocks_ConnectorResponseMessage(handle)
+	op.ConnectorToken = C.GoString(val)
 }
 
-//export linksocks_AuthResponseMessage_Success_Get
-func linksocks_AuthResponseMessage_Success_Get(handle CGoHandle) C.char {
-	op := ptrFromHandle_linksocks_AuthResponseMessage(handle)
-	return boolGoToPy(op.Success)
-}
+//export linksocks_ConnectorResponseMessage_GetType
+func linksocks_ConnectorResponseMessage_GetType(_handle CGoHandle) *C.char {
+	_saved_thread := C.PyEval_SaveThread()
+	defer C.PyEval_RestoreThread(_saved_thread)
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.ConnectorResponseMessage")
+	if __err != nil {
+		return C.CString("")
+	}
+	return C.CString(gopyh.Embed(vifc, reflect.TypeOf(linksocks.ConnectorResponseMessage{})).(*linksocks.ConnectorResponseMessage).GetType())
 
-//export linksocks_AuthResponseMessage_Success_Set
-func linksocks_AuthResponseMessage_Success_Set(handle CGoHandle, val C.char) {
-	op := ptrFromHandle_linksocks_AuthResponseMessage(handle)
-	op.Success = boolPyToGo(val)
 }
 
-//export linksocks_AuthResponseMessage_Error_Get
-func linksocks_AuthResponseMessage_Error_Get(handle CGoHandle) *C.char {
-	op := ptrFromHandle_linksocks_AuthResponseMessage(handle)
-	return C.CString(op.Error)
+// --- wrapping struct: linksocks.ContextWithCancel ---
+//
+//export linksocks_ContextWithCancel_CTor
+func linksocks_ContextWithCancel_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_linksocks_ContextWithCancel(&linksocks.ContextWithCancel{}))
 }
 
-//export linksocks_AuthResponseMessage_Error_Set
-func linksocks_AuthResponseMessage_Error_Set(handle CGoHandle, val *C.char) {
-	op := ptrFromHandle_linksocks_AuthResponseMessage(handle)
-	op.Error = C.GoString(val)
+//export linksocks_ContextWithCancel_Cancel
+func linksocks_ContextWithCancel_Cancel(_handle CGoHandle, goRun C.char) {
+	_saved_thread := C.PyEval_SaveThread()
+	defer C.PyEval_RestoreThread(_saved_thread)
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.ContextWithCancel")
+	if __err != nil {
+		return
+	}
+	if boolPyToGo(goRun) {
+		go gopyh.Embed(vifc, reflect.TypeOf(linksocks.ContextWithCancel{})).(*linksocks.ContextWithCancel).Cancel()
+	} else {
+		gopyh.Embed(vifc, reflect.TypeOf(linksocks.ContextWithCancel{})).(*linksocks.ContextWithCancel).Cancel()
+	}
 }
 
-//export linksocks_AuthResponseMessage_GetType
-func linksocks_AuthResponseMessage_GetType(_handle CGoHandle) *C.char {
+//export linksocks_ContextWithCancel_Context
+func linksocks_ContextWithCancel_Context(_handle CGoHandle) CGoHandle {
 	_saved_thread := C.PyEval_SaveThread()
 	defer C.PyEval_RestoreThread(_saved_thread)
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.AuthResponseMessage")
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.ContextWithCancel")
 	if __err != nil {
-		return C.CString("")
+		return handleFromPtr_context_Context(nil)
 	}
-	return C.CString(gopyh.Embed(vifc, reflect.TypeOf(linksocks.AuthResponseMessage{})).(*linksocks.AuthResponseMessage).GetType())
+	return handleFromPtr_context_Context(gopyh.Embed(vifc, reflect.TypeOf(linksocks.ContextWithCancel{})).(*linksocks.ContextWithCancel).Context())
 
 }
 
-// --- wrapping struct: linksocks.ClientOption ---
+// --- wrapping struct: linksocks.LinkSocksServer ---
 //
-//export linksocks_ClientOption_CTor
-func linksocks_ClientOption_CTor() CGoHandle {
-	return CGoHandle(handleFromPtr_linksocks_ClientOption(&linksocks.ClientOption{}))
-}
-
-//export linksocks_ClientOption_WSURL_Get
-func linksocks_ClientOption_WSURL_Get(handle CGoHandle) *C.char {
-	op := ptrFromHandle_linksocks_ClientOption(handle)
-	return C.CString(op.WSURL)
-}
-
-//export linksocks_ClientOption_WSURL_Set
-func linksocks_ClientOption_WSURL_Set(handle CGoHandle, val *C.char) {
-	op := ptrFromHandle_linksocks_ClientOption(handle)
-	op.WSURL = C.GoString(val)
+//export linksocks_LinkSocksServer_CTor
+func linksocks_LinkSocksServer_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_linksocks_LinkSocksServer(&linksocks.LinkSocksServer{}))
 }
 
-//export linksocks_ClientOption_Reverse_Get
-func linksocks_ClientOption_Reverse_Get(handle CGoHandle) C.char {
-	op := ptrFromHandle_linksocks_ClientOption(handle)
-	return boolGoToPy(op.Reverse)
-}
+//export linksocks_LinkSocksServer_AddReverseToken
+func linksocks_LinkSocksServer_AddReverseToken(_handle CGoHandle, opts CGoHandle) CGoHandle {
+	_saved_thread := C.PyEval_SaveThread()
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.LinkSocksServer")
+	if __err != nil {
+		return handleFromPtr_Ptr_linksocks_ReverseTokenResult(nil)
+	}
+	cret, __err := gopyh.Embed(vifc, reflect.TypeOf(linksocks.LinkSocksServer{})).(*linksocks.LinkSocksServer).AddReverseToken(ptrFromHandle_Ptr_linksocks_ReverseTokenOptions(opts))
 
-//export linksocks_ClientOption_Reverse_Set
-func linksocks_ClientOption_Reverse_Set(handle CGoHandle, val C.char) {
-	op := ptrFromHandle_linksocks_ClientOption(handle)
-	op.Reverse = boolPyToGo(val)
+	C.PyEval_RestoreThread(_saved_thread)
+	if __err != nil {
+		estr := C.CString(__err.Error())
+		C.PyErr_SetString(C.PyExc_RuntimeError, estr)
+		C.free(unsafe.Pointer(estr))
+		return handleFromPtr_Ptr_linksocks_ReverseTokenResult(nil)
+	}
+	return handleFromPtr_Ptr_linksocks_ReverseTokenResult(cret)
 }
 
-//export linksocks_ClientOption_SocksHost_Get
-func linksocks_ClientOption_SocksHost_Get(handle CGoHandle) *C.char {
-	op := ptrFromHandle_linksocks_ClientOption(handle)
-	return C.CString(op.SocksHost)
-}
+//export linksocks_LinkSocksServer_AddForwardToken
+func linksocks_LinkSocksServer_AddForwardToken(_handle CGoHandle, token *C.char) *C.char {
+	_saved_thread := C.PyEval_SaveThread()
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.LinkSocksServer")
+	if __err != nil {
+		return C.CString("")
+	}
+	cret, __err := gopyh.Embed(vifc, reflect.TypeOf(linksocks.LinkSocksServer{})).(*linksocks.LinkSocksServer).AddForwardToken(C.GoString(token))
 
-//export linksocks_ClientOption_SocksHost_Set
-func linksocks_ClientOption_SocksHost_Set(handle CGoHandle, val *C.char) {
-	op := ptrFromHandle_linksocks_ClientOption(handle)
-	op.SocksHost = C.GoString(val)
+	C.PyEval_RestoreThread(_saved_thread)
+	if __err != nil {
+		estr := C.CString(__err.Error())
+		C.PyErr_SetString(C.PyExc_RuntimeError, estr)
+		C.free(unsafe.Pointer(estr))
+		return C.CString("")
+	}
+	return C.CString(cret)
 }
 
-//export linksocks_ClientOption_SocksPort_Get
-func linksocks_ClientOption_SocksPort_Get(handle CGoHandle) C.longlong {
-	op := ptrFromHandle_linksocks_ClientOption(handle)
-	return C.longlong(op.SocksPort)
-}
+//export linksocks_LinkSocksServer_AddConnectorToken
+func linksocks_LinkSocksServer_AddConnectorToken(_handle CGoHandle, connectorToken *C.char, reverseToken *C.char) *C.char {
+	_saved_thread := C.PyEval_SaveThread()
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.LinkSocksServer")
+	if __err != nil {
+		return C.CString("")
+	}
+	cret, __err := gopyh.Embed(vifc, reflect.TypeOf(linksocks.LinkSocksServer{})).(*linksocks.LinkSocksServer).AddConnectorToken(C.GoString(connectorToken), C.GoString(reverseToken))
 
-//export linksocks_ClientOption_SocksPort_Set
-func linksocks_ClientOption_SocksPort_Set(handle CGoHandle, val C.longlong) {
-	op := ptrFromHandle_linksocks_ClientOption(handle)
-	op.SocksPort = int(val)
+	C.PyEval_RestoreThread(_saved_thread)
+	if __err != nil {
+		estr := C.CString(__err.Error())
+		C.PyErr_SetString(C.PyExc_RuntimeError, estr)
+		C.free(unsafe.Pointer(estr))
+		return C.CString("")
+	}
+	return C.CString(cret)
 }
 
-//export linksocks_ClientOption_SocksUsername_Get
-func linksocks_ClientOption_SocksUsername_Get(handle CGoHandle) *C.char {
-	op := ptrFromHandle_linksocks_ClientOption(handle)
-	return C.CString(op.SocksUsername)
-}
+//export linksocks_LinkSocksServer_RemoveToken
+func linksocks_LinkSocksServer_RemoveToken(_handle CGoHandle, token *C.char) C.char {
+	_saved_thread := C.PyEval_SaveThread()
+	defer C.PyEval_RestoreThread(_saved_thread)
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.LinkSocksServer")
+	if __err != nil {
+		return boolGoToPy(false)
+	}
+	return boolGoToPy(gopyh.Embed(vifc, reflect.TypeOf(linksocks.LinkSocksServer{})).(*linksocks.LinkSocksServer).RemoveToken(C.GoString(token)))
 
-//export linksocks_ClientOption_SocksUsername_Set
-func linksocks_ClientOption_SocksUsername_Set(handle CGoHandle, val *C.char) {
-	op := ptrFromHandle_linksocks_ClientOption(handle)
-	op.SocksUsername = C.GoString(val)
 }
 
-//export linksocks_ClientOption_SocksPassword_Get
-func linksocks_ClientOption_SocksPassword_Get(handle CGoHandle) *C.char {
-	op := ptrFromHandle_linksocks_ClientOption(handle)
-	return C.CString(op.SocksPassword)
-}
+//export linksocks_LinkSocksServer_Serve
+func linksocks_LinkSocksServer_Serve(_handle CGoHandle, ctx CGoHandle) *C.char {
+	_saved_thread := C.PyEval_SaveThread()
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.LinkSocksServer")
+	if __err != nil {
+		return errorGoToPy(nil)
+	}
+	__err = gopyh.Embed(vifc, reflect.TypeOf(linksocks.LinkSocksServer{})).(*linksocks.LinkSocksServer).Serve(ptrFromHandle_context_Context(ctx))
 
-//export linksocks_ClientOption_SocksPassword_Set
-func linksocks_ClientOption_SocksPassword_Set(handle CGoHandle, val *C.char) {
-	op := ptrFromHandle_linksocks_ClientOption(handle)
-	op.SocksPassword = C.GoString(val)
+	C.PyEval_RestoreThread(_saved_thread)
+	if __err != nil {
+		estr := C.CString(__err.Error())
+		C.PyErr_SetString(C.PyExc_RuntimeError, estr)
+		return estr
+	}
+	return C.CString("")
 }
 
-//export linksocks_ClientOption_SocksWaitServer_Get
-func linksocks_ClientOption_SocksWaitServer_Get(handle CGoHandle) C.char {
-	op := ptrFromHandle_linksocks_ClientOption(handle)
-	return boolGoToPy(op.SocksWaitServer)
-}
-
-//export linksocks_ClientOption_SocksWaitServer_Set
-func linksocks_ClientOption_SocksWaitServer_Set(handle CGoHandle, val C.char) {
-	op := ptrFromHandle_linksocks_ClientOption(handle)
-	op.SocksWaitServer = boolPyToGo(val)
-}
-
-//export linksocks_ClientOption_Reconnect_Get
-func linksocks_ClientOption_Reconnect_Get(handle CGoHandle) C.char {
-	op := ptrFromHandle_linksocks_ClientOption(handle)
-	return boolGoToPy(op.Reconnect)
-}
-
-//export linksocks_ClientOption_Reconnect_Set
-func linksocks_ClientOption_Reconnect_Set(handle CGoHandle, val C.char) {
-	op := ptrFromHandle_linksocks_ClientOption(handle)
-	op.Reconnect = boolPyToGo(val)
-}
-
-//export linksocks_ClientOption_ReconnectDelay_Get
-func linksocks_ClientOption_ReconnectDelay_Get(handle CGoHandle) C.longlong {
-	op := ptrFromHandle_linksocks_ClientOption(handle)
-	return C.longlong(int64(op.ReconnectDelay))
-}
-
-//export linksocks_ClientOption_ReconnectDelay_Set
-func linksocks_ClientOption_ReconnectDelay_Set(handle CGoHandle, val C.longlong) {
-	op := ptrFromHandle_linksocks_ClientOption(handle)
-	op.ReconnectDelay = time.Duration(int64(val))
-}
-
-//export linksocks_ClientOption_Logger_Get
-func linksocks_ClientOption_Logger_Get(handle CGoHandle) CGoHandle {
-	op := ptrFromHandle_linksocks_ClientOption(handle)
-	return handleFromPtr_zerolog_Logger(&op.Logger)
-}
-
-//export linksocks_ClientOption_Logger_Set
-func linksocks_ClientOption_Logger_Set(handle CGoHandle, val CGoHandle) {
-	op := ptrFromHandle_linksocks_ClientOption(handle)
-	op.Logger = *ptrFromHandle_zerolog_Logger(val)
-}
-
-//export linksocks_ClientOption_BufferSize_Get
-func linksocks_ClientOption_BufferSize_Get(handle CGoHandle) C.longlong {
-	op := ptrFromHandle_linksocks_ClientOption(handle)
-	return C.longlong(op.BufferSize)
-}
-
-//export linksocks_ClientOption_BufferSize_Set
-func linksocks_ClientOption_BufferSize_Set(handle CGoHandle, val C.longlong) {
-	op := ptrFromHandle_linksocks_ClientOption(handle)
-	op.BufferSize = int(val)
-}
-
-//export linksocks_ClientOption_ChannelTimeout_Get
-func linksocks_ClientOption_ChannelTimeout_Get(handle CGoHandle) C.longlong {
-	op := ptrFromHandle_linksocks_ClientOption(handle)
-	return C.longlong(int64(op.ChannelTimeout))
-}
-
-//export linksocks_ClientOption_ChannelTimeout_Set
-func linksocks_ClientOption_ChannelTimeout_Set(handle CGoHandle, val C.longlong) {
-	op := ptrFromHandle_linksocks_ClientOption(handle)
-	op.ChannelTimeout = time.Duration(int64(val))
-}
-
-//export linksocks_ClientOption_ConnectTimeout_Get
-func linksocks_ClientOption_ConnectTimeout_Get(handle CGoHandle) C.longlong {
-	op := ptrFromHandle_linksocks_ClientOption(handle)
-	return C.longlong(int64(op.ConnectTimeout))
-}
-
-//export linksocks_ClientOption_ConnectTimeout_Set
-func linksocks_ClientOption_ConnectTimeout_Set(handle CGoHandle, val C.longlong) {
-	op := ptrFromHandle_linksocks_ClientOption(handle)
-	op.ConnectTimeout = time.Duration(int64(val))
-}
-
-//export linksocks_ClientOption_Threads_Get
-func linksocks_ClientOption_Threads_Get(handle CGoHandle) C.longlong {
-	op := ptrFromHandle_linksocks_ClientOption(handle)
-	return C.longlong(op.Threads)
-}
-
-//export linksocks_ClientOption_Threads_Set
-func linksocks_ClientOption_Threads_Set(handle CGoHandle, val C.longlong) {
-	op := ptrFromHandle_linksocks_ClientOption(handle)
-	op.Threads = int(val)
-}
-
-//export linksocks_ClientOption_FastOpen_Get
-func linksocks_ClientOption_FastOpen_Get(handle CGoHandle) C.char {
-	op := ptrFromHandle_linksocks_ClientOption(handle)
-	return boolGoToPy(op.FastOpen)
-}
-
-//export linksocks_ClientOption_FastOpen_Set
-func linksocks_ClientOption_FastOpen_Set(handle CGoHandle, val C.char) {
-	op := ptrFromHandle_linksocks_ClientOption(handle)
-	op.FastOpen = boolPyToGo(val)
-}
-
-//export linksocks_ClientOption_UpstreamProxy_Get
-func linksocks_ClientOption_UpstreamProxy_Get(handle CGoHandle) *C.char {
-	op := ptrFromHandle_linksocks_ClientOption(handle)
-	return C.CString(op.UpstreamProxy)
-}
-
-//export linksocks_ClientOption_UpstreamProxy_Set
-func linksocks_ClientOption_UpstreamProxy_Set(handle CGoHandle, val *C.char) {
-	op := ptrFromHandle_linksocks_ClientOption(handle)
-	op.UpstreamProxy = C.GoString(val)
-}
-
-//export linksocks_ClientOption_UpstreamUsername_Get
-func linksocks_ClientOption_UpstreamUsername_Get(handle CGoHandle) *C.char {
-	op := ptrFromHandle_linksocks_ClientOption(handle)
-	return C.CString(op.UpstreamUsername)
-}
-
-//export linksocks_ClientOption_UpstreamUsername_Set
-func linksocks_ClientOption_UpstreamUsername_Set(handle CGoHandle, val *C.char) {
-	op := ptrFromHandle_linksocks_ClientOption(handle)
-	op.UpstreamUsername = C.GoString(val)
-}
-
-//export linksocks_ClientOption_UpstreamPassword_Get
-func linksocks_ClientOption_UpstreamPassword_Get(handle CGoHandle) *C.char {
-	op := ptrFromHandle_linksocks_ClientOption(handle)
-	return C.CString(op.UpstreamPassword)
-}
-
-//export linksocks_ClientOption_UpstreamPassword_Set
-func linksocks_ClientOption_UpstreamPassword_Set(handle CGoHandle, val *C.char) {
-	op := ptrFromHandle_linksocks_ClientOption(handle)
-	op.UpstreamPassword = C.GoString(val)
-}
-
-//export linksocks_ClientOption_NoEnvProxy_Get
-func linksocks_ClientOption_NoEnvProxy_Get(handle CGoHandle) C.char {
-	op := ptrFromHandle_linksocks_ClientOption(handle)
-	return boolGoToPy(op.NoEnvProxy)
-}
-
-//export linksocks_ClientOption_NoEnvProxy_Set
-func linksocks_ClientOption_NoEnvProxy_Set(handle CGoHandle, val C.char) {
-	op := ptrFromHandle_linksocks_ClientOption(handle)
-	op.NoEnvProxy = boolPyToGo(val)
-}
-
-//export linksocks_ClientOption_WithWSURL
-func linksocks_ClientOption_WithWSURL(_handle CGoHandle, url *C.char) CGoHandle {
+//export linksocks_LinkSocksServer_WaitReady
+func linksocks_LinkSocksServer_WaitReady(_handle CGoHandle, ctx CGoHandle, timeout C.longlong) *C.char {
 	_saved_thread := C.PyEval_SaveThread()
-	defer C.PyEval_RestoreThread(_saved_thread)
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.ClientOption")
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.LinkSocksServer")
 	if __err != nil {
-		return handleFromPtr_Ptr_linksocks_ClientOption(nil)
+		return errorGoToPy(nil)
 	}
-	return handleFromPtr_Ptr_linksocks_ClientOption(gopyh.Embed(vifc, reflect.TypeOf(linksocks.ClientOption{})).(*linksocks.ClientOption).WithWSURL(C.GoString(url)))
-
-}
+	__err = gopyh.Embed(vifc, reflect.TypeOf(linksocks.LinkSocksServer{})).(*linksocks.LinkSocksServer).WaitReady(ptrFromHandle_context_Context(ctx), time.Duration(int64(timeout)))
 
-//export linksocks_ClientOption_WithReverse
-func linksocks_ClientOption_WithReverse(_handle CGoHandle, reverse C.char) CGoHandle {
-	_saved_thread := C.PyEval_SaveThread()
-	defer C.PyEval_RestoreThread(_saved_thread)
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.ClientOption")
+	C.PyEval_RestoreThread(_saved_thread)
 	if __err != nil {
-		return handleFromPtr_Ptr_linksocks_ClientOption(nil)
+		estr := C.CString(__err.Error())
+		C.PyErr_SetString(C.PyExc_RuntimeError, estr)
+		return estr
 	}
-	return handleFromPtr_Ptr_linksocks_ClientOption(gopyh.Embed(vifc, reflect.TypeOf(linksocks.ClientOption{})).(*linksocks.ClientOption).WithReverse(boolPyToGo(reverse)))
-
+	return C.CString("")
 }
 
-//export linksocks_ClientOption_WithSocksHost
-func linksocks_ClientOption_WithSocksHost(_handle CGoHandle, host *C.char) CGoHandle {
+//export linksocks_LinkSocksServer_Close
+func linksocks_LinkSocksServer_Close(_handle CGoHandle, goRun C.char) {
 	_saved_thread := C.PyEval_SaveThread()
 	defer C.PyEval_RestoreThread(_saved_thread)
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.ClientOption")
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.LinkSocksServer")
 	if __err != nil {
-		return handleFromPtr_Ptr_linksocks_ClientOption(nil)
+		return
+	}
+	if boolPyToGo(goRun) {
+		go gopyh.Embed(vifc, reflect.TypeOf(linksocks.LinkSocksServer{})).(*linksocks.LinkSocksServer).Close()
+	} else {
+		gopyh.Embed(vifc, reflect.TypeOf(linksocks.LinkSocksServer{})).(*linksocks.LinkSocksServer).Close()
 	}
-	return handleFromPtr_Ptr_linksocks_ClientOption(gopyh.Embed(vifc, reflect.TypeOf(linksocks.ClientOption{})).(*linksocks.ClientOption).WithSocksHost(C.GoString(host)))
-
 }
 
-//export linksocks_ClientOption_WithSocksPort
-func linksocks_ClientOption_WithSocksPort(_handle CGoHandle, port C.longlong) CGoHandle {
+//export linksocks_LinkSocksServer_GetClientCount
+func linksocks_LinkSocksServer_GetClientCount(_handle CGoHandle) C.longlong {
 	_saved_thread := C.PyEval_SaveThread()
 	defer C.PyEval_RestoreThread(_saved_thread)
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.ClientOption")
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.LinkSocksServer")
 	if __err != nil {
-		return handleFromPtr_Ptr_linksocks_ClientOption(nil)
+		return C.longlong(0)
 	}
-	return handleFromPtr_Ptr_linksocks_ClientOption(gopyh.Embed(vifc, reflect.TypeOf(linksocks.ClientOption{})).(*linksocks.ClientOption).WithSocksPort(int(port)))
+	return C.longlong(gopyh.Embed(vifc, reflect.TypeOf(linksocks.LinkSocksServer{})).(*linksocks.LinkSocksServer).GetClientCount())
 
 }
 
-//export linksocks_ClientOption_WithSocksUsername
-func linksocks_ClientOption_WithSocksUsername(_handle CGoHandle, username *C.char) CGoHandle {
+//export linksocks_LinkSocksServer_HasClients
+func linksocks_LinkSocksServer_HasClients(_handle CGoHandle) C.char {
 	_saved_thread := C.PyEval_SaveThread()
 	defer C.PyEval_RestoreThread(_saved_thread)
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.ClientOption")
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.LinkSocksServer")
 	if __err != nil {
-		return handleFromPtr_Ptr_linksocks_ClientOption(nil)
+		return boolGoToPy(false)
 	}
-	return handleFromPtr_Ptr_linksocks_ClientOption(gopyh.Embed(vifc, reflect.TypeOf(linksocks.ClientOption{})).(*linksocks.ClientOption).WithSocksUsername(C.GoString(username)))
+	return boolGoToPy(gopyh.Embed(vifc, reflect.TypeOf(linksocks.LinkSocksServer{})).(*linksocks.LinkSocksServer).HasClients())
 
 }
 
-//export linksocks_ClientOption_WithSocksPassword
-func linksocks_ClientOption_WithSocksPassword(_handle CGoHandle, password *C.char) CGoHandle {
+//export linksocks_LinkSocksServer_GetTokenClientCount
+func linksocks_LinkSocksServer_GetTokenClientCount(_handle CGoHandle, token *C.char) C.longlong {
 	_saved_thread := C.PyEval_SaveThread()
 	defer C.PyEval_RestoreThread(_saved_thread)
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.ClientOption")
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.LinkSocksServer")
 	if __err != nil {
-		return handleFromPtr_Ptr_linksocks_ClientOption(nil)
+		return C.longlong(0)
 	}
-	return handleFromPtr_Ptr_linksocks_ClientOption(gopyh.Embed(vifc, reflect.TypeOf(linksocks.ClientOption{})).(*linksocks.ClientOption).WithSocksPassword(C.GoString(password)))
+	return C.longlong(gopyh.Embed(vifc, reflect.TypeOf(linksocks.LinkSocksServer{})).(*linksocks.LinkSocksServer).GetTokenClientCount(C.GoString(token)))
 
 }
 
-//export linksocks_ClientOption_WithSocksWaitServer
-func linksocks_ClientOption_WithSocksWaitServer(_handle CGoHandle, wait C.char) CGoHandle {
-	_saved_thread := C.PyEval_SaveThread()
-	defer C.PyEval_RestoreThread(_saved_thread)
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.ClientOption")
-	if __err != nil {
-		return handleFromPtr_Ptr_linksocks_ClientOption(nil)
-	}
-	return handleFromPtr_Ptr_linksocks_ClientOption(gopyh.Embed(vifc, reflect.TypeOf(linksocks.ClientOption{})).(*linksocks.ClientOption).WithSocksWaitServer(boolPyToGo(wait)))
-
+// --- wrapping struct: linksocks.Relay ---
+//
+//export linksocks_Relay_CTor
+func linksocks_Relay_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_linksocks_Relay(&linksocks.Relay{}))
 }
 
-//export linksocks_ClientOption_WithReconnect
-func linksocks_ClientOption_WithReconnect(_handle CGoHandle, reconnect C.char) CGoHandle {
+//export linksocks_Relay_RefuseSocksRequest
+func linksocks_Relay_RefuseSocksRequest(_handle CGoHandle, conn CGoHandle, reason C.char) *C.char {
 	_saved_thread := C.PyEval_SaveThread()
-	defer C.PyEval_RestoreThread(_saved_thread)
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.ClientOption")
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.Relay")
 	if __err != nil {
-		return handleFromPtr_Ptr_linksocks_ClientOption(nil)
+		return errorGoToPy(nil)
 	}
-	return handleFromPtr_Ptr_linksocks_ClientOption(gopyh.Embed(vifc, reflect.TypeOf(linksocks.ClientOption{})).(*linksocks.ClientOption).WithReconnect(boolPyToGo(reconnect)))
+	__err = gopyh.Embed(vifc, reflect.TypeOf(linksocks.Relay{})).(*linksocks.Relay).RefuseSocksRequest(ptrFromHandle_net_Conn(conn), byte(reason))
 
+	C.PyEval_RestoreThread(_saved_thread)
+	if __err != nil {
+		estr := C.CString(__err.Error())
+		C.PyErr_SetString(C.PyExc_RuntimeError, estr)
+		return estr
+	}
+	return C.CString("")
 }
 
-//export linksocks_ClientOption_WithReconnectDelay
-func linksocks_ClientOption_WithReconnectDelay(_handle CGoHandle, delay C.longlong) CGoHandle {
+//export linksocks_Relay_HandleNetworkConnection
+func linksocks_Relay_HandleNetworkConnection(_handle CGoHandle, ctx CGoHandle, ws CGoHandle, request CGoHandle) *C.char {
 	_saved_thread := C.PyEval_SaveThread()
-	defer C.PyEval_RestoreThread(_saved_thread)
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.ClientOption")
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.Relay")
 	if __err != nil {
-		return handleFromPtr_Ptr_linksocks_ClientOption(nil)
+		return errorGoToPy(nil)
 	}
-	return handleFromPtr_Ptr_linksocks_ClientOption(gopyh.Embed(vifc, reflect.TypeOf(linksocks.ClientOption{})).(*linksocks.ClientOption).WithReconnectDelay(time.Duration(int64(delay))))
+	__err = gopyh.Embed(vifc, reflect.TypeOf(linksocks.Relay{})).(*linksocks.Relay).HandleNetworkConnection(ptrFromHandle_context_Context(ctx), ptrFromHandle_Ptr_linksocks_WSConn(ws), *ptrFromHandle_linksocks_ConnectMessage(request))
 
+	C.PyEval_RestoreThread(_saved_thread)
+	if __err != nil {
+		estr := C.CString(__err.Error())
+		C.PyErr_SetString(C.PyExc_RuntimeError, estr)
+		return estr
+	}
+	return C.CString("")
 }
 
-//export linksocks_ClientOption_WithLogger
-func linksocks_ClientOption_WithLogger(_handle CGoHandle, logger CGoHandle) CGoHandle {
+//export linksocks_Relay_HandleTCPConnection
+func linksocks_Relay_HandleTCPConnection(_handle CGoHandle, ctx CGoHandle, ws CGoHandle, request CGoHandle) *C.char {
 	_saved_thread := C.PyEval_SaveThread()
-	defer C.PyEval_RestoreThread(_saved_thread)
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.ClientOption")
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.Relay")
 	if __err != nil {
-		return handleFromPtr_Ptr_linksocks_ClientOption(nil)
+		return errorGoToPy(nil)
 	}
-	return handleFromPtr_Ptr_linksocks_ClientOption(gopyh.Embed(vifc, reflect.TypeOf(linksocks.ClientOption{})).(*linksocks.ClientOption).WithLogger(*ptrFromHandle_zerolog_Logger(logger)))
+	__err = gopyh.Embed(vifc, reflect.TypeOf(linksocks.Relay{})).(*linksocks.Relay).HandleTCPConnection(ptrFromHandle_context_Context(ctx), ptrFromHandle_Ptr_linksocks_WSConn(ws), *ptrFromHandle_linksocks_ConnectMessage(request))
 
+	C.PyEval_RestoreThread(_saved_thread)
+	if __err != nil {
+		estr := C.CString(__err.Error())
+		C.PyErr_SetString(C.PyExc_RuntimeError, estr)
+		return estr
+	}
+	return C.CString("")
 }
 
-//export linksocks_ClientOption_WithBufferSize
-func linksocks_ClientOption_WithBufferSize(_handle CGoHandle, size C.longlong) CGoHandle {
+//export linksocks_Relay_HandleUDPConnection
+func linksocks_Relay_HandleUDPConnection(_handle CGoHandle, ctx CGoHandle, ws CGoHandle, request CGoHandle) *C.char {
 	_saved_thread := C.PyEval_SaveThread()
-	defer C.PyEval_RestoreThread(_saved_thread)
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.ClientOption")
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.Relay")
 	if __err != nil {
-		return handleFromPtr_Ptr_linksocks_ClientOption(nil)
+		return errorGoToPy(nil)
 	}
-	return handleFromPtr_Ptr_linksocks_ClientOption(gopyh.Embed(vifc, reflect.TypeOf(linksocks.ClientOption{})).(*linksocks.ClientOption).WithBufferSize(int(size)))
+	__err = gopyh.Embed(vifc, reflect.TypeOf(linksocks.Relay{})).(*linksocks.Relay).HandleUDPConnection(ptrFromHandle_context_Context(ctx), ptrFromHandle_Ptr_linksocks_WSConn(ws), *ptrFromHandle_linksocks_ConnectMessage(request))
 
+	C.PyEval_RestoreThread(_saved_thread)
+	if __err != nil {
+		estr := C.CString(__err.Error())
+		C.PyErr_SetString(C.PyExc_RuntimeError, estr)
+		return estr
+	}
+	return C.CString("")
 }
 
-//export linksocks_ClientOption_WithChannelTimeout
-func linksocks_ClientOption_WithChannelTimeout(_handle CGoHandle, timeout C.longlong) CGoHandle {
+//export linksocks_Relay_HandleSocksRequest
+func linksocks_Relay_HandleSocksRequest(_handle CGoHandle, ctx CGoHandle, ws CGoHandle, socksConn CGoHandle, socksUsername *C.char, socksPassword *C.char) *C.char {
 	_saved_thread := C.PyEval_SaveThread()
-	defer C.PyEval_RestoreThread(_saved_thread)
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.ClientOption")
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.Relay")
 	if __err != nil {
-		return handleFromPtr_Ptr_linksocks_ClientOption(nil)
+		return errorGoToPy(nil)
 	}
-	return handleFromPtr_Ptr_linksocks_ClientOption(gopyh.Embed(vifc, reflect.TypeOf(linksocks.ClientOption{})).(*linksocks.ClientOption).WithChannelTimeout(time.Duration(int64(timeout))))
+	__err = gopyh.Embed(vifc, reflect.TypeOf(linksocks.Relay{})).(*linksocks.Relay).HandleSocksRequest(ptrFromHandle_context_Context(ctx), ptrFromHandle_Ptr_linksocks_WSConn(ws), ptrFromHandle_net_Conn(socksConn), C.GoString(socksUsername), C.GoString(socksPassword))
 
+	C.PyEval_RestoreThread(_saved_thread)
+	if __err != nil {
+		estr := C.CString(__err.Error())
+		C.PyErr_SetString(C.PyExc_RuntimeError, estr)
+		return estr
+	}
+	return C.CString("")
 }
 
-//export linksocks_ClientOption_WithConnectTimeout
-func linksocks_ClientOption_WithConnectTimeout(_handle CGoHandle, timeout C.longlong) CGoHandle {
+//export linksocks_Relay_HandleRemoteTCPForward
+func linksocks_Relay_HandleRemoteTCPForward(_handle CGoHandle, ctx CGoHandle, ws CGoHandle, remoteConn CGoHandle, channelID CGoHandle) *C.char {
 	_saved_thread := C.PyEval_SaveThread()
-	defer C.PyEval_RestoreThread(_saved_thread)
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.ClientOption")
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.Relay")
 	if __err != nil {
-		return handleFromPtr_Ptr_linksocks_ClientOption(nil)
+		return errorGoToPy(nil)
 	}
-	return handleFromPtr_Ptr_linksocks_ClientOption(gopyh.Embed(vifc, reflect.TypeOf(linksocks.ClientOption{})).(*linksocks.ClientOption).WithConnectTimeout(time.Duration(int64(timeout))))
+	__err = gopyh.Embed(vifc, reflect.TypeOf(linksocks.Relay{})).(*linksocks.Relay).HandleRemoteTCPForward(ptrFromHandle_context_Context(ctx), ptrFromHandle_Ptr_linksocks_WSConn(ws), ptrFromHandle_net_Conn(remoteConn), deptrFromHandle_uuid_UUID(channelID))
 
+	C.PyEval_RestoreThread(_saved_thread)
+	if __err != nil {
+		estr := C.CString(__err.Error())
+		C.PyErr_SetString(C.PyExc_RuntimeError, estr)
+		return estr
+	}
+	return C.CString("")
 }
 
-//export linksocks_ClientOption_WithThreads
-func linksocks_ClientOption_WithThreads(_handle CGoHandle, threads C.longlong) CGoHandle {
+//export linksocks_Relay_HandleRemoteUDPForward
+func linksocks_Relay_HandleRemoteUDPForward(_handle CGoHandle, ctx CGoHandle, ws CGoHandle, udpConn CGoHandle, channelID CGoHandle) *C.char {
 	_saved_thread := C.PyEval_SaveThread()
-	defer C.PyEval_RestoreThread(_saved_thread)
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.ClientOption")
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.Relay")
 	if __err != nil {
-		return handleFromPtr_Ptr_linksocks_ClientOption(nil)
+		return errorGoToPy(nil)
 	}
-	return handleFromPtr_Ptr_linksocks_ClientOption(gopyh.Embed(vifc, reflect.TypeOf(linksocks.ClientOption{})).(*linksocks.ClientOption).WithThreads(int(threads)))
+	__err = gopyh.Embed(vifc, reflect.TypeOf(linksocks.Relay{})).(*linksocks.Relay).HandleRemoteUDPForward(ptrFromHandle_context_Context(ctx), ptrFromHandle_Ptr_linksocks_WSConn(ws), ptrFromHandle_Ptr_net_UDPConn(udpConn), deptrFromHandle_uuid_UUID(channelID))
 
+	C.PyEval_RestoreThread(_saved_thread)
+	if __err != nil {
+		estr := C.CString(__err.Error())
+		C.PyErr_SetString(C.PyExc_RuntimeError, estr)
+		return estr
+	}
+	return C.CString("")
 }
 
-//export linksocks_ClientOption_WithFastOpen
-func linksocks_ClientOption_WithFastOpen(_handle CGoHandle, fastOpen C.char) CGoHandle {
+//export linksocks_Relay_HandleSocksTCPForward
+func linksocks_Relay_HandleSocksTCPForward(_handle CGoHandle, ctx CGoHandle, ws CGoHandle, socksConn CGoHandle, channelID CGoHandle) *C.char {
 	_saved_thread := C.PyEval_SaveThread()
-	defer C.PyEval_RestoreThread(_saved_thread)
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.ClientOption")
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.Relay")
 	if __err != nil {
-		return handleFromPtr_Ptr_linksocks_ClientOption(nil)
+		return errorGoToPy(nil)
 	}
-	return handleFromPtr_Ptr_linksocks_ClientOption(gopyh.Embed(vifc, reflect.TypeOf(linksocks.ClientOption{})).(*linksocks.ClientOption).WithFastOpen(boolPyToGo(fastOpen)))
+	__err = gopyh.Embed(vifc, reflect.TypeOf(linksocks.Relay{})).(*linksocks.Relay).HandleSocksTCPForward(ptrFromHandle_context_Context(ctx), ptrFromHandle_Ptr_linksocks_WSConn(ws), ptrFromHandle_net_Conn(socksConn), deptrFromHandle_uuid_UUID(channelID))
 
+	C.PyEval_RestoreThread(_saved_thread)
+	if __err != nil {
+		estr := C.CString(__err.Error())
+		C.PyErr_SetString(C.PyExc_RuntimeError, estr)
+		return estr
+	}
+	return C.CString("")
 }
 
-//export linksocks_ClientOption_WithUpstreamProxy
-func linksocks_ClientOption_WithUpstreamProxy(_handle CGoHandle, proxy *C.char) CGoHandle {
+//export linksocks_Relay_HandleSocksUDPForward
+func linksocks_Relay_HandleSocksUDPForward(_handle CGoHandle, ctx CGoHandle, ws CGoHandle, udpConn CGoHandle, socksConn CGoHandle, channelID CGoHandle) *C.char {
 	_saved_thread := C.PyEval_SaveThread()
-	defer C.PyEval_RestoreThread(_saved_thread)
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.ClientOption")
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.Relay")
 	if __err != nil {
-		return handleFromPtr_Ptr_linksocks_ClientOption(nil)
+		return errorGoToPy(nil)
 	}
-	return handleFromPtr_Ptr_linksocks_ClientOption(gopyh.Embed(vifc, reflect.TypeOf(linksocks.ClientOption{})).(*linksocks.ClientOption).WithUpstreamProxy(C.GoString(proxy)))
+	__err = gopyh.Embed(vifc, reflect.TypeOf(linksocks.Relay{})).(*linksocks.Relay).HandleSocksUDPForward(ptrFromHandle_context_Context(ctx), ptrFromHandle_Ptr_linksocks_WSConn(ws), ptrFromHandle_Ptr_net_UDPConn(udpConn), ptrFromHandle_net_Conn(socksConn), deptrFromHandle_uuid_UUID(channelID))
 
+	C.PyEval_RestoreThread(_saved_thread)
+	if __err != nil {
+		estr := C.CString(__err.Error())
+		C.PyErr_SetString(C.PyExc_RuntimeError, estr)
+		return estr
+	}
+	return C.CString("")
 }
 
-//export linksocks_ClientOption_WithUpstreamAuth
-func linksocks_ClientOption_WithUpstreamAuth(_handle CGoHandle, username *C.char, password *C.char) CGoHandle {
+//export linksocks_Relay_Close
+func linksocks_Relay_Close(_handle CGoHandle, goRun C.char) {
 	_saved_thread := C.PyEval_SaveThread()
 	defer C.PyEval_RestoreThread(_saved_thread)
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.ClientOption")
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.Relay")
 	if __err != nil {
-		return handleFromPtr_Ptr_linksocks_ClientOption(nil)
+		return
+	}
+	if boolPyToGo(goRun) {
+		go gopyh.Embed(vifc, reflect.TypeOf(linksocks.Relay{})).(*linksocks.Relay).Close()
+	} else {
+		gopyh.Embed(vifc, reflect.TypeOf(linksocks.Relay{})).(*linksocks.Relay).Close()
 	}
-	return handleFromPtr_Ptr_linksocks_ClientOption(gopyh.Embed(vifc, reflect.TypeOf(linksocks.ClientOption{})).(*linksocks.ClientOption).WithUpstreamAuth(C.GoString(username), C.GoString(password)))
-
 }
 
-//export linksocks_ClientOption_WithNoEnvProxy
-func linksocks_ClientOption_WithNoEnvProxy(_handle CGoHandle, noEnvProxy C.char) CGoHandle {
+//export linksocks_Relay_SetConnectionSuccess
+func linksocks_Relay_SetConnectionSuccess(_handle CGoHandle, channelID CGoHandle, goRun C.char) {
 	_saved_thread := C.PyEval_SaveThread()
 	defer C.PyEval_RestoreThread(_saved_thread)
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.ClientOption")
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.Relay")
 	if __err != nil {
-		return handleFromPtr_Ptr_linksocks_ClientOption(nil)
+		return
+	}
+	if boolPyToGo(goRun) {
+		go gopyh.Embed(vifc, reflect.TypeOf(linksocks.Relay{})).(*linksocks.Relay).SetConnectionSuccess(deptrFromHandle_uuid_UUID(channelID))
+	} else {
+		gopyh.Embed(vifc, reflect.TypeOf(linksocks.Relay{})).(*linksocks.Relay).SetConnectionSuccess(deptrFromHandle_uuid_UUID(channelID))
 	}
-	return handleFromPtr_Ptr_linksocks_ClientOption(gopyh.Embed(vifc, reflect.TypeOf(linksocks.ClientOption{})).(*linksocks.ClientOption).WithNoEnvProxy(boolPyToGo(noEnvProxy)))
-
 }
 
-// --- wrapping struct: linksocks.ConnectMessage ---
+// --- wrapping struct: linksocks.TokenStatus ---
 //
-//export linksocks_ConnectMessage_CTor
-func linksocks_ConnectMessage_CTor() CGoHandle {
-	return CGoHandle(handleFromPtr_linksocks_ConnectMessage(&linksocks.ConnectMessage{}))
+//export linksocks_TokenStatus_CTor
+func linksocks_TokenStatus_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_linksocks_TokenStatus(&linksocks.TokenStatus{}))
 }
 
-//export linksocks_ConnectMessage_Protocol_Get
-func linksocks_ConnectMessage_Protocol_Get(handle CGoHandle) *C.char {
-	op := ptrFromHandle_linksocks_ConnectMessage(handle)
-	return C.CString(op.Protocol)
+//export linksocks_TokenStatus_Token_Get
+func linksocks_TokenStatus_Token_Get(handle CGoHandle) *C.char {
+	op := ptrFromHandle_linksocks_TokenStatus(handle)
+	return C.CString(op.Token)
 }
 
-//export linksocks_ConnectMessage_Protocol_Set
-func linksocks_ConnectMessage_Protocol_Set(handle CGoHandle, val *C.char) {
-	op := ptrFromHandle_linksocks_ConnectMessage(handle)
-	op.Protocol = C.GoString(val)
+//export linksocks_TokenStatus_Token_Set
+func linksocks_TokenStatus_Token_Set(handle CGoHandle, val *C.char) {
+	op := ptrFromHandle_linksocks_TokenStatus(handle)
+	op.Token = C.GoString(val)
 }
 
-//export linksocks_ConnectMessage_Address_Get
-func linksocks_ConnectMessage_Address_Get(handle CGoHandle) *C.char {
-	op := ptrFromHandle_linksocks_ConnectMessage(handle)
-	return C.CString(op.Address)
+//export linksocks_TokenStatus_Type_Get
+func linksocks_TokenStatus_Type_Get(handle CGoHandle) *C.char {
+	op := ptrFromHandle_linksocks_TokenStatus(handle)
+	return C.CString(op.Type)
 }
 
-//export linksocks_ConnectMessage_Address_Set
-func linksocks_ConnectMessage_Address_Set(handle CGoHandle, val *C.char) {
-	op := ptrFromHandle_linksocks_ConnectMessage(handle)
-	op.Address = C.GoString(val)
+//export linksocks_TokenStatus_Type_Set
+func linksocks_TokenStatus_Type_Set(handle CGoHandle, val *C.char) {
+	op := ptrFromHandle_linksocks_TokenStatus(handle)
+	op.Type = C.GoString(val)
 }
 
-//export linksocks_ConnectMessage_Port_Get
-func linksocks_ConnectMessage_Port_Get(handle CGoHandle) C.longlong {
-	op := ptrFromHandle_linksocks_ConnectMessage(handle)
-	return C.longlong(op.Port)
+//export linksocks_TokenStatus_ClientsCount_Get
+func linksocks_TokenStatus_ClientsCount_Get(handle CGoHandle) C.longlong {
+	op := ptrFromHandle_linksocks_TokenStatus(handle)
+	return C.longlong(op.ClientsCount)
 }
 
-//export linksocks_ConnectMessage_Port_Set
-func linksocks_ConnectMessage_Port_Set(handle CGoHandle, val C.longlong) {
-	op := ptrFromHandle_linksocks_ConnectMessage(handle)
-	op.Port = int(val)
+//export linksocks_TokenStatus_ClientsCount_Set
+func linksocks_TokenStatus_ClientsCount_Set(handle CGoHandle, val C.longlong) {
+	op := ptrFromHandle_linksocks_TokenStatus(handle)
+	op.ClientsCount = int(val)
 }
 
-//export linksocks_ConnectMessage_ChannelID_Get
-func linksocks_ConnectMessage_ChannelID_Get(handle CGoHandle) CGoHandle {
-	op := ptrFromHandle_linksocks_ConnectMessage(handle)
-	return handleFromPtr_uuid_UUID(&op.ChannelID)
+// --- wrapping struct: linksocks.WSConn ---
+//
+//export linksocks_WSConn_CTor
+func linksocks_WSConn_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_linksocks_WSConn(&linksocks.WSConn{}))
 }
 
-//export linksocks_ConnectMessage_GetType
-func linksocks_ConnectMessage_GetType(_handle CGoHandle) *C.char {
+//export linksocks_WSConn_Label
+func linksocks_WSConn_Label(_handle CGoHandle) *C.char {
 	_saved_thread := C.PyEval_SaveThread()
 	defer C.PyEval_RestoreThread(_saved_thread)
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.ConnectMessage")
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.WSConn")
 	if __err != nil {
 		return C.CString("")
 	}
-	return C.CString(gopyh.Embed(vifc, reflect.TypeOf(linksocks.ConnectMessage{})).(*linksocks.ConnectMessage).GetType())
+	return C.CString(gopyh.Embed(vifc, reflect.TypeOf(linksocks.WSConn{})).(*linksocks.WSConn).Label())
 
 }
 
-// --- wrapping struct: linksocks.ConnectorMessage ---
-//
-//export linksocks_ConnectorMessage_CTor
-func linksocks_ConnectorMessage_CTor() CGoHandle {
-	return CGoHandle(handleFromPtr_linksocks_ConnectorMessage(&linksocks.ConnectorMessage{}))
+//export linksocks_WSConn_GetClientIP
+func linksocks_WSConn_GetClientIP(_handle CGoHandle) *C.char {
+	_saved_thread := C.PyEval_SaveThread()
+	defer C.PyEval_RestoreThread(_saved_thread)
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.WSConn")
+	if __err != nil {
+		return C.CString("")
+	}
+	return C.CString(gopyh.Embed(vifc, reflect.TypeOf(linksocks.WSConn{})).(*linksocks.WSConn).GetClientIP())
+
 }
 
-//export linksocks_ConnectorMessage_ChannelID_Get
-func linksocks_ConnectorMessage_ChannelID_Get(handle CGoHandle) CGoHandle {
-	op := ptrFromHandle_linksocks_ConnectorMessage(handle)
-	return handleFromPtr_uuid_UUID(&op.ChannelID)
+//export linksocks_WSConn_SetClientIPFromRequest
+func linksocks_WSConn_SetClientIPFromRequest(_handle CGoHandle, r CGoHandle, goRun C.char) {
+	_saved_thread := C.PyEval_SaveThread()
+	defer C.PyEval_RestoreThread(_saved_thread)
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.WSConn")
+	if __err != nil {
+		return
+	}
+	if boolPyToGo(goRun) {
+		go gopyh.Embed(vifc, reflect.TypeOf(linksocks.WSConn{})).(*linksocks.WSConn).SetClientIPFromRequest(ptrFromHandle_Ptr_http_Request(r))
+	} else {
+		gopyh.Embed(vifc, reflect.TypeOf(linksocks.WSConn{})).(*linksocks.WSConn).SetClientIPFromRequest(ptrFromHandle_Ptr_http_Request(r))
+	}
 }
 
-//export linksocks_ConnectorMessage_ConnectorToken_Get
-func linksocks_ConnectorMessage_ConnectorToken_Get(handle CGoHandle) *C.char {
-	op := ptrFromHandle_linksocks_ConnectorMessage(handle)
-	return C.CString(op.ConnectorToken)
-}
+//export linksocks_WSConn_SyncWriteBinary
+func linksocks_WSConn_SyncWriteBinary(_handle CGoHandle, data CGoHandle) *C.char {
+	_saved_thread := C.PyEval_SaveThread()
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.WSConn")
+	if __err != nil {
+		return errorGoToPy(nil)
+	}
+	__err = gopyh.Embed(vifc, reflect.TypeOf(linksocks.WSConn{})).(*linksocks.WSConn).SyncWriteBinary(deptrFromHandle_Slice_byte(data))
 
-//export linksocks_ConnectorMessage_ConnectorToken_Set
-func linksocks_ConnectorMessage_ConnectorToken_Set(handle CGoHandle, val *C.char) {
-	op := ptrFromHandle_linksocks_ConnectorMessage(handle)
-	op.ConnectorToken = C.GoString(val)
+	C.PyEval_RestoreThread(_saved_thread)
+	if __err != nil {
+		estr := C.CString(__err.Error())
+		C.PyErr_SetString(C.PyExc_RuntimeError, estr)
+		return estr
+	}
+	return C.CString("")
 }
 
-//export linksocks_ConnectorMessage_Operation_Get
-func linksocks_ConnectorMessage_Operation_Get(handle CGoHandle) *C.char {
-	op := ptrFromHandle_linksocks_ConnectorMessage(handle)
-	return C.CString(op.Operation)
-}
+//export linksocks_WSConn_ReadMessage
+func linksocks_WSConn_ReadMessage(_handle CGoHandle) CGoHandle {
+	_saved_thread := C.PyEval_SaveThread()
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.WSConn")
+	if __err != nil {
+		return handleFromPtr_linksocks_BaseMessage(nil)
+	}
+	cret, __err := gopyh.Embed(vifc, reflect.TypeOf(linksocks.WSConn{})).(*linksocks.WSConn).ReadMessage()
 
-//export linksocks_ConnectorMessage_Operation_Set
-func linksocks_ConnectorMessage_Operation_Set(handle CGoHandle, val *C.char) {
-	op := ptrFromHandle_linksocks_ConnectorMessage(handle)
-	op.Operation = C.GoString(val)
+	C.PyEval_RestoreThread(_saved_thread)
+	if __err != nil {
+		estr := C.CString(__err.Error())
+		C.PyErr_SetString(C.PyExc_RuntimeError, estr)
+		C.free(unsafe.Pointer(estr))
+		return handleFromPtr_linksocks_BaseMessage(nil)
+	}
+	return handleFromPtr_linksocks_BaseMessage(cret)
 }
 
-//export linksocks_ConnectorMessage_GetType
-func linksocks_ConnectorMessage_GetType(_handle CGoHandle) *C.char {
+//export linksocks_WSConn_WriteMessage
+func linksocks_WSConn_WriteMessage(_handle CGoHandle, msg CGoHandle) *C.char {
 	_saved_thread := C.PyEval_SaveThread()
-	defer C.PyEval_RestoreThread(_saved_thread)
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.ConnectorMessage")
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.WSConn")
 	if __err != nil {
-		return C.CString("")
+		return errorGoToPy(nil)
 	}
-	return C.CString(gopyh.Embed(vifc, reflect.TypeOf(linksocks.ConnectorMessage{})).(*linksocks.ConnectorMessage).GetType())
+	__err = gopyh.Embed(vifc, reflect.TypeOf(linksocks.WSConn{})).(*linksocks.WSConn).WriteMessage(ptrFromHandle_linksocks_BaseMessage(msg))
 
+	C.PyEval_RestoreThread(_saved_thread)
+	if __err != nil {
+		estr := C.CString(__err.Error())
+		C.PyErr_SetString(C.PyExc_RuntimeError, estr)
+		return estr
+	}
+	return C.CString("")
 }
 
-// --- wrapping struct: linksocks.TokenRequest ---
-//
-//export linksocks_TokenRequest_CTor
-func linksocks_TokenRequest_CTor() CGoHandle {
-	return CGoHandle(handleFromPtr_linksocks_TokenRequest(&linksocks.TokenRequest{}))
-}
+//export linksocks_WSConn_SyncWriteControl
+func linksocks_WSConn_SyncWriteControl(_handle CGoHandle, messageType C.longlong, data CGoHandle, deadline CGoHandle) *C.char {
+	_saved_thread := C.PyEval_SaveThread()
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.WSConn")
+	if __err != nil {
+		return errorGoToPy(nil)
+	}
+	__err = gopyh.Embed(vifc, reflect.TypeOf(linksocks.WSConn{})).(*linksocks.WSConn).SyncWriteControl(int(messageType), deptrFromHandle_Slice_byte(data), *ptrFromHandle_time_Time(deadline))
 
-//export linksocks_TokenRequest_Type_Get
-func linksocks_TokenRequest_Type_Get(handle CGoHandle) *C.char {
-	op := ptrFromHandle_linksocks_TokenRequest(handle)
-	return C.CString(op.Type)
+	C.PyEval_RestoreThread(_saved_thread)
+	if __err != nil {
+		estr := C.CString(__err.Error())
+		C.PyErr_SetString(C.PyExc_RuntimeError, estr)
+		return estr
+	}
+	return C.CString("")
 }
 
-//export linksocks_TokenRequest_Type_Set
-func linksocks_TokenRequest_Type_Set(handle CGoHandle, val *C.char) {
-	op := ptrFromHandle_linksocks_TokenRequest(handle)
-	op.Type = C.GoString(val)
+//export linksocks_WSConn_Close
+func linksocks_WSConn_Close(_handle CGoHandle) *C.char {
+	_saved_thread := C.PyEval_SaveThread()
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.WSConn")
+	if __err != nil {
+		return errorGoToPy(nil)
+	}
+	__err = gopyh.Embed(vifc, reflect.TypeOf(linksocks.WSConn{})).(*linksocks.WSConn).Close()
+
+	C.PyEval_RestoreThread(_saved_thread)
+	if __err != nil {
+		estr := C.CString(__err.Error())
+		C.PyErr_SetString(C.PyExc_RuntimeError, estr)
+		return estr
+	}
+	return C.CString("")
 }
 
-//export linksocks_TokenRequest_Token_Get
-func linksocks_TokenRequest_Token_Get(handle CGoHandle) *C.char {
-	op := ptrFromHandle_linksocks_TokenRequest(handle)
-	return C.CString(op.Token)
+// --- wrapping struct: linksocks.ClientOption ---
+//
+//export linksocks_ClientOption_CTor
+func linksocks_ClientOption_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_linksocks_ClientOption(&linksocks.ClientOption{}))
 }
 
-//export linksocks_TokenRequest_Token_Set
-func linksocks_TokenRequest_Token_Set(handle CGoHandle, val *C.char) {
-	op := ptrFromHandle_linksocks_TokenRequest(handle)
-	op.Token = C.GoString(val)
+//export linksocks_ClientOption_WSURL_Get
+func linksocks_ClientOption_WSURL_Get(handle CGoHandle) *C.char {
+	op := ptrFromHandle_linksocks_ClientOption(handle)
+	return C.CString(op.WSURL)
 }
 
-//export linksocks_TokenRequest_Port_Get
-func linksocks_TokenRequest_Port_Get(handle CGoHandle) C.longlong {
-	op := ptrFromHandle_linksocks_TokenRequest(handle)
-	return C.longlong(op.Port)
+//export linksocks_ClientOption_WSURL_Set
+func linksocks_ClientOption_WSURL_Set(handle CGoHandle, val *C.char) {
+	op := ptrFromHandle_linksocks_ClientOption(handle)
+	op.WSURL = C.GoString(val)
 }
 
-//export linksocks_TokenRequest_Port_Set
-func linksocks_TokenRequest_Port_Set(handle CGoHandle, val C.longlong) {
-	op := ptrFromHandle_linksocks_TokenRequest(handle)
-	op.Port = int(val)
+//export linksocks_ClientOption_Reverse_Get
+func linksocks_ClientOption_Reverse_Get(handle CGoHandle) C.char {
+	op := ptrFromHandle_linksocks_ClientOption(handle)
+	return boolGoToPy(op.Reverse)
 }
 
-//export linksocks_TokenRequest_Username_Get
-func linksocks_TokenRequest_Username_Get(handle CGoHandle) *C.char {
-	op := ptrFromHandle_linksocks_TokenRequest(handle)
-	return C.CString(op.Username)
+//export linksocks_ClientOption_Reverse_Set
+func linksocks_ClientOption_Reverse_Set(handle CGoHandle, val C.char) {
+	op := ptrFromHandle_linksocks_ClientOption(handle)
+	op.Reverse = boolPyToGo(val)
 }
 
-//export linksocks_TokenRequest_Username_Set
-func linksocks_TokenRequest_Username_Set(handle CGoHandle, val *C.char) {
-	op := ptrFromHandle_linksocks_TokenRequest(handle)
-	op.Username = C.GoString(val)
+//export linksocks_ClientOption_SocksHost_Get
+func linksocks_ClientOption_SocksHost_Get(handle CGoHandle) *C.char {
+	op := ptrFromHandle_linksocks_ClientOption(handle)
+	return C.CString(op.SocksHost)
 }
 
-//export linksocks_TokenRequest_Password_Get
-func linksocks_TokenRequest_Password_Get(handle CGoHandle) *C.char {
-	op := ptrFromHandle_linksocks_TokenRequest(handle)
-	return C.CString(op.Password)
+//export linksocks_ClientOption_SocksHost_Set
+func linksocks_ClientOption_SocksHost_Set(handle CGoHandle, val *C.char) {
+	op := ptrFromHandle_linksocks_ClientOption(handle)
+	op.SocksHost = C.GoString(val)
 }
 
-//export linksocks_TokenRequest_Password_Set
-func linksocks_TokenRequest_Password_Set(handle CGoHandle, val *C.char) {
-	op := ptrFromHandle_linksocks_TokenRequest(handle)
-	op.Password = C.GoString(val)
+//export linksocks_ClientOption_SocksPort_Get
+func linksocks_ClientOption_SocksPort_Get(handle CGoHandle) C.longlong {
+	op := ptrFromHandle_linksocks_ClientOption(handle)
+	return C.longlong(op.SocksPort)
 }
 
-//export linksocks_TokenRequest_ReverseToken_Get
-func linksocks_TokenRequest_ReverseToken_Get(handle CGoHandle) *C.char {
-	op := ptrFromHandle_linksocks_TokenRequest(handle)
-	return C.CString(op.ReverseToken)
+//export linksocks_ClientOption_SocksPort_Set
+func linksocks_ClientOption_SocksPort_Set(handle CGoHandle, val C.longlong) {
+	op := ptrFromHandle_linksocks_ClientOption(handle)
+	op.SocksPort = int(val)
 }
 
-//export linksocks_TokenRequest_ReverseToken_Set
-func linksocks_TokenRequest_ReverseToken_Set(handle CGoHandle, val *C.char) {
-	op := ptrFromHandle_linksocks_TokenRequest(handle)
-	op.ReverseToken = C.GoString(val)
+//export linksocks_ClientOption_SocksUsername_Get
+func linksocks_ClientOption_SocksUsername_Get(handle CGoHandle) *C.char {
+	op := ptrFromHandle_linksocks_ClientOption(handle)
+	return C.CString(op.SocksUsername)
 }
 
-//export linksocks_TokenRequest_AllowManageConnector_Get
-func linksocks_TokenRequest_AllowManageConnector_Get(handle CGoHandle) C.char {
-	op := ptrFromHandle_linksocks_TokenRequest(handle)
-	return boolGoToPy(op.AllowManageConnector)
+//export linksocks_ClientOption_SocksUsername_Set
+func linksocks_ClientOption_SocksUsername_Set(handle CGoHandle, val *C.char) {
+	op := ptrFromHandle_linksocks_ClientOption(handle)
+	op.SocksUsername = C.GoString(val)
 }
 
-//export linksocks_TokenRequest_AllowManageConnector_Set
-func linksocks_TokenRequest_AllowManageConnector_Set(handle CGoHandle, val C.char) {
-	op := ptrFromHandle_linksocks_TokenRequest(handle)
-	op.AllowManageConnector = boolPyToGo(val)
+//export linksocks_ClientOption_SocksPassword_Get
+func linksocks_ClientOption_SocksPassword_Get(handle CGoHandle) *C.char {
+	op := ptrFromHandle_linksocks_ClientOption(handle)
+	return C.CString(op.SocksPassword)
 }
 
-// --- wrapping struct: linksocks.AuthMessage ---
-//
-//export linksocks_AuthMessage_CTor
-func linksocks_AuthMessage_CTor() CGoHandle {
-	return CGoHandle(handleFromPtr_linksocks_AuthMessage(&linksocks.AuthMessage{}))
+//export linksocks_ClientOption_SocksPassword_Set
+func linksocks_ClientOption_SocksPassword_Set(handle CGoHandle, val *C.char) {
+	op := ptrFromHandle_linksocks_ClientOption(handle)
+	op.SocksPassword = C.GoString(val)
 }
 
-//export linksocks_AuthMessage_Token_Get
-func linksocks_AuthMessage_Token_Get(handle CGoHandle) *C.char {
-	op := ptrFromHandle_linksocks_AuthMessage(handle)
-	return C.CString(op.Token)
+//export linksocks_ClientOption_SocksWaitServer_Get
+func linksocks_ClientOption_SocksWaitServer_Get(handle CGoHandle) C.char {
+	op := ptrFromHandle_linksocks_ClientOption(handle)
+	return boolGoToPy(op.SocksWaitServer)
 }
 
-//export linksocks_AuthMessage_Token_Set
-func linksocks_AuthMessage_Token_Set(handle CGoHandle, val *C.char) {
-	op := ptrFromHandle_linksocks_AuthMessage(handle)
-	op.Token = C.GoString(val)
+//export linksocks_ClientOption_SocksWaitServer_Set
+func linksocks_ClientOption_SocksWaitServer_Set(handle CGoHandle, val C.char) {
+	op := ptrFromHandle_linksocks_ClientOption(handle)
+	op.SocksWaitServer = boolPyToGo(val)
 }
 
-//export linksocks_AuthMessage_Reverse_Get
-func linksocks_AuthMessage_Reverse_Get(handle CGoHandle) C.char {
-	op := ptrFromHandle_linksocks_AuthMessage(handle)
-	return boolGoToPy(op.Reverse)
+//export linksocks_ClientOption_Reconnect_Get
+func linksocks_ClientOption_Reconnect_Get(handle CGoHandle) C.char {
+	op := ptrFromHandle_linksocks_ClientOption(handle)
+	return boolGoToPy(op.Reconnect)
 }
 
-//export linksocks_AuthMessage_Reverse_Set
-func linksocks_AuthMessage_Reverse_Set(handle CGoHandle, val C.char) {
-	op := ptrFromHandle_linksocks_AuthMessage(handle)
-	op.Reverse = boolPyToGo(val)
+//export linksocks_ClientOption_Reconnect_Set
+func linksocks_ClientOption_Reconnect_Set(handle CGoHandle, val C.char) {
+	op := ptrFromHandle_linksocks_ClientOption(handle)
+	op.Reconnect = boolPyToGo(val)
 }
 
-//export linksocks_AuthMessage_Instance_Get
-func linksocks_AuthMessage_Instance_Get(handle CGoHandle) CGoHandle {
-	op := ptrFromHandle_linksocks_AuthMessage(handle)
-	return handleFromPtr_uuid_UUID(&op.Instance)
+//export linksocks_ClientOption_ReconnectDelay_Get
+func linksocks_ClientOption_ReconnectDelay_Get(handle CGoHandle) C.longlong {
+	op := ptrFromHandle_linksocks_ClientOption(handle)
+	return C.longlong(int64(op.ReconnectDelay))
 }
 
-//export linksocks_AuthMessage_GetType
-func linksocks_AuthMessage_GetType(_handle CGoHandle) *C.char {
-	_saved_thread := C.PyEval_SaveThread()
-	defer C.PyEval_RestoreThread(_saved_thread)
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.AuthMessage")
-	if __err != nil {
-		return C.CString("")
-	}
-	return C.CString(gopyh.Embed(vifc, reflect.TypeOf(linksocks.AuthMessage{})).(*linksocks.AuthMessage).GetType())
+//export linksocks_ClientOption_ReconnectDelay_Set
+func linksocks_ClientOption_ReconnectDelay_Set(handle CGoHandle, val C.longlong) {
+	op := ptrFromHandle_linksocks_ClientOption(handle)
+	op.ReconnectDelay = time.Duration(int64(val))
+}
 
+//export linksocks_ClientOption_Logger_Get
+func linksocks_ClientOption_Logger_Get(handle CGoHandle) CGoHandle {
+	op := ptrFromHandle_linksocks_ClientOption(handle)
+	return handleFromPtr_zerolog_Logger(&op.Logger)
 }
 
-// --- wrapping struct: linksocks.ConnectorResponseMessage ---
-//
-//export linksocks_ConnectorResponseMessage_CTor
-func linksocks_ConnectorResponseMessage_CTor() CGoHandle {
-	return CGoHandle(handleFromPtr_linksocks_ConnectorResponseMessage(&linksocks.ConnectorResponseMessage{}))
+//export linksocks_ClientOption_Logger_Set
+func linksocks_ClientOption_Logger_Set(handle CGoHandle, val CGoHandle) {
+	op := ptrFromHandle_linksocks_ClientOption(handle)
+	op.Logger = *ptrFromHandle_zerolog_Logger(val)
 }
 
-//export linksocks_ConnectorResponseMessage_Success_Get
-func linksocks_ConnectorResponseMessage_Success_Get(handle CGoHandle) C.char {
-	op := ptrFromHandle_linksocks_ConnectorResponseMessage(handle)
-	return boolGoToPy(op.Success)
+//export linksocks_ClientOption_BufferSize_Get
+func linksocks_ClientOption_BufferSize_Get(handle CGoHandle) C.longlong {
+	op := ptrFromHandle_linksocks_ClientOption(handle)
+	return C.longlong(op.BufferSize)
 }
 
-//export linksocks_ConnectorResponseMessage_Success_Set
-func linksocks_ConnectorResponseMessage_Success_Set(handle CGoHandle, val C.char) {
-	op := ptrFromHandle_linksocks_ConnectorResponseMessage(handle)
-	op.Success = boolPyToGo(val)
+//export linksocks_ClientOption_BufferSize_Set
+func linksocks_ClientOption_BufferSize_Set(handle CGoHandle, val C.longlong) {
+	op := ptrFromHandle_linksocks_ClientOption(handle)
+	op.BufferSize = int(val)
 }
 
-//export linksocks_ConnectorResponseMessage_Error_Get
-func linksocks_ConnectorResponseMessage_Error_Get(handle CGoHandle) *C.char {
-	op := ptrFromHandle_linksocks_ConnectorResponseMessage(handle)
-	return C.CString(op.Error)
+//export linksocks_ClientOption_ChannelTimeout_Get
+func linksocks_ClientOption_ChannelTimeout_Get(handle CGoHandle) C.longlong {
+	op := ptrFromHandle_linksocks_ClientOption(handle)
+	return C.longlong(int64(op.ChannelTimeout))
 }
 
-//export linksocks_ConnectorResponseMessage_Error_Set
-func linksocks_ConnectorResponseMessage_Error_Set(handle CGoHandle, val *C.char) {
-	op := ptrFromHandle_linksocks_ConnectorResponseMessage(handle)
-	op.Error = C.GoString(val)
+//export linksocks_ClientOption_ChannelTimeout_Set
+func linksocks_ClientOption_ChannelTimeout_Set(handle CGoHandle, val C.longlong) {
+	op := ptrFromHandle_linksocks_ClientOption(handle)
+	op.ChannelTimeout = time.Duration(int64(val))
 }
 
-//export linksocks_ConnectorResponseMessage_ChannelID_Get
-func linksocks_ConnectorResponseMessage_ChannelID_Get(handle CGoHandle) CGoHandle {
-	op := ptrFromHandle_linksocks_ConnectorResponseMessage(handle)
-	return handleFromPtr_uuid_UUID(&op.ChannelID)
+//export linksocks_ClientOption_ConnectTimeout_Get
+func linksocks_ClientOption_ConnectTimeout_Get(handle CGoHandle) C.longlong {
+	op := ptrFromHandle_linksocks_ClientOption(handle)
+	return C.longlong(int64(op.ConnectTimeout))
 }
 
-//export linksocks_ConnectorResponseMessage_ConnectorToken_Get
-func linksocks_ConnectorResponseMessage_ConnectorToken_Get(handle CGoHandle) *C.char {
-	op := ptrFromHandle_linksocks_ConnectorResponseMessage(handle)
-	return C.CString(op.ConnectorToken)
+//export linksocks_ClientOption_ConnectTimeout_Set
+func linksocks_ClientOption_ConnectTimeout_Set(handle CGoHandle, val C.longlong) {
+	op := ptrFromHandle_linksocks_ClientOption(handle)
+	op.ConnectTimeout = time.Duration(int64(val))
 }
 
-//export linksocks_ConnectorResponseMessage_ConnectorToken_Set
-func linksocks_ConnectorResponseMessage_ConnectorToken_Set(handle CGoHandle, val *C.char) {
-	op := ptrFromHandle_linksocks_ConnectorResponseMessage(handle)
-	op.ConnectorToken = C.GoString(val)
+//export linksocks_ClientOption_Threads_Get
+func linksocks_ClientOption_Threads_Get(handle CGoHandle) C.longlong {
+	op := ptrFromHandle_linksocks_ClientOption(handle)
+	return C.longlong(op.Threads)
 }
 
-//export linksocks_ConnectorResponseMessage_GetType
-func linksocks_ConnectorResponseMessage_GetType(_handle CGoHandle) *C.char {
-	_saved_thread := C.PyEval_SaveThread()
-	defer C.PyEval_RestoreThread(_saved_thread)
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.ConnectorResponseMessage")
-	if __err != nil {
-		return C.CString("")
-	}
-	return C.CString(gopyh.Embed(vifc, reflect.TypeOf(linksocks.ConnectorResponseMessage{})).(*linksocks.ConnectorResponseMessage).GetType())
+//export linksocks_ClientOption_Threads_Set
+func linksocks_ClientOption_Threads_Set(handle CGoHandle, val C.longlong) {
+	op := ptrFromHandle_linksocks_ClientOption(handle)
+	op.Threads = int(val)
+}
 
+//export linksocks_ClientOption_FastOpen_Get
+func linksocks_ClientOption_FastOpen_Get(handle CGoHandle) C.char {
+	op := ptrFromHandle_linksocks_ClientOption(handle)
+	return boolGoToPy(op.FastOpen)
 }
 
-// --- wrapping struct: linksocks.DisconnectMessage ---
-//
-//export linksocks_DisconnectMessage_CTor
-func linksocks_DisconnectMessage_CTor() CGoHandle {
-	return CGoHandle(handleFromPtr_linksocks_DisconnectMessage(&linksocks.DisconnectMessage{}))
+//export linksocks_ClientOption_FastOpen_Set
+func linksocks_ClientOption_FastOpen_Set(handle CGoHandle, val C.char) {
+	op := ptrFromHandle_linksocks_ClientOption(handle)
+	op.FastOpen = boolPyToGo(val)
 }
 
-//export linksocks_DisconnectMessage_ChannelID_Get
-func linksocks_DisconnectMessage_ChannelID_Get(handle CGoHandle) CGoHandle {
-	op := ptrFromHandle_linksocks_DisconnectMessage(handle)
-	return handleFromPtr_uuid_UUID(&op.ChannelID)
+//export linksocks_ClientOption_UpstreamProxy_Get
+func linksocks_ClientOption_UpstreamProxy_Get(handle CGoHandle) *C.char {
+	op := ptrFromHandle_linksocks_ClientOption(handle)
+	return C.CString(op.UpstreamProxy)
 }
 
-//export linksocks_DisconnectMessage_Error_Get
-func linksocks_DisconnectMessage_Error_Get(handle CGoHandle) *C.char {
-	op := ptrFromHandle_linksocks_DisconnectMessage(handle)
-	return C.CString(op.Error)
+//export linksocks_ClientOption_UpstreamProxy_Set
+func linksocks_ClientOption_UpstreamProxy_Set(handle CGoHandle, val *C.char) {
+	op := ptrFromHandle_linksocks_ClientOption(handle)
+	op.UpstreamProxy = C.GoString(val)
 }
 
-//export linksocks_DisconnectMessage_Error_Set
-func linksocks_DisconnectMessage_Error_Set(handle CGoHandle, val *C.char) {
-	op := ptrFromHandle_linksocks_DisconnectMessage(handle)
-	op.Error = C.GoString(val)
+//export linksocks_ClientOption_UpstreamUsername_Get
+func linksocks_ClientOption_UpstreamUsername_Get(handle CGoHandle) *C.char {
+	op := ptrFromHandle_linksocks_ClientOption(handle)
+	return C.CString(op.UpstreamUsername)
 }
 
-//export linksocks_DisconnectMessage_GetType
-func linksocks_DisconnectMessage_GetType(_handle CGoHandle) *C.char {
-	_saved_thread := C.PyEval_SaveThread()
-	defer C.PyEval_RestoreThread(_saved_thread)
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.DisconnectMessage")
-	if __err != nil {
-		return C.CString("")
-	}
-	return C.CString(gopyh.Embed(vifc, reflect.TypeOf(linksocks.DisconnectMessage{})).(*linksocks.DisconnectMessage).GetType())
+//export linksocks_ClientOption_UpstreamUsername_Set
+func linksocks_ClientOption_UpstreamUsername_Set(handle CGoHandle, val *C.char) {
+	op := ptrFromHandle_linksocks_ClientOption(handle)
+	op.UpstreamUsername = C.GoString(val)
+}
 
+//export linksocks_ClientOption_UpstreamPassword_Get
+func linksocks_ClientOption_UpstreamPassword_Get(handle CGoHandle) *C.char {
+	op := ptrFromHandle_linksocks_ClientOption(handle)
+	return C.CString(op.UpstreamPassword)
 }
 
-// --- wrapping struct: linksocks.PartnersMessage ---
-//
-//export linksocks_PartnersMessage_CTor
-func linksocks_PartnersMessage_CTor() CGoHandle {
-	return CGoHandle(handleFromPtr_linksocks_PartnersMessage(&linksocks.PartnersMessage{}))
+//export linksocks_ClientOption_UpstreamPassword_Set
+func linksocks_ClientOption_UpstreamPassword_Set(handle CGoHandle, val *C.char) {
+	op := ptrFromHandle_linksocks_ClientOption(handle)
+	op.UpstreamPassword = C.GoString(val)
 }
 
-//export linksocks_PartnersMessage_Count_Get
-func linksocks_PartnersMessage_Count_Get(handle CGoHandle) C.longlong {
-	op := ptrFromHandle_linksocks_PartnersMessage(handle)
-	return C.longlong(op.Count)
+//export linksocks_ClientOption_NoEnvProxy_Get
+func linksocks_ClientOption_NoEnvProxy_Get(handle CGoHandle) C.char {
+	op := ptrFromHandle_linksocks_ClientOption(handle)
+	return boolGoToPy(op.NoEnvProxy)
 }
 
-//export linksocks_PartnersMessage_Count_Set
-func linksocks_PartnersMessage_Count_Set(handle CGoHandle, val C.longlong) {
-	op := ptrFromHandle_linksocks_PartnersMessage(handle)
-	op.Count = int(val)
+//export linksocks_ClientOption_NoEnvProxy_Set
+func linksocks_ClientOption_NoEnvProxy_Set(handle CGoHandle, val C.char) {
+	op := ptrFromHandle_linksocks_ClientOption(handle)
+	op.NoEnvProxy = boolPyToGo(val)
 }
 
-//export linksocks_PartnersMessage_GetType
-func linksocks_PartnersMessage_GetType(_handle CGoHandle) *C.char {
+//export linksocks_ClientOption_WithWSURL
+func linksocks_ClientOption_WithWSURL(_handle CGoHandle, url *C.char) CGoHandle {
 	_saved_thread := C.PyEval_SaveThread()
 	defer C.PyEval_RestoreThread(_saved_thread)
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.PartnersMessage")
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.ClientOption")
 	if __err != nil {
-		return C.CString("")
+		return handleFromPtr_Ptr_linksocks_ClientOption(nil)
 	}
-	return C.CString(gopyh.Embed(vifc, reflect.TypeOf(linksocks.PartnersMessage{})).(*linksocks.PartnersMessage).GetType())
-
-}
-
-// --- wrapping struct: linksocks.ReverseTokenOptions ---
-//
-//export linksocks_ReverseTokenOptions_CTor
-func linksocks_ReverseTokenOptions_CTor() CGoHandle {
-	return CGoHandle(handleFromPtr_linksocks_ReverseTokenOptions(&linksocks.ReverseTokenOptions{}))
-}
-
-//export linksocks_ReverseTokenOptions_Token_Get
-func linksocks_ReverseTokenOptions_Token_Get(handle CGoHandle) *C.char {
-	op := ptrFromHandle_linksocks_ReverseTokenOptions(handle)
-	return C.CString(op.Token)
-}
+	return handleFromPtr_Ptr_linksocks_ClientOption(gopyh.Embed(vifc, reflect.TypeOf(linksocks.ClientOption{})).(*linksocks.ClientOption).WithWSURL(C.GoString(url)))
 
-//export linksocks_ReverseTokenOptions_Token_Set
-func linksocks_ReverseTokenOptions_Token_Set(handle CGoHandle, val *C.char) {
-	op := ptrFromHandle_linksocks_ReverseTokenOptions(handle)
-	op.Token = C.GoString(val)
 }
 
-//export linksocks_ReverseTokenOptions_Port_Get
-func linksocks_ReverseTokenOptions_Port_Get(handle CGoHandle) C.longlong {
-	op := ptrFromHandle_linksocks_ReverseTokenOptions(handle)
-	return C.longlong(op.Port)
-}
+//export linksocks_ClientOption_WithReverse
+func linksocks_ClientOption_WithReverse(_handle CGoHandle, reverse C.char) CGoHandle {
+	_saved_thread := C.PyEval_SaveThread()
+	defer C.PyEval_RestoreThread(_saved_thread)
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.ClientOption")
+	if __err != nil {
+		return handleFromPtr_Ptr_linksocks_ClientOption(nil)
+	}
+	return handleFromPtr_Ptr_linksocks_ClientOption(gopyh.Embed(vifc, reflect.TypeOf(linksocks.ClientOption{})).(*linksocks.ClientOption).WithReverse(boolPyToGo(reverse)))
 
-//export linksocks_ReverseTokenOptions_Port_Set
-func linksocks_ReverseTokenOptions_Port_Set(handle CGoHandle, val C.longlong) {
-	op := ptrFromHandle_linksocks_ReverseTokenOptions(handle)
-	op.Port = int(val)
 }
 
-//export linksocks_ReverseTokenOptions_Username_Get
-func linksocks_ReverseTokenOptions_Username_Get(handle CGoHandle) *C.char {
-	op := ptrFromHandle_linksocks_ReverseTokenOptions(handle)
-	return C.CString(op.Username)
-}
+//export linksocks_ClientOption_WithSocksHost
+func linksocks_ClientOption_WithSocksHost(_handle CGoHandle, host *C.char) CGoHandle {
+	_saved_thread := C.PyEval_SaveThread()
+	defer C.PyEval_RestoreThread(_saved_thread)
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.ClientOption")
+	if __err != nil {
+		return handleFromPtr_Ptr_linksocks_ClientOption(nil)
+	}
+	return handleFromPtr_Ptr_linksocks_ClientOption(gopyh.Embed(vifc, reflect.TypeOf(linksocks.ClientOption{})).(*linksocks.ClientOption).WithSocksHost(C.GoString(host)))
 
-//export linksocks_ReverseTokenOptions_Username_Set
-func linksocks_ReverseTokenOptions_Username_Set(handle CGoHandle, val *C.char) {
-	op := ptrFromHandle_linksocks_ReverseTokenOptions(handle)
-	op.Username = C.GoString(val)
 }
 
-//export linksocks_ReverseTokenOptions_Password_Get
-func linksocks_ReverseTokenOptions_Password_Get(handle CGoHandle) *C.char {
-	op := ptrFromHandle_linksocks_ReverseTokenOptions(handle)
-	return C.CString(op.Password)
-}
+//export linksocks_ClientOption_WithSocksPort
+func linksocks_ClientOption_WithSocksPort(_handle CGoHandle, port C.longlong) CGoHandle {
+	_saved_thread := C.PyEval_SaveThread()
+	defer C.PyEval_RestoreThread(_saved_thread)
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.ClientOption")
+	if __err != nil {
+		return handleFromPtr_Ptr_linksocks_ClientOption(nil)
+	}
+	return handleFromPtr_Ptr_linksocks_ClientOption(gopyh.Embed(vifc, reflect.TypeOf(linksocks.ClientOption{})).(*linksocks.ClientOption).WithSocksPort(int(port)))
 
-//export linksocks_ReverseTokenOptions_Password_Set
-func linksocks_ReverseTokenOptions_Password_Set(handle CGoHandle, val *C.char) {
-	op := ptrFromHandle_linksocks_ReverseTokenOptions(handle)
-	op.Password = C.GoString(val)
 }
 
-//export linksocks_ReverseTokenOptions_AllowManageConnector_Get
-func linksocks_ReverseTokenOptions_AllowManageConnector_Get(handle CGoHandle) C.char {
-	op := ptrFromHandle_linksocks_ReverseTokenOptions(handle)
-	return boolGoToPy(op.AllowManageConnector)
-}
+//export linksocks_ClientOption_WithSocksUsername
+func linksocks_ClientOption_WithSocksUsername(_handle CGoHandle, username *C.char) CGoHandle {
+	_saved_thread := C.PyEval_SaveThread()
+	defer C.PyEval_RestoreThread(_saved_thread)
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.ClientOption")
+	if __err != nil {
+		return handleFromPtr_Ptr_linksocks_ClientOption(nil)
+	}
+	return handleFromPtr_Ptr_linksocks_ClientOption(gopyh.Embed(vifc, reflect.TypeOf(linksocks.ClientOption{})).(*linksocks.ClientOption).WithSocksUsername(C.GoString(username)))
 
-//export linksocks_ReverseTokenOptions_AllowManageConnector_Set
-func linksocks_ReverseTokenOptions_AllowManageConnector_Set(handle CGoHandle, val C.char) {
-	op := ptrFromHandle_linksocks_ReverseTokenOptions(handle)
-	op.AllowManageConnector = boolPyToGo(val)
 }
 
-// --- wrapping struct: linksocks.ReverseTokenResult ---
-//
-//export linksocks_ReverseTokenResult_CTor
-func linksocks_ReverseTokenResult_CTor() CGoHandle {
-	return CGoHandle(handleFromPtr_linksocks_ReverseTokenResult(&linksocks.ReverseTokenResult{}))
-}
+//export linksocks_ClientOption_WithSocksPassword
+func linksocks_ClientOption_WithSocksPassword(_handle CGoHandle, password *C.char) CGoHandle {
+	_saved_thread := C.PyEval_SaveThread()
+	defer C.PyEval_RestoreThread(_saved_thread)
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.ClientOption")
+	if __err != nil {
+		return handleFromPtr_Ptr_linksocks_ClientOption(nil)
+	}
+	return handleFromPtr_Ptr_linksocks_ClientOption(gopyh.Embed(vifc, reflect.TypeOf(linksocks.ClientOption{})).(*linksocks.ClientOption).WithSocksPassword(C.GoString(password)))
 
-//export linksocks_ReverseTokenResult_Token_Get
-func linksocks_ReverseTokenResult_Token_Get(handle CGoHandle) *C.char {
-	op := ptrFromHandle_linksocks_ReverseTokenResult(handle)
-	return C.CString(op.Token)
 }
 
-//export linksocks_ReverseTokenResult_Token_Set
-func linksocks_ReverseTokenResult_Token_Set(handle CGoHandle, val *C.char) {
-	op := ptrFromHandle_linksocks_ReverseTokenResult(handle)
-	op.Token = C.GoString(val)
-}
+//export linksocks_ClientOption_WithSocksWaitServer
+func linksocks_ClientOption_WithSocksWaitServer(_handle CGoHandle, wait C.char) CGoHandle {
+	_saved_thread := C.PyEval_SaveThread()
+	defer C.PyEval_RestoreThread(_saved_thread)
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.ClientOption")
+	if __err != nil {
+		return handleFromPtr_Ptr_linksocks_ClientOption(nil)
+	}
+	return handleFromPtr_Ptr_linksocks_ClientOption(gopyh.Embed(vifc, reflect.TypeOf(linksocks.ClientOption{})).(*linksocks.ClientOption).WithSocksWaitServer(boolPyToGo(wait)))
 
-//export linksocks_ReverseTokenResult_Port_Get
-func linksocks_ReverseTokenResult_Port_Get(handle CGoHandle) C.longlong {
-	op := ptrFromHandle_linksocks_ReverseTokenResult(handle)
-	return C.longlong(op.Port)
 }
 
-//export linksocks_ReverseTokenResult_Port_Set
-func linksocks_ReverseTokenResult_Port_Set(handle CGoHandle, val C.longlong) {
-	op := ptrFromHandle_linksocks_ReverseTokenResult(handle)
-	op.Port = int(val)
-}
+//export linksocks_ClientOption_WithReconnect
+func linksocks_ClientOption_WithReconnect(_handle CGoHandle, reconnect C.char) CGoHandle {
+	_saved_thread := C.PyEval_SaveThread()
+	defer C.PyEval_RestoreThread(_saved_thread)
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.ClientOption")
+	if __err != nil {
+		return handleFromPtr_Ptr_linksocks_ClientOption(nil)
+	}
+	return handleFromPtr_Ptr_linksocks_ClientOption(gopyh.Embed(vifc, reflect.TypeOf(linksocks.ClientOption{})).(*linksocks.ClientOption).WithReconnect(boolPyToGo(reconnect)))
 
-// --- wrapping struct: linksocks.APIHandler ---
-//
-//export linksocks_APIHandler_CTor
-func linksocks_APIHandler_CTor() CGoHandle {
-	return CGoHandle(handleFromPtr_linksocks_APIHandler(&linksocks.APIHandler{}))
 }
 
-//export linksocks_APIHandler_RegisterHandlers
-func linksocks_APIHandler_RegisterHandlers(_handle CGoHandle, mux CGoHandle, goRun C.char) {
+//export linksocks_ClientOption_WithReconnectDelay
+func linksocks_ClientOption_WithReconnectDelay(_handle CGoHandle, delay C.longlong) CGoHandle {
 	_saved_thread := C.PyEval_SaveThread()
 	defer C.PyEval_RestoreThread(_saved_thread)
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.APIHandler")
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.ClientOption")
 	if __err != nil {
-		return
-	}
-	if boolPyToGo(goRun) {
-		go gopyh.Embed(vifc, reflect.TypeOf(linksocks.APIHandler{})).(*linksocks.APIHandler).RegisterHandlers(ptrFromHandle_Ptr_http_ServeMux(mux))
-	} else {
-		gopyh.Embed(vifc, reflect.TypeOf(linksocks.APIHandler{})).(*linksocks.APIHandler).RegisterHandlers(ptrFromHandle_Ptr_http_ServeMux(mux))
+		return handleFromPtr_Ptr_linksocks_ClientOption(nil)
 	}
-}
+	return handleFromPtr_Ptr_linksocks_ClientOption(gopyh.Embed(vifc, reflect.TypeOf(linksocks.ClientOption{})).(*linksocks.ClientOption).WithReconnectDelay(time.Duration(int64(delay))))
 
-// --- wrapping struct: linksocks.ConnectResponseMessage ---
-//
-//export linksocks_ConnectResponseMessage_CTor
-func linksocks_ConnectResponseMessage_CTor() CGoHandle {
-	return CGoHandle(handleFromPtr_linksocks_ConnectResponseMessage(&linksocks.ConnectResponseMessage{}))
 }
 
-//export linksocks_ConnectResponseMessage_Success_Get
-func linksocks_ConnectResponseMessage_Success_Get(handle CGoHandle) C.char {
-	op := ptrFromHandle_linksocks_ConnectResponseMessage(handle)
-	return boolGoToPy(op.Success)
-}
+//export linksocks_ClientOption_WithLogger
+func linksocks_ClientOption_WithLogger(_handle CGoHandle, logger CGoHandle) CGoHandle {
+	_saved_thread := C.PyEval_SaveThread()
+	defer C.PyEval_RestoreThread(_saved_thread)
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.ClientOption")
+	if __err != nil {
+		return handleFromPtr_Ptr_linksocks_ClientOption(nil)
+	}
+	return handleFromPtr_Ptr_linksocks_ClientOption(gopyh.Embed(vifc, reflect.TypeOf(linksocks.ClientOption{})).(*linksocks.ClientOption).WithLogger(*ptrFromHandle_zerolog_Logger(logger)))
 
-//export linksocks_ConnectResponseMessage_Success_Set
-func linksocks_ConnectResponseMessage_Success_Set(handle CGoHandle, val C.char) {
-	op := ptrFromHandle_linksocks_ConnectResponseMessage(handle)
-	op.Success = boolPyToGo(val)
 }
 
-//export linksocks_ConnectResponseMessage_Error_Get
-func linksocks_ConnectResponseMessage_Error_Get(handle CGoHandle) *C.char {
-	op := ptrFromHandle_linksocks_ConnectResponseMessage(handle)
-	return C.CString(op.Error)
-}
+//export linksocks_ClientOption_WithBufferSize
+func linksocks_ClientOption_WithBufferSize(_handle CGoHandle, size C.longlong) CGoHandle {
+	_saved_thread := C.PyEval_SaveThread()
+	defer C.PyEval_RestoreThread(_saved_thread)
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.ClientOption")
+	if __err != nil {
+		return handleFromPtr_Ptr_linksocks_ClientOption(nil)
+	}
+	return handleFromPtr_Ptr_linksocks_ClientOption(gopyh.Embed(vifc, reflect.TypeOf(linksocks.ClientOption{})).(*linksocks.ClientOption).WithBufferSize(int(size)))
 
-//export linksocks_ConnectResponseMessage_Error_Set
-func linksocks_ConnectResponseMessage_Error_Set(handle CGoHandle, val *C.char) {
-	op := ptrFromHandle_linksocks_ConnectResponseMessage(handle)
-	op.Error = C.GoString(val)
 }
 
-//export linksocks_ConnectResponseMessage_ChannelID_Get
-func linksocks_ConnectResponseMessage_ChannelID_Get(handle CGoHandle) CGoHandle {
-	op := ptrFromHandle_linksocks_ConnectResponseMessage(handle)
-	return handleFromPtr_uuid_UUID(&op.ChannelID)
+//export linksocks_ClientOption_WithChannelTimeout
+func linksocks_ClientOption_WithChannelTimeout(_handle CGoHandle, timeout C.longlong) CGoHandle {
+	_saved_thread := C.PyEval_SaveThread()
+	defer C.PyEval_RestoreThread(_saved_thread)
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.ClientOption")
+	if __err != nil {
+		return handleFromPtr_Ptr_linksocks_ClientOption(nil)
+	}
+	return handleFromPtr_Ptr_linksocks_ClientOption(gopyh.Embed(vifc, reflect.TypeOf(linksocks.ClientOption{})).(*linksocks.ClientOption).WithChannelTimeout(time.Duration(int64(timeout))))
+
 }
 
-//export linksocks_ConnectResponseMessage_GetType
-func linksocks_ConnectResponseMessage_GetType(_handle CGoHandle) *C.char {
+//export linksocks_ClientOption_WithConnectTimeout
+func linksocks_ClientOption_WithConnectTimeout(_handle CGoHandle, timeout C.longlong) CGoHandle {
 	_saved_thread := C.PyEval_SaveThread()
 	defer C.PyEval_RestoreThread(_saved_thread)
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.ConnectResponseMessage")
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.ClientOption")
 	if __err != nil {
-		return C.CString("")
+		return handleFromPtr_Ptr_linksocks_ClientOption(nil)
 	}
-	return C.CString(gopyh.Embed(vifc, reflect.TypeOf(linksocks.ConnectResponseMessage{})).(*linksocks.ConnectResponseMessage).GetType())
+	return handleFromPtr_Ptr_linksocks_ClientOption(gopyh.Embed(vifc, reflect.TypeOf(linksocks.ClientOption{})).(*linksocks.ClientOption).WithConnectTimeout(time.Duration(int64(timeout))))
 
 }
 
-// --- wrapping struct: linksocks.DataMessage ---
-//
-//export linksocks_DataMessage_CTor
-func linksocks_DataMessage_CTor() CGoHandle {
-	return CGoHandle(handleFromPtr_linksocks_DataMessage(&linksocks.DataMessage{}))
-}
+//export linksocks_ClientOption_WithThreads
+func linksocks_ClientOption_WithThreads(_handle CGoHandle, threads C.longlong) CGoHandle {
+	_saved_thread := C.PyEval_SaveThread()
+	defer C.PyEval_RestoreThread(_saved_thread)
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.ClientOption")
+	if __err != nil {
+		return handleFromPtr_Ptr_linksocks_ClientOption(nil)
+	}
+	return handleFromPtr_Ptr_linksocks_ClientOption(gopyh.Embed(vifc, reflect.TypeOf(linksocks.ClientOption{})).(*linksocks.ClientOption).WithThreads(int(threads)))
 
-//export linksocks_DataMessage_Protocol_Get
-func linksocks_DataMessage_Protocol_Get(handle CGoHandle) *C.char {
-	op := ptrFromHandle_linksocks_DataMessage(handle)
-	return C.CString(op.Protocol)
 }
 
-//export linksocks_DataMessage_Protocol_Set
-func linksocks_DataMessage_Protocol_Set(handle CGoHandle, val *C.char) {
-	op := ptrFromHandle_linksocks_DataMessage(handle)
-	op.Protocol = C.GoString(val)
-}
+//export linksocks_ClientOption_WithFastOpen
+func linksocks_ClientOption_WithFastOpen(_handle CGoHandle, fastOpen C.char) CGoHandle {
+	_saved_thread := C.PyEval_SaveThread()
+	defer C.PyEval_RestoreThread(_saved_thread)
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.ClientOption")
+	if __err != nil {
+		return handleFromPtr_Ptr_linksocks_ClientOption(nil)
+	}
+	return handleFromPtr_Ptr_linksocks_ClientOption(gopyh.Embed(vifc, reflect.TypeOf(linksocks.ClientOption{})).(*linksocks.ClientOption).WithFastOpen(boolPyToGo(fastOpen)))
 
-//export linksocks_DataMessage_ChannelID_Get
-func linksocks_DataMessage_ChannelID_Get(handle CGoHandle) CGoHandle {
-	op := ptrFromHandle_linksocks_DataMessage(handle)
-	return handleFromPtr_uuid_UUID(&op.ChannelID)
 }
 
-//export linksocks_DataMessage_Data_Get
-func linksocks_DataMessage_Data_Get(handle CGoHandle) CGoHandle {
-	op := ptrFromHandle_linksocks_DataMessage(handle)
-	return handleFromPtr_Slice_byte(&op.Data)
-}
+//export linksocks_ClientOption_WithUpstreamProxy
+func linksocks_ClientOption_WithUpstreamProxy(_handle CGoHandle, proxy *C.char) CGoHandle {
+	_saved_thread := C.PyEval_SaveThread()
+	defer C.PyEval_RestoreThread(_saved_thread)
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.ClientOption")
+	if __err != nil {
+		return handleFromPtr_Ptr_linksocks_ClientOption(nil)
+	}
+	return handleFromPtr_Ptr_linksocks_ClientOption(gopyh.Embed(vifc, reflect.TypeOf(linksocks.ClientOption{})).(*linksocks.ClientOption).WithUpstreamProxy(C.GoString(proxy)))
 
-//export linksocks_DataMessage_Data_Set
-func linksocks_DataMessage_Data_Set(handle CGoHandle, val CGoHandle) {
-	op := ptrFromHandle_linksocks_DataMessage(handle)
-	op.Data = deptrFromHandle_Slice_byte(val)
 }
 
-//export linksocks_DataMessage_Compression_Get
-func linksocks_DataMessage_Compression_Get(handle CGoHandle) C.char {
-	op := ptrFromHandle_linksocks_DataMessage(handle)
-	return C.char(op.Compression)
-}
+//export linksocks_ClientOption_WithUpstreamAuth
+func linksocks_ClientOption_WithUpstreamAuth(_handle CGoHandle, username *C.char, password *C.char) CGoHandle {
+	_saved_thread := C.PyEval_SaveThread()
+	defer C.PyEval_RestoreThread(_saved_thread)
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.ClientOption")
+	if __err != nil {
+		return handleFromPtr_Ptr_linksocks_ClientOption(nil)
+	}
+	return handleFromPtr_Ptr_linksocks_ClientOption(gopyh.Embed(vifc, reflect.TypeOf(linksocks.ClientOption{})).(*linksocks.ClientOption).WithUpstreamAuth(C.GoString(username), C.GoString(password)))
 
-//export linksocks_DataMessage_Compression_Set
-func linksocks_DataMessage_Compression_Set(handle CGoHandle, val C.char) {
-	op := ptrFromHandle_linksocks_DataMessage(handle)
-	op.Compression = byte(val)
 }
 
-//export linksocks_DataMessage_Address_Get
-func linksocks_DataMessage_Address_Get(handle CGoHandle) *C.char {
-	op := ptrFromHandle_linksocks_DataMessage(handle)
-	return C.CString(op.Address)
-}
+//export linksocks_ClientOption_WithNoEnvProxy
+func linksocks_ClientOption_WithNoEnvProxy(_handle CGoHandle, noEnvProxy C.char) CGoHandle {
+	_saved_thread := C.PyEval_SaveThread()
+	defer C.PyEval_RestoreThread(_saved_thread)
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.ClientOption")
+	if __err != nil {
+		return handleFromPtr_Ptr_linksocks_ClientOption(nil)
+	}
+	return handleFromPtr_Ptr_linksocks_ClientOption(gopyh.Embed(vifc, reflect.TypeOf(linksocks.ClientOption{})).(*linksocks.ClientOption).WithNoEnvProxy(boolPyToGo(noEnvProxy)))
 
-//export linksocks_DataMessage_Address_Set
-func linksocks_DataMessage_Address_Set(handle CGoHandle, val *C.char) {
-	op := ptrFromHandle_linksocks_DataMessage(handle)
-	op.Address = C.GoString(val)
 }
 
-//export linksocks_DataMessage_Port_Get
-func linksocks_DataMessage_Port_Get(handle CGoHandle) C.longlong {
-	op := ptrFromHandle_linksocks_DataMessage(handle)
-	return C.longlong(op.Port)
+// --- wrapping struct: linksocks.ConnectResponseMessage ---
+//
+//export linksocks_ConnectResponseMessage_CTor
+func linksocks_ConnectResponseMessage_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_linksocks_ConnectResponseMessage(&linksocks.ConnectResponseMessage{}))
 }
 
-//export linksocks_DataMessage_Port_Set
-func linksocks_DataMessage_Port_Set(handle CGoHandle, val C.longlong) {
-	op := ptrFromHandle_linksocks_DataMessage(handle)
-	op.Port = int(val)
+//export linksocks_ConnectResponseMessage_Success_Get
+func linksocks_ConnectResponseMessage_Success_Get(handle CGoHandle) C.char {
+	op := ptrFromHandle_linksocks_ConnectResponseMessage(handle)
+	return boolGoToPy(op.Success)
 }
 
-//export linksocks_DataMessage_TargetAddr_Get
-func linksocks_DataMessage_TargetAddr_Get(handle CGoHandle) *C.char {
-	op := ptrFromHandle_linksocks_DataMessage(handle)
-	return C.CString(op.TargetAddr)
+//export linksocks_ConnectResponseMessage_Success_Set
+func linksocks_ConnectResponseMessage_Success_Set(handle CGoHandle, val C.char) {
+	op := ptrFromHandle_linksocks_ConnectResponseMessage(handle)
+	op.Success = boolPyToGo(val)
 }
 
-//export linksocks_DataMessage_TargetAddr_Set
-func linksocks_DataMessage_TargetAddr_Set(handle CGoHandle, val *C.char) {
-	op := ptrFromHandle_linksocks_DataMessage(handle)
-	op.TargetAddr = C.GoString(val)
+//export linksocks_ConnectResponseMessage_Error_Get
+func linksocks_ConnectResponseMessage_Error_Get(handle CGoHandle) *C.char {
+	op := ptrFromHandle_linksocks_ConnectResponseMessage(handle)
+	return C.CString(op.Error)
 }
 
-//export linksocks_DataMessage_TargetPort_Get
-func linksocks_DataMessage_TargetPort_Get(handle CGoHandle) C.longlong {
-	op := ptrFromHandle_linksocks_DataMessage(handle)
-	return C.longlong(op.TargetPort)
+//export linksocks_ConnectResponseMessage_Error_Set
+func linksocks_ConnectResponseMessage_Error_Set(handle CGoHandle, val *C.char) {
+	op := ptrFromHandle_linksocks_ConnectResponseMessage(handle)
+	op.Error = C.GoString(val)
 }
 
-//export linksocks_DataMessage_TargetPort_Set
-func linksocks_DataMessage_TargetPort_Set(handle CGoHandle, val C.longlong) {
-	op := ptrFromHandle_linksocks_DataMessage(handle)
-	op.TargetPort = int(val)
+//export linksocks_ConnectResponseMessage_ChannelID_Get
+func linksocks_ConnectResponseMessage_ChannelID_Get(handle CGoHandle) CGoHandle {
+	op := ptrFromHandle_linksocks_ConnectResponseMessage(handle)
+	return handleFromPtr_uuid_UUID(&op.ChannelID)
 }
 
-//export linksocks_DataMessage_GetType
-func linksocks_DataMessage_GetType(_handle CGoHandle) *C.char {
+//export linksocks_ConnectResponseMessage_GetType
+func linksocks_ConnectResponseMessage_GetType(_handle CGoHandle) *C.char {
 	_saved_thread := C.PyEval_SaveThread()
 	defer C.PyEval_RestoreThread(_saved_thread)
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.DataMessage")
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.ConnectResponseMessage")
 	if __err != nil {
 		return C.CString("")
 	}
-	return C.CString(gopyh.Embed(vifc, reflect.TypeOf(linksocks.DataMessage{})).(*linksocks.DataMessage).GetType())
+	return C.CString(gopyh.Embed(vifc, reflect.TypeOf(linksocks.ConnectResponseMessage{})).(*linksocks.ConnectResponseMessage).GetType())
 
 }
 
-// --- wrapping struct: linksocks.LogMessage ---
+// --- wrapping struct: linksocks.ConnectorMessage ---
 //
-//export linksocks_LogMessage_CTor
-func linksocks_LogMessage_CTor() CGoHandle {
-	return CGoHandle(handleFromPtr_linksocks_LogMessage(&linksocks.LogMessage{}))
+//export linksocks_ConnectorMessage_CTor
+func linksocks_ConnectorMessage_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_linksocks_ConnectorMessage(&linksocks.ConnectorMessage{}))
 }
 
-//export linksocks_LogMessage_Level_Get
-func linksocks_LogMessage_Level_Get(handle CGoHandle) *C.char {
-	op := ptrFromHandle_linksocks_LogMessage(handle)
-	return C.CString(op.Level)
+//export linksocks_ConnectorMessage_ChannelID_Get
+func linksocks_ConnectorMessage_ChannelID_Get(handle CGoHandle) CGoHandle {
+	op := ptrFromHandle_linksocks_ConnectorMessage(handle)
+	return handleFromPtr_uuid_UUID(&op.ChannelID)
 }
 
-//export linksocks_LogMessage_Level_Set
-func linksocks_LogMessage_Level_Set(handle CGoHandle, val *C.char) {
-	op := ptrFromHandle_linksocks_LogMessage(handle)
-	op.Level = C.GoString(val)
+//export linksocks_ConnectorMessage_ConnectorToken_Get
+func linksocks_ConnectorMessage_ConnectorToken_Get(handle CGoHandle) *C.char {
+	op := ptrFromHandle_linksocks_ConnectorMessage(handle)
+	return C.CString(op.ConnectorToken)
 }
 
-//export linksocks_LogMessage_Msg_Get
-func linksocks_LogMessage_Msg_Get(handle CGoHandle) *C.char {
-	op := ptrFromHandle_linksocks_LogMessage(handle)
-	return C.CString(op.Msg)
+//export linksocks_ConnectorMessage_ConnectorToken_Set
+func linksocks_ConnectorMessage_ConnectorToken_Set(handle CGoHandle, val *C.char) {
+	op := ptrFromHandle_linksocks_ConnectorMessage(handle)
+	op.ConnectorToken = C.GoString(val)
 }
 
-//export linksocks_LogMessage_Msg_Set
-func linksocks_LogMessage_Msg_Set(handle CGoHandle, val *C.char) {
-	op := ptrFromHandle_linksocks_LogMessage(handle)
-	op.Msg = C.GoString(val)
+//export linksocks_ConnectorMessage_Operation_Get
+func linksocks_ConnectorMessage_Operation_Get(handle CGoHandle) *C.char {
+	op := ptrFromHandle_linksocks_ConnectorMessage(handle)
+	return C.CString(op.Operation)
 }
 
-//export linksocks_LogMessage_GetType
-func linksocks_LogMessage_GetType(_handle CGoHandle) *C.char {
+//export linksocks_ConnectorMessage_Operation_Set
+func linksocks_ConnectorMessage_Operation_Set(handle CGoHandle, val *C.char) {
+	op := ptrFromHandle_linksocks_ConnectorMessage(handle)
+	op.Operation = C.GoString(val)
+}
+
+//export linksocks_ConnectorMessage_GetType
+func linksocks_ConnectorMessage_GetType(_handle CGoHandle) *C.char {
 	_saved_thread := C.PyEval_SaveThread()
 	defer C.PyEval_RestoreThread(_saved_thread)
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.LogMessage")
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.ConnectorMessage")
 	if __err != nil {
 		return C.CString("")
 	}
-	return C.CString(gopyh.Embed(vifc, reflect.TypeOf(linksocks.LogMessage{})).(*linksocks.LogMessage).GetType())
+	return C.CString(gopyh.Embed(vifc, reflect.TypeOf(linksocks.ConnectorMessage{})).(*linksocks.ConnectorMessage).GetType())
 
 }
 
-// --- wrapping struct: linksocks.PortPool ---
+// --- wrapping struct: linksocks.PartnersMessage ---
 //
-//export linksocks_PortPool_CTor
-func linksocks_PortPool_CTor() CGoHandle {
-	return CGoHandle(handleFromPtr_linksocks_PortPool(&linksocks.PortPool{}))
+//export linksocks_PartnersMessage_CTor
+func linksocks_PartnersMessage_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_linksocks_PartnersMessage(&linksocks.PartnersMessage{}))
 }
 
-//export linksocks_PortPool_Get
-func linksocks_PortPool_Get(_handle CGoHandle, requestedPort C.longlong) C.longlong {
+//export linksocks_PartnersMessage_Count_Get
+func linksocks_PartnersMessage_Count_Get(handle CGoHandle) C.longlong {
+	op := ptrFromHandle_linksocks_PartnersMessage(handle)
+	return C.longlong(op.Count)
+}
+
+//export linksocks_PartnersMessage_Count_Set
+func linksocks_PartnersMessage_Count_Set(handle CGoHandle, val C.longlong) {
+	op := ptrFromHandle_linksocks_PartnersMessage(handle)
+	op.Count = int(val)
+}
+
+//export linksocks_PartnersMessage_GetType
+func linksocks_PartnersMessage_GetType(_handle CGoHandle) *C.char {
 	_saved_thread := C.PyEval_SaveThread()
 	defer C.PyEval_RestoreThread(_saved_thread)
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.PortPool")
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.PartnersMessage")
 	if __err != nil {
-		return C.longlong(0)
+		return C.CString("")
 	}
-	return C.longlong(gopyh.Embed(vifc, reflect.TypeOf(linksocks.PortPool{})).(*linksocks.PortPool).Get(int(requestedPort)))
+	return C.CString(gopyh.Embed(vifc, reflect.TypeOf(linksocks.PartnersMessage{})).(*linksocks.PartnersMessage).GetType())
 
 }
 
-//export linksocks_PortPool_Put
-func linksocks_PortPool_Put(_handle CGoHandle, port C.longlong, goRun C.char) {
+// --- wrapping struct: linksocks.ConnectMessage ---
+//
+//export linksocks_ConnectMessage_CTor
+func linksocks_ConnectMessage_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_linksocks_ConnectMessage(&linksocks.ConnectMessage{}))
+}
+
+//export linksocks_ConnectMessage_Protocol_Get
+func linksocks_ConnectMessage_Protocol_Get(handle CGoHandle) *C.char {
+	op := ptrFromHandle_linksocks_ConnectMessage(handle)
+	return C.CString(op.Protocol)
+}
+
+//export linksocks_ConnectMessage_Protocol_Set
+func linksocks_ConnectMessage_Protocol_Set(handle CGoHandle, val *C.char) {
+	op := ptrFromHandle_linksocks_ConnectMessage(handle)
+	op.Protocol = C.GoString(val)
+}
+
+//export linksocks_ConnectMessage_Address_Get
+func linksocks_ConnectMessage_Address_Get(handle CGoHandle) *C.char {
+	op := ptrFromHandle_linksocks_ConnectMessage(handle)
+	return C.CString(op.Address)
+}
+
+//export linksocks_ConnectMessage_Address_Set
+func linksocks_ConnectMessage_Address_Set(handle CGoHandle, val *C.char) {
+	op := ptrFromHandle_linksocks_ConnectMessage(handle)
+	op.Address = C.GoString(val)
+}
+
+//export linksocks_ConnectMessage_Port_Get
+func linksocks_ConnectMessage_Port_Get(handle CGoHandle) C.longlong {
+	op := ptrFromHandle_linksocks_ConnectMessage(handle)
+	return C.longlong(op.Port)
+}
+
+//export linksocks_ConnectMessage_Port_Set
+func linksocks_ConnectMessage_Port_Set(handle CGoHandle, val C.longlong) {
+	op := ptrFromHandle_linksocks_ConnectMessage(handle)
+	op.Port = int(val)
+}
+
+//export linksocks_ConnectMessage_ChannelID_Get
+func linksocks_ConnectMessage_ChannelID_Get(handle CGoHandle) CGoHandle {
+	op := ptrFromHandle_linksocks_ConnectMessage(handle)
+	return handleFromPtr_uuid_UUID(&op.ChannelID)
+}
+
+//export linksocks_ConnectMessage_GetType
+func linksocks_ConnectMessage_GetType(_handle CGoHandle) *C.char {
 	_saved_thread := C.PyEval_SaveThread()
 	defer C.PyEval_RestoreThread(_saved_thread)
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.PortPool")
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.ConnectMessage")
 	if __err != nil {
-		return
-	}
-	if boolPyToGo(goRun) {
-		go gopyh.Embed(vifc, reflect.TypeOf(linksocks.PortPool{})).(*linksocks.PortPool).Put(int(port))
-	} else {
-		gopyh.Embed(vifc, reflect.TypeOf(linksocks.PortPool{})).(*linksocks.PortPool).Put(int(port))
+		return C.CString("")
 	}
+	return C.CString(gopyh.Embed(vifc, reflect.TypeOf(linksocks.ConnectMessage{})).(*linksocks.ConnectMessage).GetType())
+
 }
 
 // --- wrapping struct: linksocks.ServerOption ---
@@ -6818,427 +6825,567 @@ func linksocks_ServerOption_WithUpstreamProxy(_handle CGoHandle, proxy *C.char)
 
 }
 
-//export linksocks_ServerOption_WithUpstreamAuth
-func linksocks_ServerOption_WithUpstreamAuth(_handle CGoHandle, username *C.char, password *C.char) CGoHandle {
+//export linksocks_ServerOption_WithUpstreamAuth
+func linksocks_ServerOption_WithUpstreamAuth(_handle CGoHandle, username *C.char, password *C.char) CGoHandle {
+	_saved_thread := C.PyEval_SaveThread()
+	defer C.PyEval_RestoreThread(_saved_thread)
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.ServerOption")
+	if __err != nil {
+		return handleFromPtr_Ptr_linksocks_ServerOption(nil)
+	}
+	return handleFromPtr_Ptr_linksocks_ServerOption(gopyh.Embed(vifc, reflect.TypeOf(linksocks.ServerOption{})).(*linksocks.ServerOption).WithUpstreamAuth(C.GoString(username), C.GoString(password)))
+
+}
+
+// --- wrapping struct: linksocks.CLI ---
+//
+//export linksocks_CLI_CTor
+func linksocks_CLI_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_linksocks_CLI(&linksocks.CLI{}))
+}
+
+//export linksocks_CLI_Execute
+func linksocks_CLI_Execute(_handle CGoHandle) *C.char {
+	_saved_thread := C.PyEval_SaveThread()
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.CLI")
+	if __err != nil {
+		return errorGoToPy(nil)
+	}
+	__err = gopyh.Embed(vifc, reflect.TypeOf(linksocks.CLI{})).(*linksocks.CLI).Execute()
+
+	C.PyEval_RestoreThread(_saved_thread)
+	if __err != nil {
+		estr := C.CString(__err.Error())
+		C.PyErr_SetString(C.PyExc_RuntimeError, estr)
+		return estr
+	}
+	return C.CString("")
+}
+
+// --- wrapping struct: linksocks.LogMessage ---
+//
+//export linksocks_LogMessage_CTor
+func linksocks_LogMessage_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_linksocks_LogMessage(&linksocks.LogMessage{}))
+}
+
+//export linksocks_LogMessage_Level_Get
+func linksocks_LogMessage_Level_Get(handle CGoHandle) *C.char {
+	op := ptrFromHandle_linksocks_LogMessage(handle)
+	return C.CString(op.Level)
+}
+
+//export linksocks_LogMessage_Level_Set
+func linksocks_LogMessage_Level_Set(handle CGoHandle, val *C.char) {
+	op := ptrFromHandle_linksocks_LogMessage(handle)
+	op.Level = C.GoString(val)
+}
+
+//export linksocks_LogMessage_Msg_Get
+func linksocks_LogMessage_Msg_Get(handle CGoHandle) *C.char {
+	op := ptrFromHandle_linksocks_LogMessage(handle)
+	return C.CString(op.Msg)
+}
+
+//export linksocks_LogMessage_Msg_Set
+func linksocks_LogMessage_Msg_Set(handle CGoHandle, val *C.char) {
+	op := ptrFromHandle_linksocks_LogMessage(handle)
+	op.Msg = C.GoString(val)
+}
+
+//export linksocks_LogMessage_GetType
+func linksocks_LogMessage_GetType(_handle CGoHandle) *C.char {
 	_saved_thread := C.PyEval_SaveThread()
 	defer C.PyEval_RestoreThread(_saved_thread)
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.ServerOption")
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.LogMessage")
 	if __err != nil {
-		return handleFromPtr_Ptr_linksocks_ServerOption(nil)
+		return C.CString("")
 	}
-	return handleFromPtr_Ptr_linksocks_ServerOption(gopyh.Embed(vifc, reflect.TypeOf(linksocks.ServerOption{})).(*linksocks.ServerOption).WithUpstreamAuth(C.GoString(username), C.GoString(password)))
+	return C.CString(gopyh.Embed(vifc, reflect.TypeOf(linksocks.LogMessage{})).(*linksocks.LogMessage).GetType())
 
 }
 
-// --- wrapping struct: linksocks.SocketManager ---
+// --- wrapping struct: linksocks.RelayOption ---
 //
-//export linksocks_SocketManager_CTor
-func linksocks_SocketManager_CTor() CGoHandle {
-	return CGoHandle(handleFromPtr_linksocks_SocketManager(&linksocks.SocketManager{}))
+//export linksocks_RelayOption_CTor
+func linksocks_RelayOption_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_linksocks_RelayOption(&linksocks.RelayOption{}))
 }
 
-//export linksocks_SocketManager_GetListener
-func linksocks_SocketManager_GetListener(_handle CGoHandle, port C.longlong) CGoHandle {
-	_saved_thread := C.PyEval_SaveThread()
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.SocketManager")
-	if __err != nil {
-		return handleFromPtr_net_Listener(nil)
-	}
-	cret, __err := gopyh.Embed(vifc, reflect.TypeOf(linksocks.SocketManager{})).(*linksocks.SocketManager).GetListener(int(port))
-
-	C.PyEval_RestoreThread(_saved_thread)
-	if __err != nil {
-		estr := C.CString(__err.Error())
-		C.PyErr_SetString(C.PyExc_RuntimeError, estr)
-		C.free(unsafe.Pointer(estr))
-		return handleFromPtr_net_Listener(nil)
-	}
-	return handleFromPtr_net_Listener(cret)
+//export linksocks_RelayOption_BufferSize_Get
+func linksocks_RelayOption_BufferSize_Get(handle CGoHandle) C.longlong {
+	op := ptrFromHandle_linksocks_RelayOption(handle)
+	return C.longlong(op.BufferSize)
 }
 
-//export linksocks_SocketManager_ReleaseListener
-func linksocks_SocketManager_ReleaseListener(_handle CGoHandle, port C.longlong, goRun C.char) {
-	_saved_thread := C.PyEval_SaveThread()
-	defer C.PyEval_RestoreThread(_saved_thread)
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.SocketManager")
-	if __err != nil {
-		return
-	}
-	if boolPyToGo(goRun) {
-		go gopyh.Embed(vifc, reflect.TypeOf(linksocks.SocketManager{})).(*linksocks.SocketManager).ReleaseListener(int(port))
-	} else {
-		gopyh.Embed(vifc, reflect.TypeOf(linksocks.SocketManager{})).(*linksocks.SocketManager).ReleaseListener(int(port))
-	}
+//export linksocks_RelayOption_BufferSize_Set
+func linksocks_RelayOption_BufferSize_Set(handle CGoHandle, val C.longlong) {
+	op := ptrFromHandle_linksocks_RelayOption(handle)
+	op.BufferSize = int(val)
 }
 
-//export linksocks_SocketManager_Close
-func linksocks_SocketManager_Close(_handle CGoHandle, goRun C.char) {
-	_saved_thread := C.PyEval_SaveThread()
-	defer C.PyEval_RestoreThread(_saved_thread)
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.SocketManager")
-	if __err != nil {
-		return
-	}
-	if boolPyToGo(goRun) {
-		go gopyh.Embed(vifc, reflect.TypeOf(linksocks.SocketManager{})).(*linksocks.SocketManager).Close()
-	} else {
-		gopyh.Embed(vifc, reflect.TypeOf(linksocks.SocketManager{})).(*linksocks.SocketManager).Close()
-	}
+//export linksocks_RelayOption_ChannelTimeout_Get
+func linksocks_RelayOption_ChannelTimeout_Get(handle CGoHandle) C.longlong {
+	op := ptrFromHandle_linksocks_RelayOption(handle)
+	return C.longlong(int64(op.ChannelTimeout))
 }
 
-// --- wrapping struct: linksocks.StatusResponse ---
-//
-//export linksocks_StatusResponse_CTor
-func linksocks_StatusResponse_CTor() CGoHandle {
-	return CGoHandle(handleFromPtr_linksocks_StatusResponse(&linksocks.StatusResponse{}))
+//export linksocks_RelayOption_ChannelTimeout_Set
+func linksocks_RelayOption_ChannelTimeout_Set(handle CGoHandle, val C.longlong) {
+	op := ptrFromHandle_linksocks_RelayOption(handle)
+	op.ChannelTimeout = time.Duration(int64(val))
 }
 
-//export linksocks_StatusResponse_Version_Get
-func linksocks_StatusResponse_Version_Get(handle CGoHandle) *C.char {
-	op := ptrFromHandle_linksocks_StatusResponse(handle)
-	return C.CString(op.Version)
+//export linksocks_RelayOption_ConnectTimeout_Get
+func linksocks_RelayOption_ConnectTimeout_Get(handle CGoHandle) C.longlong {
+	op := ptrFromHandle_linksocks_RelayOption(handle)
+	return C.longlong(int64(op.ConnectTimeout))
 }
 
-//export linksocks_StatusResponse_Version_Set
-func linksocks_StatusResponse_Version_Set(handle CGoHandle, val *C.char) {
-	op := ptrFromHandle_linksocks_StatusResponse(handle)
-	op.Version = C.GoString(val)
+//export linksocks_RelayOption_ConnectTimeout_Set
+func linksocks_RelayOption_ConnectTimeout_Set(handle CGoHandle, val C.longlong) {
+	op := ptrFromHandle_linksocks_RelayOption(handle)
+	op.ConnectTimeout = time.Duration(int64(val))
 }
 
-//export linksocks_StatusResponse_Tokens_Get
-func linksocks_StatusResponse_Tokens_Get(handle CGoHandle) CGoHandle {
-	op := ptrFromHandle_linksocks_StatusResponse(handle)
-	return handleFromPtr_Slice_interface_(&op.Tokens)
+//export linksocks_RelayOption_FastOpen_Get
+func linksocks_RelayOption_FastOpen_Get(handle CGoHandle) C.char {
+	op := ptrFromHandle_linksocks_RelayOption(handle)
+	return boolGoToPy(op.FastOpen)
 }
 
-//export linksocks_StatusResponse_Tokens_Set
-func linksocks_StatusResponse_Tokens_Set(handle CGoHandle, val CGoHandle) {
-	op := ptrFromHandle_linksocks_StatusResponse(handle)
-	op.Tokens = deptrFromHandle_Slice_interface_(val)
+//export linksocks_RelayOption_FastOpen_Set
+func linksocks_RelayOption_FastOpen_Set(handle CGoHandle, val C.char) {
+	op := ptrFromHandle_linksocks_RelayOption(handle)
+	op.FastOpen = boolPyToGo(val)
 }
 
-// --- wrapping struct: linksocks.TokenStatus ---
-//
-//export linksocks_TokenStatus_CTor
-func linksocks_TokenStatus_CTor() CGoHandle {
-	return CGoHandle(handleFromPtr_linksocks_TokenStatus(&linksocks.TokenStatus{}))
+//export linksocks_RelayOption_UpstreamProxy_Get
+func linksocks_RelayOption_UpstreamProxy_Get(handle CGoHandle) *C.char {
+	op := ptrFromHandle_linksocks_RelayOption(handle)
+	return C.CString(op.UpstreamProxy)
 }
 
-//export linksocks_TokenStatus_Token_Get
-func linksocks_TokenStatus_Token_Get(handle CGoHandle) *C.char {
-	op := ptrFromHandle_linksocks_TokenStatus(handle)
-	return C.CString(op.Token)
+//export linksocks_RelayOption_UpstreamProxy_Set
+func linksocks_RelayOption_UpstreamProxy_Set(handle CGoHandle, val *C.char) {
+	op := ptrFromHandle_linksocks_RelayOption(handle)
+	op.UpstreamProxy = C.GoString(val)
 }
 
-//export linksocks_TokenStatus_Token_Set
-func linksocks_TokenStatus_Token_Set(handle CGoHandle, val *C.char) {
-	op := ptrFromHandle_linksocks_TokenStatus(handle)
-	op.Token = C.GoString(val)
+//export linksocks_RelayOption_UpstreamUsername_Get
+func linksocks_RelayOption_UpstreamUsername_Get(handle CGoHandle) *C.char {
+	op := ptrFromHandle_linksocks_RelayOption(handle)
+	return C.CString(op.UpstreamUsername)
 }
 
-//export linksocks_TokenStatus_Type_Get
-func linksocks_TokenStatus_Type_Get(handle CGoHandle) *C.char {
-	op := ptrFromHandle_linksocks_TokenStatus(handle)
-	return C.CString(op.Type)
+//export linksocks_RelayOption_UpstreamUsername_Set
+func linksocks_RelayOption_UpstreamUsername_Set(handle CGoHandle, val *C.char) {
+	op := ptrFromHandle_linksocks_RelayOption(handle)
+	op.UpstreamUsername = C.GoString(val)
 }
 
-//export linksocks_TokenStatus_Type_Set
-func linksocks_TokenStatus_Type_Set(handle CGoHandle, val *C.char) {
-	op := ptrFromHandle_linksocks_TokenStatus(handle)
-	op.Type = C.GoString(val)
+//export linksocks_RelayOption_UpstreamPassword_Get
+func linksocks_RelayOption_UpstreamPassword_Get(handle CGoHandle) *C.char {
+	op := ptrFromHandle_linksocks_RelayOption(handle)
+	return C.CString(op.UpstreamPassword)
 }
 
-//export linksocks_TokenStatus_ClientsCount_Get
-func linksocks_TokenStatus_ClientsCount_Get(handle CGoHandle) C.longlong {
-	op := ptrFromHandle_linksocks_TokenStatus(handle)
-	return C.longlong(op.ClientsCount)
+//export linksocks_RelayOption_UpstreamPassword_Set
+func linksocks_RelayOption_UpstreamPassword_Set(handle CGoHandle, val *C.char) {
+	op := ptrFromHandle_linksocks_RelayOption(handle)
+	op.UpstreamPassword = C.GoString(val)
 }
 
-//export linksocks_TokenStatus_ClientsCount_Set
-func linksocks_TokenStatus_ClientsCount_Set(handle CGoHandle, val C.longlong) {
-	op := ptrFromHandle_linksocks_TokenStatus(handle)
-	op.ClientsCount = int(val)
+//export linksocks_RelayOption_EnableDynamicBatching_Get
+func linksocks_RelayOption_EnableDynamicBatching_Get(handle CGoHandle) C.char {
+	op := ptrFromHandle_linksocks_RelayOption(handle)
+	return boolGoToPy(op.EnableDynamicBatching)
 }
 
-// --- wrapping struct: linksocks.TokenResponse ---
-//
-//export linksocks_TokenResponse_CTor
-func linksocks_TokenResponse_CTor() CGoHandle {
-	return CGoHandle(handleFromPtr_linksocks_TokenResponse(&linksocks.TokenResponse{}))
+//export linksocks_RelayOption_EnableDynamicBatching_Set
+func linksocks_RelayOption_EnableDynamicBatching_Set(handle CGoHandle, val C.char) {
+	op := ptrFromHandle_linksocks_RelayOption(handle)
+	op.EnableDynamicBatching = boolPyToGo(val)
 }
 
-//export linksocks_TokenResponse_Success_Get
-func linksocks_TokenResponse_Success_Get(handle CGoHandle) C.char {
-	op := ptrFromHandle_linksocks_TokenResponse(handle)
-	return boolGoToPy(op.Success)
+//export linksocks_RelayOption_MaxBatchWaitTime_Get
+func linksocks_RelayOption_MaxBatchWaitTime_Get(handle CGoHandle) C.longlong {
+	op := ptrFromHandle_linksocks_RelayOption(handle)
+	return C.longlong(int64(op.MaxBatchWaitTime))
 }
 
-//export linksocks_TokenResponse_Success_Set
-func linksocks_TokenResponse_Success_Set(handle CGoHandle, val C.char) {
-	op := ptrFromHandle_linksocks_TokenResponse(handle)
-	op.Success = boolPyToGo(val)
+//export linksocks_RelayOption_MaxBatchWaitTime_Set
+func linksocks_RelayOption_MaxBatchWaitTime_Set(handle CGoHandle, val C.longlong) {
+	op := ptrFromHandle_linksocks_RelayOption(handle)
+	op.MaxBatchWaitTime = time.Duration(int64(val))
 }
 
-//export linksocks_TokenResponse_Token_Get
-func linksocks_TokenResponse_Token_Get(handle CGoHandle) *C.char {
-	op := ptrFromHandle_linksocks_TokenResponse(handle)
-	return C.CString(op.Token)
+//export linksocks_RelayOption_MinBatchWaitTime_Get
+func linksocks_RelayOption_MinBatchWaitTime_Get(handle CGoHandle) C.longlong {
+	op := ptrFromHandle_linksocks_RelayOption(handle)
+	return C.longlong(int64(op.MinBatchWaitTime))
 }
 
-//export linksocks_TokenResponse_Token_Set
-func linksocks_TokenResponse_Token_Set(handle CGoHandle, val *C.char) {
-	op := ptrFromHandle_linksocks_TokenResponse(handle)
-	op.Token = C.GoString(val)
+//export linksocks_RelayOption_MinBatchWaitTime_Set
+func linksocks_RelayOption_MinBatchWaitTime_Set(handle CGoHandle, val C.longlong) {
+	op := ptrFromHandle_linksocks_RelayOption(handle)
+	op.MinBatchWaitTime = time.Duration(int64(val))
 }
 
-//export linksocks_TokenResponse_Port_Get
-func linksocks_TokenResponse_Port_Get(handle CGoHandle) C.longlong {
-	op := ptrFromHandle_linksocks_TokenResponse(handle)
-	return C.longlong(op.Port)
+//export linksocks_RelayOption_HighSpeedThreshold_Get
+func linksocks_RelayOption_HighSpeedThreshold_Get(handle CGoHandle) C.double {
+	op := ptrFromHandle_linksocks_RelayOption(handle)
+	return C.double(op.HighSpeedThreshold)
 }
 
-//export linksocks_TokenResponse_Port_Set
-func linksocks_TokenResponse_Port_Set(handle CGoHandle, val C.longlong) {
-	op := ptrFromHandle_linksocks_TokenResponse(handle)
-	op.Port = int(val)
+//export linksocks_RelayOption_HighSpeedThreshold_Set
+func linksocks_RelayOption_HighSpeedThreshold_Set(handle CGoHandle, val C.double) {
+	op := ptrFromHandle_linksocks_RelayOption(handle)
+	op.HighSpeedThreshold = float64(val)
 }
 
-//export linksocks_TokenResponse_Error_Get
-func linksocks_TokenResponse_Error_Get(handle CGoHandle) *C.char {
-	op := ptrFromHandle_linksocks_TokenResponse(handle)
-	return C.CString(op.Error)
+//export linksocks_RelayOption_LowSpeedThreshold_Get
+func linksocks_RelayOption_LowSpeedThreshold_Get(handle CGoHandle) C.double {
+	op := ptrFromHandle_linksocks_RelayOption(handle)
+	return C.double(op.LowSpeedThreshold)
 }
 
-//export linksocks_TokenResponse_Error_Set
-func linksocks_TokenResponse_Error_Set(handle CGoHandle, val *C.char) {
-	op := ptrFromHandle_linksocks_TokenResponse(handle)
-	op.Error = C.GoString(val)
+//export linksocks_RelayOption_LowSpeedThreshold_Set
+func linksocks_RelayOption_LowSpeedThreshold_Set(handle CGoHandle, val C.double) {
+	op := ptrFromHandle_linksocks_RelayOption(handle)
+	op.LowSpeedThreshold = float64(val)
 }
 
-// --- wrapping struct: linksocks.ReverseTokenStatus ---
-//
-//export linksocks_ReverseTokenStatus_CTor
-func linksocks_ReverseTokenStatus_CTor() CGoHandle {
-	return CGoHandle(handleFromPtr_linksocks_ReverseTokenStatus(&linksocks.ReverseTokenStatus{}))
+//export linksocks_RelayOption_CompressionThreshold_Get
+func linksocks_RelayOption_CompressionThreshold_Get(handle CGoHandle) C.longlong {
+	op := ptrFromHandle_linksocks_RelayOption(handle)
+	return C.longlong(op.CompressionThreshold)
 }
 
-//export linksocks_ReverseTokenStatus_Port_Get
-func linksocks_ReverseTokenStatus_Port_Get(handle CGoHandle) C.longlong {
-	op := ptrFromHandle_linksocks_ReverseTokenStatus(handle)
-	return C.longlong(op.Port)
+//export linksocks_RelayOption_CompressionThreshold_Set
+func linksocks_RelayOption_CompressionThreshold_Set(handle CGoHandle, val C.longlong) {
+	op := ptrFromHandle_linksocks_RelayOption(handle)
+	op.CompressionThreshold = int(val)
 }
 
-//export linksocks_ReverseTokenStatus_Port_Set
-func linksocks_ReverseTokenStatus_Port_Set(handle CGoHandle, val C.longlong) {
-	op := ptrFromHandle_linksocks_ReverseTokenStatus(handle)
-	op.Port = int(val)
+//export linksocks_RelayOption_WithBufferSize
+func linksocks_RelayOption_WithBufferSize(_handle CGoHandle, size C.longlong) CGoHandle {
+	_saved_thread := C.PyEval_SaveThread()
+	defer C.PyEval_RestoreThread(_saved_thread)
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.RelayOption")
+	if __err != nil {
+		return handleFromPtr_Ptr_linksocks_RelayOption(nil)
+	}
+	return handleFromPtr_Ptr_linksocks_RelayOption(gopyh.Embed(vifc, reflect.TypeOf(linksocks.RelayOption{})).(*linksocks.RelayOption).WithBufferSize(int(size)))
+
 }
 
-//export linksocks_ReverseTokenStatus_ConnectorTokens_Get
-func linksocks_ReverseTokenStatus_ConnectorTokens_Get(handle CGoHandle) CGoHandle {
-	op := ptrFromHandle_linksocks_ReverseTokenStatus(handle)
-	return handleFromPtr_Slice_string(&op.ConnectorTokens)
+//export linksocks_RelayOption_WithChannelTimeout
+func linksocks_RelayOption_WithChannelTimeout(_handle CGoHandle, timeout C.longlong) CGoHandle {
+	_saved_thread := C.PyEval_SaveThread()
+	defer C.PyEval_RestoreThread(_saved_thread)
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.RelayOption")
+	if __err != nil {
+		return handleFromPtr_Ptr_linksocks_RelayOption(nil)
+	}
+	return handleFromPtr_Ptr_linksocks_RelayOption(gopyh.Embed(vifc, reflect.TypeOf(linksocks.RelayOption{})).(*linksocks.RelayOption).WithChannelTimeout(time.Duration(int64(timeout))))
+
 }
 
-//export linksocks_ReverseTokenStatus_ConnectorTokens_Set
-func linksocks_ReverseTokenStatus_ConnectorTokens_Set(handle CGoHandle, val CGoHandle) {
-	op := ptrFromHandle_linksocks_ReverseTokenStatus(handle)
-	op.ConnectorTokens = deptrFromHandle_Slice_string(val)
+//export linksocks_RelayOption_WithConnectTimeout
+func linksocks_RelayOption_WithConnectTimeout(_handle CGoHandle, timeout C.longlong) CGoHandle {
+	_saved_thread := C.PyEval_SaveThread()
+	defer C.PyEval_RestoreThread(_saved_thread)
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.RelayOption")
+	if __err != nil {
+		return handleFromPtr_Ptr_linksocks_RelayOption(nil)
+	}
+	return handleFromPtr_Ptr_linksocks_RelayOption(gopyh.Embed(vifc, reflect.TypeOf(linksocks.RelayOption{})).(*linksocks.RelayOption).WithConnectTimeout(time.Duration(int64(timeout))))
+
 }
 
-// --- wrapping struct: linksocks.WSConn ---
-//
-//export linksocks_WSConn_CTor
-func linksocks_WSConn_CTor() CGoHandle {
-	return CGoHandle(handleFromPtr_linksocks_WSConn(&linksocks.WSConn{}))
+//export linksocks_RelayOption_WithFastOpen
+func linksocks_RelayOption_WithFastOpen(_handle CGoHandle, fastOpen C.char) CGoHandle {
+	_saved_thread := C.PyEval_SaveThread()
+	defer C.PyEval_RestoreThread(_saved_thread)
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.RelayOption")
+	if __err != nil {
+		return handleFromPtr_Ptr_linksocks_RelayOption(nil)
+	}
+	return handleFromPtr_Ptr_linksocks_RelayOption(gopyh.Embed(vifc, reflect.TypeOf(linksocks.RelayOption{})).(*linksocks.RelayOption).WithFastOpen(boolPyToGo(fastOpen)))
+
 }
 
-//export linksocks_WSConn_Label
-func linksocks_WSConn_Label(_handle CGoHandle) *C.char {
+//export linksocks_RelayOption_WithUpstreamProxy
+func linksocks_RelayOption_WithUpstreamProxy(_handle CGoHandle, proxy *C.char) CGoHandle {
 	_saved_thread := C.PyEval_SaveThread()
 	defer C.PyEval_RestoreThread(_saved_thread)
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.WSConn")
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.RelayOption")
 	if __err != nil {
-		return C.CString("")
+		return handleFromPtr_Ptr_linksocks_RelayOption(nil)
 	}
-	return C.CString(gopyh.Embed(vifc, reflect.TypeOf(linksocks.WSConn{})).(*linksocks.WSConn).Label())
+	return handleFromPtr_Ptr_linksocks_RelayOption(gopyh.Embed(vifc, reflect.TypeOf(linksocks.RelayOption{})).(*linksocks.RelayOption).WithUpstreamProxy(C.GoString(proxy)))
 
 }
 
-//export linksocks_WSConn_GetClientIP
-func linksocks_WSConn_GetClientIP(_handle CGoHandle) *C.char {
+//export linksocks_RelayOption_WithUpstreamAuth
+func linksocks_RelayOption_WithUpstreamAuth(_handle CGoHandle, username *C.char, password *C.char) CGoHandle {
 	_saved_thread := C.PyEval_SaveThread()
 	defer C.PyEval_RestoreThread(_saved_thread)
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.WSConn")
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.RelayOption")
 	if __err != nil {
-		return C.CString("")
+		return handleFromPtr_Ptr_linksocks_RelayOption(nil)
 	}
-	return C.CString(gopyh.Embed(vifc, reflect.TypeOf(linksocks.WSConn{})).(*linksocks.WSConn).GetClientIP())
+	return handleFromPtr_Ptr_linksocks_RelayOption(gopyh.Embed(vifc, reflect.TypeOf(linksocks.RelayOption{})).(*linksocks.RelayOption).WithUpstreamAuth(C.GoString(username), C.GoString(password)))
 
 }
 
-//export linksocks_WSConn_SetClientIPFromRequest
-func linksocks_WSConn_SetClientIPFromRequest(_handle CGoHandle, r CGoHandle, goRun C.char) {
+//export linksocks_RelayOption_WithDynamicBatching
+func linksocks_RelayOption_WithDynamicBatching(_handle CGoHandle, enabled C.char) CGoHandle {
 	_saved_thread := C.PyEval_SaveThread()
 	defer C.PyEval_RestoreThread(_saved_thread)
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.WSConn")
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.RelayOption")
 	if __err != nil {
-		return
+		return handleFromPtr_Ptr_linksocks_RelayOption(nil)
 	}
-	if boolPyToGo(goRun) {
-		go gopyh.Embed(vifc, reflect.TypeOf(linksocks.WSConn{})).(*linksocks.WSConn).SetClientIPFromRequest(ptrFromHandle_Ptr_http_Request(r))
-	} else {
-		gopyh.Embed(vifc, reflect.TypeOf(linksocks.WSConn{})).(*linksocks.WSConn).SetClientIPFromRequest(ptrFromHandle_Ptr_http_Request(r))
+	return handleFromPtr_Ptr_linksocks_RelayOption(gopyh.Embed(vifc, reflect.TypeOf(linksocks.RelayOption{})).(*linksocks.RelayOption).WithDynamicBatching(boolPyToGo(enabled)))
+
+}
+
+//export linksocks_RelayOption_WithBatchingTimeLimits
+func linksocks_RelayOption_WithBatchingTimeLimits(_handle CGoHandle, min C.longlong, max C.longlong) CGoHandle {
+	_saved_thread := C.PyEval_SaveThread()
+	defer C.PyEval_RestoreThread(_saved_thread)
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.RelayOption")
+	if __err != nil {
+		return handleFromPtr_Ptr_linksocks_RelayOption(nil)
 	}
+	return handleFromPtr_Ptr_linksocks_RelayOption(gopyh.Embed(vifc, reflect.TypeOf(linksocks.RelayOption{})).(*linksocks.RelayOption).WithBatchingTimeLimits(time.Duration(int64(min)), time.Duration(int64(max))))
+
 }
 
-//export linksocks_WSConn_SyncWriteBinary
-func linksocks_WSConn_SyncWriteBinary(_handle CGoHandle, data CGoHandle) *C.char {
+//export linksocks_RelayOption_WithHighSpeedThreshold
+func linksocks_RelayOption_WithHighSpeedThreshold(_handle CGoHandle, threshold C.double) CGoHandle {
 	_saved_thread := C.PyEval_SaveThread()
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.WSConn")
+	defer C.PyEval_RestoreThread(_saved_thread)
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.RelayOption")
 	if __err != nil {
-		return errorGoToPy(nil)
+		return handleFromPtr_Ptr_linksocks_RelayOption(nil)
 	}
-	__err = gopyh.Embed(vifc, reflect.TypeOf(linksocks.WSConn{})).(*linksocks.WSConn).SyncWriteBinary(deptrFromHandle_Slice_byte(data))
+	return handleFromPtr_Ptr_linksocks_RelayOption(gopyh.Embed(vifc, reflect.TypeOf(linksocks.RelayOption{})).(*linksocks.RelayOption).WithHighSpeedThreshold(float64(threshold)))
 
-	C.PyEval_RestoreThread(_saved_thread)
+}
+
+//export linksocks_RelayOption_WithLowSpeedThreshold
+func linksocks_RelayOption_WithLowSpeedThreshold(_handle CGoHandle, threshold C.double) CGoHandle {
+	_saved_thread := C.PyEval_SaveThread()
+	defer C.PyEval_RestoreThread(_saved_thread)
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.RelayOption")
 	if __err != nil {
-		estr := C.CString(__err.Error())
-		C.PyErr_SetString(C.PyExc_RuntimeError, estr)
-		return estr
+		return handleFromPtr_Ptr_linksocks_RelayOption(nil)
 	}
-	return C.CString("")
+	return handleFromPtr_Ptr_linksocks_RelayOption(gopyh.Embed(vifc, reflect.TypeOf(linksocks.RelayOption{})).(*linksocks.RelayOption).WithLowSpeedThreshold(float64(threshold)))
+
 }
 
-//export linksocks_WSConn_ReadMessage
-func linksocks_WSConn_ReadMessage(_handle CGoHandle) CGoHandle {
+//export linksocks_RelayOption_WithCompressionThreshold
+func linksocks_RelayOption_WithCompressionThreshold(_handle CGoHandle, threshold C.longlong) CGoHandle {
 	_saved_thread := C.PyEval_SaveThread()
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.WSConn")
+	defer C.PyEval_RestoreThread(_saved_thread)
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.RelayOption")
 	if __err != nil {
-		return handleFromPtr_linksocks_BaseMessage(nil)
+		return handleFromPtr_Ptr_linksocks_RelayOption(nil)
 	}
-	cret, __err := gopyh.Embed(vifc, reflect.TypeOf(linksocks.WSConn{})).(*linksocks.WSConn).ReadMessage()
+	return handleFromPtr_Ptr_linksocks_RelayOption(gopyh.Embed(vifc, reflect.TypeOf(linksocks.RelayOption{})).(*linksocks.RelayOption).WithCompressionThreshold(int(threshold)))
 
-	C.PyEval_RestoreThread(_saved_thread)
+}
+
+// --- wrapping struct: linksocks.AuthResponseMessage ---
+//
+//export linksocks_AuthResponseMessage_CTor
+func linksocks_AuthResponseMessage_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_linksocks_AuthResponseMessage(&linksocks.AuthResponseMessage{}))
+}
+
+//export linksocks_AuthResponseMessage_Success_Get
+func linksocks_AuthResponseMessage_Success_Get(handle CGoHandle) C.char {
+	op := ptrFromHandle_linksocks_AuthResponseMessage(handle)
+	return boolGoToPy(op.Success)
+}
+
+//export linksocks_AuthResponseMessage_Success_Set
+func linksocks_AuthResponseMessage_Success_Set(handle CGoHandle, val C.char) {
+	op := ptrFromHandle_linksocks_AuthResponseMessage(handle)
+	op.Success = boolPyToGo(val)
+}
+
+//export linksocks_AuthResponseMessage_Error_Get
+func linksocks_AuthResponseMessage_Error_Get(handle CGoHandle) *C.char {
+	op := ptrFromHandle_linksocks_AuthResponseMessage(handle)
+	return C.CString(op.Error)
+}
+
+//export linksocks_AuthResponseMessage_Error_Set
+func linksocks_AuthResponseMessage_Error_Set(handle CGoHandle, val *C.char) {
+	op := ptrFromHandle_linksocks_AuthResponseMessage(handle)
+	op.Error = C.GoString(val)
+}
+
+//export linksocks_AuthResponseMessage_GetType
+func linksocks_AuthResponseMessage_GetType(_handle CGoHandle) *C.char {
+	_saved_thread := C.PyEval_SaveThread()
+	defer C.PyEval_RestoreThread(_saved_thread)
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.AuthResponseMessage")
 	if __err != nil {
-		estr := C.CString(__err.Error())
-		C.PyErr_SetString(C.PyExc_RuntimeError, estr)
-		C.free(unsafe.Pointer(estr))
-		return handleFromPtr_linksocks_BaseMessage(nil)
+		return C.CString("")
 	}
-	return handleFromPtr_linksocks_BaseMessage(cret)
+	return C.CString(gopyh.Embed(vifc, reflect.TypeOf(linksocks.AuthResponseMessage{})).(*linksocks.AuthResponseMessage).GetType())
+
+}
+
+// --- wrapping struct: linksocks.DataMessage ---
+//
+//export linksocks_DataMessage_CTor
+func linksocks_DataMessage_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_linksocks_DataMessage(&linksocks.DataMessage{}))
+}
+
+//export linksocks_DataMessage_Protocol_Get
+func linksocks_DataMessage_Protocol_Get(handle CGoHandle) *C.char {
+	op := ptrFromHandle_linksocks_DataMessage(handle)
+	return C.CString(op.Protocol)
+}
+
+//export linksocks_DataMessage_Protocol_Set
+func linksocks_DataMessage_Protocol_Set(handle CGoHandle, val *C.char) {
+	op := ptrFromHandle_linksocks_DataMessage(handle)
+	op.Protocol = C.GoString(val)
+}
+
+//export linksocks_DataMessage_ChannelID_Get
+func linksocks_DataMessage_ChannelID_Get(handle CGoHandle) CGoHandle {
+	op := ptrFromHandle_linksocks_DataMessage(handle)
+	return handleFromPtr_uuid_UUID(&op.ChannelID)
+}
+
+//export linksocks_DataMessage_Data_Get
+func linksocks_DataMessage_Data_Get(handle CGoHandle) CGoHandle {
+	op := ptrFromHandle_linksocks_DataMessage(handle)
+	return handleFromPtr_Slice_byte(&op.Data)
+}
+
+//export linksocks_DataMessage_Data_Set
+func linksocks_DataMessage_Data_Set(handle CGoHandle, val CGoHandle) {
+	op := ptrFromHandle_linksocks_DataMessage(handle)
+	op.Data = deptrFromHandle_Slice_byte(val)
+}
+
+//export linksocks_DataMessage_Compression_Get
+func linksocks_DataMessage_Compression_Get(handle CGoHandle) C.char {
+	op := ptrFromHandle_linksocks_DataMessage(handle)
+	return C.char(op.Compression)
+}
+
+//export linksocks_DataMessage_Compression_Set
+func linksocks_DataMessage_Compression_Set(handle CGoHandle, val C.char) {
+	op := ptrFromHandle_linksocks_DataMessage(handle)
+	op.Compression = byte(val)
+}
+
+//export linksocks_DataMessage_Address_Get
+func linksocks_DataMessage_Address_Get(handle CGoHandle) *C.char {
+	op := ptrFromHandle_linksocks_DataMessage(handle)
+	return C.CString(op.Address)
 }
 
-//export linksocks_WSConn_WriteMessage
-func linksocks_WSConn_WriteMessage(_handle CGoHandle, msg CGoHandle) *C.char {
-	_saved_thread := C.PyEval_SaveThread()
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.WSConn")
-	if __err != nil {
-		return errorGoToPy(nil)
-	}
-	__err = gopyh.Embed(vifc, reflect.TypeOf(linksocks.WSConn{})).(*linksocks.WSConn).WriteMessage(ptrFromHandle_linksocks_BaseMessage(msg))
+//export linksocks_DataMessage_Address_Set
+func linksocks_DataMessage_Address_Set(handle CGoHandle, val *C.char) {
+	op := ptrFromHandle_linksocks_DataMessage(handle)
+	op.Address = C.GoString(val)
+}
 
-	C.PyEval_RestoreThread(_saved_thread)
-	if __err != nil {
-		estr := C.CString(__err.Error())
-		C.PyErr_SetString(C.PyExc_RuntimeError, estr)
-		return estr
-	}
-	return C.CString("")
+//export linksocks_DataMessage_Port_Get
+func linksocks_DataMessage_Port_Get(handle CGoHandle) C.longlong {
+	op := ptrFromHandle_linksocks_DataMessage(handle)
+	return C.longlong(op.Port)
 }
 
-//export linksocks_WSConn_SyncWriteControl
-func linksocks_WSConn_SyncWriteControl(_handle CGoHandle, messageType C.longlong, data CGoHandle, deadline CGoHandle) *C.char {
-	_saved_thread := C.PyEval_SaveThread()
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.WSConn")
-	if __err != nil {
-		return errorGoToPy(nil)
-	}
-	__err = gopyh.Embed(vifc, reflect.TypeOf(linksocks.WSConn{})).(*linksocks.WSConn).SyncWriteControl(int(messageType), deptrFromHandle_Slice_byte(data), *ptrFromHandle_time_Time(deadline))
+//export linksocks_DataMessage_Port_Set
+func linksocks_DataMessage_Port_Set(handle CGoHandle, val C.longlong) {
+	op := ptrFromHandle_linksocks_DataMessage(handle)
+	op.Port = int(val)
+}
 
-	C.PyEval_RestoreThread(_saved_thread)
-	if __err != nil {
-		estr := C.CString(__err.Error())
-		C.PyErr_SetString(C.PyExc_RuntimeError, estr)
-		return estr
-	}
-	return C.CString("")
+//export linksocks_DataMessage_TargetAddr_Get
+func linksocks_DataMessage_TargetAddr_Get(handle CGoHandle) *C.char {
+	op := ptrFromHandle_linksocks_DataMessage(handle)
+	return C.CString(op.TargetAddr)
 }
 
-//export linksocks_WSConn_Close
-func linksocks_WSConn_Close(_handle CGoHandle) *C.char {
-	_saved_thread := C.PyEval_SaveThread()
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.WSConn")
-	if __err != nil {
-		return errorGoToPy(nil)
-	}
-	__err = gopyh.Embed(vifc, reflect.TypeOf(linksocks.WSConn{})).(*linksocks.WSConn).Close()
+//export linksocks_DataMessage_TargetAddr_Set
+func linksocks_DataMessage_TargetAddr_Set(handle CGoHandle, val *C.char) {
+	op := ptrFromHandle_linksocks_DataMessage(handle)
+	op.TargetAddr = C.GoString(val)
+}
 
-	C.PyEval_RestoreThread(_saved_thread)
-	if __err != nil {
-		estr := C.CString(__err.Error())
-		C.PyErr_SetString(C.PyExc_RuntimeError, estr)
-		return estr
-	}
-	return C.CString("")
+//export linksocks_DataMessage_TargetPort_Get
+func linksocks_DataMessage_TargetPort_Get(handle CGoHandle) C.longlong {
+	op := ptrFromHandle_linksocks_DataMessage(handle)
+	return C.longlong(op.TargetPort)
 }
 
-// --- wrapping struct: linksocks.CLI ---
-//
-//export linksocks_CLI_CTor
-func linksocks_CLI_CTor() CGoHandle {
-	return CGoHandle(handleFromPtr_linksocks_CLI(&linksocks.CLI{}))
+//export linksocks_DataMessage_TargetPort_Set
+func linksocks_DataMessage_TargetPort_Set(handle CGoHandle, val C.longlong) {
+	op := ptrFromHandle_linksocks_DataMessage(handle)
+	op.TargetPort = int(val)
 }
 
-//export linksocks_CLI_Execute
-func linksocks_CLI_Execute(_handle CGoHandle) *C.char {
+//export linksocks_DataMessage_GetType
+func linksocks_DataMessage_GetType(_handle CGoHandle) *C.char {
 	_saved_thread := C.PyEval_SaveThread()
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.CLI")
+	defer C.PyEval_RestoreThread(_saved_thread)
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.DataMessage")
 	if __err != nil {
-		return errorGoToPy(nil)
+		return C.CString("")
 	}
-	__err = gopyh.Embed(vifc, reflect.TypeOf(linksocks.CLI{})).(*linksocks.CLI).Execute()
+	return C.CString(gopyh.Embed(vifc, reflect.TypeOf(linksocks.DataMessage{})).(*linksocks.DataMessage).GetType())
 
-	C.PyEval_RestoreThread(_saved_thread)
-	if __err != nil {
-		estr := C.CString(__err.Error())
-		C.PyErr_SetString(C.PyExc_RuntimeError, estr)
-		return estr
-	}
-	return C.CString("")
 }
 
-// --- wrapping struct: linksocks.ContextWithCancel ---
+// --- wrapping struct: linksocks.DisconnectMessage ---
 //
-//export linksocks_ContextWithCancel_CTor
-func linksocks_ContextWithCancel_CTor() CGoHandle {
-	return CGoHandle(handleFromPtr_linksocks_ContextWithCancel(&linksocks.ContextWithCancel{}))
+//export linksocks_DisconnectMessage_CTor
+func linksocks_DisconnectMessage_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_linksocks_DisconnectMessage(&linksocks.DisconnectMessage{}))
 }
 
-//export linksocks_ContextWithCancel_Cancel
-func linksocks_ContextWithCancel_Cancel(_handle CGoHandle, goRun C.char) {
-	_saved_thread := C.PyEval_SaveThread()
-	defer C.PyEval_RestoreThread(_saved_thread)
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.ContextWithCancel")
-	if __err != nil {
-		return
-	}
-	if boolPyToGo(goRun) {
-		go gopyh.Embed(vifc, reflect.TypeOf(linksocks.ContextWithCancel{})).(*linksocks.ContextWithCancel).Cancel()
-	} else {
-		gopyh.Embed(vifc, reflect.TypeOf(linksocks.ContextWithCancel{})).(*linksocks.ContextWithCancel).Cancel()
-	}
+//export linksocks_DisconnectMessage_ChannelID_Get
+func linksocks_DisconnectMessage_ChannelID_Get(handle CGoHandle) CGoHandle {
+	op := ptrFromHandle_linksocks_DisconnectMessage(handle)
+	return handleFromPtr_uuid_UUID(&op.ChannelID)
 }
 
-//export linksocks_ContextWithCancel_Context
-func linksocks_ContextWithCancel_Context(_handle CGoHandle) CGoHandle {
+//export linksocks_DisconnectMessage_Error_Get
+func linksocks_DisconnectMessage_Error_Get(handle CGoHandle) *C.char {
+	op := ptrFromHandle_linksocks_DisconnectMessage(handle)
+	return C.CString(op.Error)
+}
+
+//export linksocks_DisconnectMessage_Error_Set
+func linksocks_DisconnectMessage_Error_Set(handle CGoHandle, val *C.char) {
+	op := ptrFromHandle_linksocks_DisconnectMessage(handle)
+	op.Error = C.GoString(val)
+}
+
+//export linksocks_DisconnectMessage_GetType
+func linksocks_DisconnectMessage_GetType(_handle CGoHandle) *C.char {
 	_saved_thread := C.PyEval_SaveThread()
 	defer C.PyEval_RestoreThread(_saved_thread)
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.ContextWithCancel")
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.DisconnectMessage")
 	if __err != nil {
-		return handleFromPtr_context_Context(nil)
+		return C.CString("")
 	}
-	return handleFromPtr_context_Context(gopyh.Embed(vifc, reflect.TypeOf(linksocks.ContextWithCancel{})).(*linksocks.ContextWithCancel).Context())
+	return C.CString(gopyh.Embed(vifc, reflect.TypeOf(linksocks.DisconnectMessage{})).(*linksocks.DisconnectMessage).GetType())
 
 }
 
@@ -7361,712 +7508,565 @@ func linksocks_LinkSocksClient_GetPartnersCount(_handle CGoHandle) C.longlong {
 
 }
 
-// --- wrapping struct: linksocks.RelayOption ---
+// --- wrapping struct: linksocks.ReverseTokenOptions ---
 //
-//export linksocks_RelayOption_CTor
-func linksocks_RelayOption_CTor() CGoHandle {
-	return CGoHandle(handleFromPtr_linksocks_RelayOption(&linksocks.RelayOption{}))
-}
-
-//export linksocks_RelayOption_BufferSize_Get
-func linksocks_RelayOption_BufferSize_Get(handle CGoHandle) C.longlong {
-	op := ptrFromHandle_linksocks_RelayOption(handle)
-	return C.longlong(op.BufferSize)
-}
-
-//export linksocks_RelayOption_BufferSize_Set
-func linksocks_RelayOption_BufferSize_Set(handle CGoHandle, val C.longlong) {
-	op := ptrFromHandle_linksocks_RelayOption(handle)
-	op.BufferSize = int(val)
-}
-
-//export linksocks_RelayOption_ChannelTimeout_Get
-func linksocks_RelayOption_ChannelTimeout_Get(handle CGoHandle) C.longlong {
-	op := ptrFromHandle_linksocks_RelayOption(handle)
-	return C.longlong(int64(op.ChannelTimeout))
-}
-
-//export linksocks_RelayOption_ChannelTimeout_Set
-func linksocks_RelayOption_ChannelTimeout_Set(handle CGoHandle, val C.longlong) {
-	op := ptrFromHandle_linksocks_RelayOption(handle)
-	op.ChannelTimeout = time.Duration(int64(val))
-}
-
-//export linksocks_RelayOption_ConnectTimeout_Get
-func linksocks_RelayOption_ConnectTimeout_Get(handle CGoHandle) C.longlong {
-	op := ptrFromHandle_linksocks_RelayOption(handle)
-	return C.longlong(int64(op.ConnectTimeout))
-}
-
-//export linksocks_RelayOption_ConnectTimeout_Set
-func linksocks_RelayOption_ConnectTimeout_Set(handle CGoHandle, val C.longlong) {
-	op := ptrFromHandle_linksocks_RelayOption(handle)
-	op.ConnectTimeout = time.Duration(int64(val))
-}
-
-//export linksocks_RelayOption_FastOpen_Get
-func linksocks_RelayOption_FastOpen_Get(handle CGoHandle) C.char {
-	op := ptrFromHandle_linksocks_RelayOption(handle)
-	return boolGoToPy(op.FastOpen)
-}
-
-//export linksocks_RelayOption_FastOpen_Set
-func linksocks_RelayOption_FastOpen_Set(handle CGoHandle, val C.char) {
-	op := ptrFromHandle_linksocks_RelayOption(handle)
-	op.FastOpen = boolPyToGo(val)
-}
-
-//export linksocks_RelayOption_UpstreamProxy_Get
-func linksocks_RelayOption_UpstreamProxy_Get(handle CGoHandle) *C.char {
-	op := ptrFromHandle_linksocks_RelayOption(handle)
-	return C.CString(op.UpstreamProxy)
-}
-
-//export linksocks_RelayOption_UpstreamProxy_Set
-func linksocks_RelayOption_UpstreamProxy_Set(handle CGoHandle, val *C.char) {
-	op := ptrFromHandle_linksocks_RelayOption(handle)
-	op.UpstreamProxy = C.GoString(val)
+//export linksocks_ReverseTokenOptions_CTor
+func linksocks_ReverseTokenOptions_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_linksocks_ReverseTokenOptions(&linksocks.ReverseTokenOptions{}))
 }
 
-//export linksocks_RelayOption_UpstreamUsername_Get
-func linksocks_RelayOption_UpstreamUsername_Get(handle CGoHandle) *C.char {
-	op := ptrFromHandle_linksocks_RelayOption(handle)
-	return C.CString(op.UpstreamUsername)
+//export linksocks_ReverseTokenOptions_Token_Get
+func linksocks_ReverseTokenOptions_Token_Get(handle CGoHandle) *C.char {
+	op := ptrFromHandle_linksocks_ReverseTokenOptions(handle)
+	return C.CString(op.Token)
 }
 
-//export linksocks_RelayOption_UpstreamUsername_Set
-func linksocks_RelayOption_UpstreamUsername_Set(handle CGoHandle, val *C.char) {
-	op := ptrFromHandle_linksocks_RelayOption(handle)
-	op.UpstreamUsername = C.GoString(val)
+//export linksocks_ReverseTokenOptions_Token_Set
+func linksocks_ReverseTokenOptions_Token_Set(handle CGoHandle, val *C.char) {
+	op := ptrFromHandle_linksocks_ReverseTokenOptions(handle)
+	op.Token = C.GoString(val)
 }
 
-//export linksocks_RelayOption_UpstreamPassword_Get
-func linksocks_RelayOption_UpstreamPassword_Get(handle CGoHandle) *C.char {
-	op := ptrFromHandle_linksocks_RelayOption(handle)
-	return C.CString(op.UpstreamPassword)
+//export linksocks_ReverseTokenOptions_Port_Get
+func linksocks_ReverseTokenOptions_Port_Get(handle CGoHandle) C.longlong {
+	op := ptrFromHandle_linksocks_ReverseTokenOptions(handle)
+	return C.longlong(op.Port)
 }
 
-//export linksocks_RelayOption_UpstreamPassword_Set
-func linksocks_RelayOption_UpstreamPassword_Set(handle CGoHandle, val *C.char) {
-	op := ptrFromHandle_linksocks_RelayOption(handle)
-	op.UpstreamPassword = C.GoString(val)
+//export linksocks_ReverseTokenOptions_Port_Set
+func linksocks_ReverseTokenOptions_Port_Set(handle CGoHandle, val C.longlong) {
+	op := ptrFromHandle_linksocks_ReverseTokenOptions(handle)
+	op.Port = int(val)
 }
 
-//export linksocks_RelayOption_EnableDynamicBatching_Get
-func linksocks_RelayOption_EnableDynamicBatching_Get(handle CGoHandle) C.char {
-	op := ptrFromHandle_linksocks_RelayOption(handle)
-	return boolGoToPy(op.EnableDynamicBatching)
+//export linksocks_ReverseTokenOptions_Username_Get
+func linksocks_ReverseTokenOptions_Username_Get(handle CGoHandle) *C.char {
+	op := ptrFromHandle_linksocks_ReverseTokenOptions(handle)
+	return C.CString(op.Username)
 }
 
-//export linksocks_RelayOption_EnableDynamicBatching_Set
-func linksocks_RelayOption_EnableDynamicBatching_Set(handle CGoHandle, val C.char) {
-	op := ptrFromHandle_linksocks_RelayOption(handle)
-	op.EnableDynamicBatching = boolPyToGo(val)
+//export linksocks_ReverseTokenOptions_Username_Set
+func linksocks_ReverseTokenOptions_Username_Set(handle CGoHandle, val *C.char) {
+	op := ptrFromHandle_linksocks_ReverseTokenOptions(handle)
+	op.Username = C.GoString(val)
 }
 
-//export linksocks_RelayOption_MaxBatchWaitTime_Get
-func linksocks_RelayOption_MaxBatchWaitTime_Get(handle CGoHandle) C.longlong {
-	op := ptrFromHandle_linksocks_RelayOption(handle)
-	return C.longlong(int64(op.MaxBatchWaitTime))
+//export linksocks_ReverseTokenOptions_Password_Get
+func linksocks_ReverseTokenOptions_Password_Get(handle CGoHandle) *C.char {
+	op := ptrFromHandle_linksocks_ReverseTokenOptions(handle)
+	return C.CString(op.Password)
 }
 
-//export linksocks_RelayOption_MaxBatchWaitTime_Set
-func linksocks_RelayOption_MaxBatchWaitTime_Set(handle CGoHandle, val C.longlong) {
-	op := ptrFromHandle_linksocks_RelayOption(handle)
-	op.MaxBatchWaitTime = time.Duration(int64(val))
+//export linksocks_ReverseTokenOptions_Password_Set
+func linksocks_ReverseTokenOptions_Password_Set(handle CGoHandle, val *C.char) {
+	op := ptrFromHandle_linksocks_ReverseTokenOptions(handle)
+	op.Password = C.GoString(val)
 }
 
-//export linksocks_RelayOption_MinBatchWaitTime_Get
-func linksocks_RelayOption_MinBatchWaitTime_Get(handle CGoHandle) C.longlong {
-	op := ptrFromHandle_linksocks_RelayOption(handle)
-	return C.longlong(int64(op.MinBatchWaitTime))
+//export linksocks_ReverseTokenOptions_AllowManageConnector_Get
+func linksocks_ReverseTokenOptions_AllowManageConnector_Get(handle CGoHandle) C.char {
+	op := ptrFromHandle_linksocks_ReverseTokenOptions(handle)
+	return boolGoToPy(op.AllowManageConnector)
 }
 
-//export linksocks_RelayOption_MinBatchWaitTime_Set
-func linksocks_RelayOption_MinBatchWaitTime_Set(handle CGoHandle, val C.longlong) {
-	op := ptrFromHandle_linksocks_RelayOption(handle)
-	op.MinBatchWaitTime = time.Duration(int64(val))
+//export linksocks_ReverseTokenOptions_AllowManageConnector_Set
+func linksocks_ReverseTokenOptions_AllowManageConnector_Set(handle CGoHandle, val C.char) {
+	op := ptrFromHandle_linksocks_ReverseTokenOptions(handle)
+	op.AllowManageConnector = boolPyToGo(val)
 }
 
-//export linksocks_RelayOption_HighSpeedThreshold_Get
-func linksocks_RelayOption_HighSpeedThreshold_Get(handle CGoHandle) C.double {
-	op := ptrFromHandle_linksocks_RelayOption(handle)
-	return C.double(op.HighSpeedThreshold)
+// --- wrapping struct: linksocks.StatusResponse ---
+//
+//export linksocks_StatusResponse_CTor
+func linksocks_StatusResponse_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_linksocks_StatusResponse(&linksocks.StatusResponse{}))
 }
 
-//export linksocks_RelayOption_HighSpeedThreshold_Set
-func linksocks_RelayOption_HighSpeedThreshold_Set(handle CGoHandle, val C.double) {
-	op := ptrFromHandle_linksocks_RelayOption(handle)
-	op.HighSpeedThreshold = float64(val)
+//export linksocks_StatusResponse_Version_Get
+func linksocks_StatusResponse_Version_Get(handle CGoHandle) *C.char {
+	op := ptrFromHandle_linksocks_StatusResponse(handle)
+	return C.CString(op.Version)
 }
 
-//export linksocks_RelayOption_LowSpeedThreshold_Get
-func linksocks_RelayOption_LowSpeedThreshold_Get(handle CGoHandle) C.double {
-	op := ptrFromHandle_linksocks_RelayOption(handle)
-	return C.double(op.LowSpeedThreshold)
+//export linksocks_StatusResponse_Version_Set
+func linksocks_StatusResponse_Version_Set(handle CGoHandle, val *C.char) {
+	op := ptrFromHandle_linksocks_StatusResponse(handle)
+	op.Version = C.GoString(val)
 }
 
-//export linksocks_RelayOption_LowSpeedThreshold_Set
-func linksocks_RelayOption_LowSpeedThreshold_Set(handle CGoHandle, val C.double) {
-	op := ptrFromHandle_linksocks_RelayOption(handle)
-	op.LowSpeedThreshold = float64(val)
+//export linksocks_StatusResponse_Tokens_Get
+func linksocks_StatusResponse_Tokens_Get(handle CGoHandle) CGoHandle {
+	op := ptrFromHandle_linksocks_StatusResponse(handle)
+	return handleFromPtr_Slice_interface_(&op.Tokens)
 }
 
-//export linksocks_RelayOption_CompressionThreshold_Get
-func linksocks_RelayOption_CompressionThreshold_Get(handle CGoHandle) C.longlong {
-	op := ptrFromHandle_linksocks_RelayOption(handle)
-	return C.longlong(op.CompressionThreshold)
+//export linksocks_StatusResponse_Tokens_Set
+func linksocks_StatusResponse_Tokens_Set(handle CGoHandle, val CGoHandle) {
+	op := ptrFromHandle_linksocks_StatusResponse(handle)
+	op.Tokens = deptrFromHandle_Slice_interface_(val)
 }
 
-//export linksocks_RelayOption_CompressionThreshold_Set
-func linksocks_RelayOption_CompressionThreshold_Set(handle CGoHandle, val C.longlong) {
-	op := ptrFromHandle_linksocks_RelayOption(handle)
-	op.CompressionThreshold = int(val)
+// --- wrapping struct: linksocks.APIHandler ---
+//
+//export linksocks_APIHandler_CTor
+func linksocks_APIHandler_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_linksocks_APIHandler(&linksocks.APIHandler{}))
 }
 
-//export linksocks_RelayOption_WithBufferSize
-func linksocks_RelayOption_WithBufferSize(_handle CGoHandle, size C.longlong) CGoHandle {
+//export linksocks_APIHandler_RegisterHandlers
+func linksocks_APIHandler_RegisterHandlers(_handle CGoHandle, mux CGoHandle, goRun C.char) {
 	_saved_thread := C.PyEval_SaveThread()
 	defer C.PyEval_RestoreThread(_saved_thread)
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.RelayOption")
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.APIHandler")
 	if __err != nil {
-		return handleFromPtr_Ptr_linksocks_RelayOption(nil)
+		return
+	}
+	if boolPyToGo(goRun) {
+		go gopyh.Embed(vifc, reflect.TypeOf(linksocks.APIHandler{})).(*linksocks.APIHandler).RegisterHandlers(ptrFromHandle_Ptr_http_ServeMux(mux))
+	} else {
+		gopyh.Embed(vifc, reflect.TypeOf(linksocks.APIHandler{})).(*linksocks.APIHandler).RegisterHandlers(ptrFromHandle_Ptr_http_ServeMux(mux))
 	}
-	return handleFromPtr_Ptr_linksocks_RelayOption(gopyh.Embed(vifc, reflect.TypeOf(linksocks.RelayOption{})).(*linksocks.RelayOption).WithBufferSize(int(size)))
-
 }
 
-//export linksocks_RelayOption_WithChannelTimeout
-func linksocks_RelayOption_WithChannelTimeout(_handle CGoHandle, timeout C.longlong) CGoHandle {
-	_saved_thread := C.PyEval_SaveThread()
-	defer C.PyEval_RestoreThread(_saved_thread)
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.RelayOption")
-	if __err != nil {
-		return handleFromPtr_Ptr_linksocks_RelayOption(nil)
-	}
-	return handleFromPtr_Ptr_linksocks_RelayOption(gopyh.Embed(vifc, reflect.TypeOf(linksocks.RelayOption{})).(*linksocks.RelayOption).WithChannelTimeout(time.Duration(int64(timeout))))
+// --- wrapping struct: linksocks.AuthMessage ---
+//
+//export linksocks_AuthMessage_CTor
+func linksocks_AuthMessage_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_linksocks_AuthMessage(&linksocks.AuthMessage{}))
+}
 
+//export linksocks_AuthMessage_Token_Get
+func linksocks_AuthMessage_Token_Get(handle CGoHandle) *C.char {
+	op := ptrFromHandle_linksocks_AuthMessage(handle)
+	return C.CString(op.Token)
 }
 
-//export linksocks_RelayOption_WithConnectTimeout
-func linksocks_RelayOption_WithConnectTimeout(_handle CGoHandle, timeout C.longlong) CGoHandle {
-	_saved_thread := C.PyEval_SaveThread()
-	defer C.PyEval_RestoreThread(_saved_thread)
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.RelayOption")
-	if __err != nil {
-		return handleFromPtr_Ptr_linksocks_RelayOption(nil)
-	}
-	return handleFromPtr_Ptr_linksocks_RelayOption(gopyh.Embed(vifc, reflect.TypeOf(linksocks.RelayOption{})).(*linksocks.RelayOption).WithConnectTimeout(time.Duration(int64(timeout))))
+//export linksocks_AuthMessage_Token_Set
+func linksocks_AuthMessage_Token_Set(handle CGoHandle, val *C.char) {
+	op := ptrFromHandle_linksocks_AuthMessage(handle)
+	op.Token = C.GoString(val)
+}
 
+//export linksocks_AuthMessage_Reverse_Get
+func linksocks_AuthMessage_Reverse_Get(handle CGoHandle) C.char {
+	op := ptrFromHandle_linksocks_AuthMessage(handle)
+	return boolGoToPy(op.Reverse)
 }
 
-//export linksocks_RelayOption_WithFastOpen
-func linksocks_RelayOption_WithFastOpen(_handle CGoHandle, fastOpen C.char) CGoHandle {
-	_saved_thread := C.PyEval_SaveThread()
-	defer C.PyEval_RestoreThread(_saved_thread)
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.RelayOption")
-	if __err != nil {
-		return handleFromPtr_Ptr_linksocks_RelayOption(nil)
-	}
-	return handleFromPtr_Ptr_linksocks_RelayOption(gopyh.Embed(vifc, reflect.TypeOf(linksocks.RelayOption{})).(*linksocks.RelayOption).WithFastOpen(boolPyToGo(fastOpen)))
+//export linksocks_AuthMessage_Reverse_Set
+func linksocks_AuthMessage_Reverse_Set(handle CGoHandle, val C.char) {
+	op := ptrFromHandle_linksocks_AuthMessage(handle)
+	op.Reverse = boolPyToGo(val)
+}
 
+//export linksocks_AuthMessage_Instance_Get
+func linksocks_AuthMessage_Instance_Get(handle CGoHandle) CGoHandle {
+	op := ptrFromHandle_linksocks_AuthMessage(handle)
+	return handleFromPtr_uuid_UUID(&op.Instance)
 }
 
-//export linksocks_RelayOption_WithUpstreamProxy
-func linksocks_RelayOption_WithUpstreamProxy(_handle CGoHandle, proxy *C.char) CGoHandle {
+//export linksocks_AuthMessage_GetType
+func linksocks_AuthMessage_GetType(_handle CGoHandle) *C.char {
 	_saved_thread := C.PyEval_SaveThread()
 	defer C.PyEval_RestoreThread(_saved_thread)
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.RelayOption")
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.AuthMessage")
 	if __err != nil {
-		return handleFromPtr_Ptr_linksocks_RelayOption(nil)
+		return C.CString("")
 	}
-	return handleFromPtr_Ptr_linksocks_RelayOption(gopyh.Embed(vifc, reflect.TypeOf(linksocks.RelayOption{})).(*linksocks.RelayOption).WithUpstreamProxy(C.GoString(proxy)))
+	return C.CString(gopyh.Embed(vifc, reflect.TypeOf(linksocks.AuthMessage{})).(*linksocks.AuthMessage).GetType())
 
 }
 
-//export linksocks_RelayOption_WithUpstreamAuth
-func linksocks_RelayOption_WithUpstreamAuth(_handle CGoHandle, username *C.char, password *C.char) CGoHandle {
-	_saved_thread := C.PyEval_SaveThread()
-	defer C.PyEval_RestoreThread(_saved_thread)
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.RelayOption")
-	if __err != nil {
-		return handleFromPtr_Ptr_linksocks_RelayOption(nil)
-	}
-	return handleFromPtr_Ptr_linksocks_RelayOption(gopyh.Embed(vifc, reflect.TypeOf(linksocks.RelayOption{})).(*linksocks.RelayOption).WithUpstreamAuth(C.GoString(username), C.GoString(password)))
-
+// --- wrapping struct: linksocks.PortPool ---
+//
+//export linksocks_PortPool_CTor
+func linksocks_PortPool_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_linksocks_PortPool(&linksocks.PortPool{}))
 }
 
-//export linksocks_RelayOption_WithDynamicBatching
-func linksocks_RelayOption_WithDynamicBatching(_handle CGoHandle, enabled C.char) CGoHandle {
+//export linksocks_PortPool_Get
+func linksocks_PortPool_Get(_handle CGoHandle, requestedPort C.longlong) C.longlong {
 	_saved_thread := C.PyEval_SaveThread()
 	defer C.PyEval_RestoreThread(_saved_thread)
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.RelayOption")
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.PortPool")
 	if __err != nil {
-		return handleFromPtr_Ptr_linksocks_RelayOption(nil)
+		return C.longlong(0)
 	}
-	return handleFromPtr_Ptr_linksocks_RelayOption(gopyh.Embed(vifc, reflect.TypeOf(linksocks.RelayOption{})).(*linksocks.RelayOption).WithDynamicBatching(boolPyToGo(enabled)))
+	return C.longlong(gopyh.Embed(vifc, reflect.TypeOf(linksocks.PortPool{})).(*linksocks.PortPool).Get(int(requestedPort)))
 
 }
 
-//export linksocks_RelayOption_WithBatchingTimeLimits
-func linksocks_RelayOption_WithBatchingTimeLimits(_handle CGoHandle, min C.longlong, max C.longlong) CGoHandle {
+//export linksocks_PortPool_Put
+func linksocks_PortPool_Put(_handle CGoHandle, port C.longlong, goRun C.char) {
 	_saved_thread := C.PyEval_SaveThread()
 	defer C.PyEval_RestoreThread(_saved_thread)
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.RelayOption")
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.PortPool")
 	if __err != nil {
-		return handleFromPtr_Ptr_linksocks_RelayOption(nil)
+		return
 	}
-	return handleFromPtr_Ptr_linksocks_RelayOption(gopyh.Embed(vifc, reflect.TypeOf(linksocks.RelayOption{})).(*linksocks.RelayOption).WithBatchingTimeLimits(time.Duration(int64(min)), time.Duration(int64(max))))
+	if boolPyToGo(goRun) {
+		go gopyh.Embed(vifc, reflect.TypeOf(linksocks.PortPool{})).(*linksocks.PortPool).Put(int(port))
+	} else {
+		gopyh.Embed(vifc, reflect.TypeOf(linksocks.PortPool{})).(*linksocks.PortPool).Put(int(port))
+	}
+}
 
+// --- wrapping struct: linksocks.TokenRequest ---
+//
+//export linksocks_TokenRequest_CTor
+func linksocks_TokenRequest_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_linksocks_TokenRequest(&linksocks.TokenRequest{}))
 }
 
-//export linksocks_RelayOption_WithHighSpeedThreshold
-func linksocks_RelayOption_WithHighSpeedThreshold(_handle CGoHandle, threshold C.double) CGoHandle {
-	_saved_thread := C.PyEval_SaveThread()
-	defer C.PyEval_RestoreThread(_saved_thread)
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.RelayOption")
-	if __err != nil {
-		return handleFromPtr_Ptr_linksocks_RelayOption(nil)
-	}
-	return handleFromPtr_Ptr_linksocks_RelayOption(gopyh.Embed(vifc, reflect.TypeOf(linksocks.RelayOption{})).(*linksocks.RelayOption).WithHighSpeedThreshold(float64(threshold)))
+//export linksocks_TokenRequest_Type_Get
+func linksocks_TokenRequest_Type_Get(handle CGoHandle) *C.char {
+	op := ptrFromHandle_linksocks_TokenRequest(handle)
+	return C.CString(op.Type)
+}
 
+//export linksocks_TokenRequest_Type_Set
+func linksocks_TokenRequest_Type_Set(handle CGoHandle, val *C.char) {
+	op := ptrFromHandle_linksocks_TokenRequest(handle)
+	op.Type = C.GoString(val)
 }
 
-//export linksocks_RelayOption_WithLowSpeedThreshold
-func linksocks_RelayOption_WithLowSpeedThreshold(_handle CGoHandle, threshold C.double) CGoHandle {
-	_saved_thread := C.PyEval_SaveThread()
-	defer C.PyEval_RestoreThread(_saved_thread)
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.RelayOption")
-	if __err != nil {
-		return handleFromPtr_Ptr_linksocks_RelayOption(nil)
-	}
-	return handleFromPtr_Ptr_linksocks_RelayOption(gopyh.Embed(vifc, reflect.TypeOf(linksocks.RelayOption{})).(*linksocks.RelayOption).WithLowSpeedThreshold(float64(threshold)))
+//export linksocks_TokenRequest_Token_Get
+func linksocks_TokenRequest_Token_Get(handle CGoHandle) *C.char {
+	op := ptrFromHandle_linksocks_TokenRequest(handle)
+	return C.CString(op.Token)
+}
 
+//export linksocks_TokenRequest_Token_Set
+func linksocks_TokenRequest_Token_Set(handle CGoHandle, val *C.char) {
+	op := ptrFromHandle_linksocks_TokenRequest(handle)
+	op.Token = C.GoString(val)
+}
+
+//export linksocks_TokenRequest_Port_Get
+func linksocks_TokenRequest_Port_Get(handle CGoHandle) C.longlong {
+	op := ptrFromHandle_linksocks_TokenRequest(handle)
+	return C.longlong(op.Port)
 }
 
-//export linksocks_RelayOption_WithCompressionThreshold
-func linksocks_RelayOption_WithCompressionThreshold(_handle CGoHandle, threshold C.longlong) CGoHandle {
-	_saved_thread := C.PyEval_SaveThread()
-	defer C.PyEval_RestoreThread(_saved_thread)
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.RelayOption")
-	if __err != nil {
-		return handleFromPtr_Ptr_linksocks_RelayOption(nil)
-	}
-	return handleFromPtr_Ptr_linksocks_RelayOption(gopyh.Embed(vifc, reflect.TypeOf(linksocks.RelayOption{})).(*linksocks.RelayOption).WithCompressionThreshold(int(threshold)))
+//export linksocks_TokenRequest_Port_Set
+func linksocks_TokenRequest_Port_Set(handle CGoHandle, val C.longlong) {
+	op := ptrFromHandle_linksocks_TokenRequest(handle)
+	op.Port = int(val)
+}
 
+//export linksocks_TokenRequest_Username_Get
+func linksocks_TokenRequest_Username_Get(handle CGoHandle) *C.char {
+	op := ptrFromHandle_linksocks_TokenRequest(handle)
+	return C.CString(op.Username)
 }
 
-// --- wrapping struct: linksocks.DynamicForwarder ---
-//
-//export linksocks_DynamicForwarder_CTor
-func linksocks_DynamicForwarder_CTor() CGoHandle {
-	return CGoHandle(handleFromPtr_linksocks_DynamicForwarder(&linksocks.DynamicForwarder{}))
+//export linksocks_TokenRequest_Username_Set
+func linksocks_TokenRequest_Username_Set(handle CGoHandle, val *C.char) {
+	op := ptrFromHandle_linksocks_TokenRequest(handle)
+	op.Username = C.GoString(val)
 }
 
-//export linksocks_DynamicForwarder_ProcessReads
-func linksocks_DynamicForwarder_ProcessReads(_handle CGoHandle, conn CGoHandle, goRun C.char) {
-	_saved_thread := C.PyEval_SaveThread()
-	defer C.PyEval_RestoreThread(_saved_thread)
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.DynamicForwarder")
-	if __err != nil {
-		return
-	}
-	if boolPyToGo(goRun) {
-		go gopyh.Embed(vifc, reflect.TypeOf(linksocks.DynamicForwarder{})).(*linksocks.DynamicForwarder).ProcessReads(ptrFromHandle_io_Reader(conn))
-	} else {
-		gopyh.Embed(vifc, reflect.TypeOf(linksocks.DynamicForwarder{})).(*linksocks.DynamicForwarder).ProcessReads(ptrFromHandle_io_Reader(conn))
-	}
+//export linksocks_TokenRequest_Password_Get
+func linksocks_TokenRequest_Password_Get(handle CGoHandle) *C.char {
+	op := ptrFromHandle_linksocks_TokenRequest(handle)
+	return C.CString(op.Password)
 }
 
-//export linksocks_DynamicForwarder_ProcessReadsImmediate
-func linksocks_DynamicForwarder_ProcessReadsImmediate(_handle CGoHandle, conn CGoHandle, goRun C.char) {
-	_saved_thread := C.PyEval_SaveThread()
-	defer C.PyEval_RestoreThread(_saved_thread)
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.DynamicForwarder")
-	if __err != nil {
-		return
-	}
-	if boolPyToGo(goRun) {
-		go gopyh.Embed(vifc, reflect.TypeOf(linksocks.DynamicForwarder{})).(*linksocks.DynamicForwarder).ProcessReadsImmediate(ptrFromHandle_io_Reader(conn))
-	} else {
-		gopyh.Embed(vifc, reflect.TypeOf(linksocks.DynamicForwarder{})).(*linksocks.DynamicForwarder).ProcessReadsImmediate(ptrFromHandle_io_Reader(conn))
-	}
+//export linksocks_TokenRequest_Password_Set
+func linksocks_TokenRequest_Password_Set(handle CGoHandle, val *C.char) {
+	op := ptrFromHandle_linksocks_TokenRequest(handle)
+	op.Password = C.GoString(val)
 }
 
-//export linksocks_DynamicForwarder_ProcessUDPReads
-func linksocks_DynamicForwarder_ProcessUDPReads(_handle CGoHandle, conn CGoHandle, goRun C.char) {
-	_saved_thread := C.PyEval_SaveThread()
-	defer C.PyEval_RestoreThread(_saved_thread)
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.DynamicForwarder")
-	if __err != nil {
-		return
-	}
-	if boolPyToGo(goRun) {
-		go gopyh.Embed(vifc, reflect.TypeOf(linksocks.DynamicForwarder{})).(*linksocks.DynamicForwarder).ProcessUDPReads(ptrFromHandle_Ptr_net_UDPConn(conn))
-	} else {
-		gopyh.Embed(vifc, reflect.TypeOf(linksocks.DynamicForwarder{})).(*linksocks.DynamicForwarder).ProcessUDPReads(ptrFromHandle_Ptr_net_UDPConn(conn))
-	}
+//export linksocks_TokenRequest_ReverseToken_Get
+func linksocks_TokenRequest_ReverseToken_Get(handle CGoHandle) *C.char {
+	op := ptrFromHandle_linksocks_TokenRequest(handle)
+	return C.CString(op.ReverseToken)
 }
 
-// --- wrapping struct: linksocks.LinkSocksServer ---
-//
-//export linksocks_LinkSocksServer_CTor
-func linksocks_LinkSocksServer_CTor() CGoHandle {
-	return CGoHandle(handleFromPtr_linksocks_LinkSocksServer(&linksocks.LinkSocksServer{}))
+//export linksocks_TokenRequest_ReverseToken_Set
+func linksocks_TokenRequest_ReverseToken_Set(handle CGoHandle, val *C.char) {
+	op := ptrFromHandle_linksocks_TokenRequest(handle)
+	op.ReverseToken = C.GoString(val)
 }
 
-//export linksocks_LinkSocksServer_AddReverseToken
-func linksocks_LinkSocksServer_AddReverseToken(_handle CGoHandle, opts CGoHandle) CGoHandle {
-	_saved_thread := C.PyEval_SaveThread()
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.LinkSocksServer")
-	if __err != nil {
-		return handleFromPtr_Ptr_linksocks_ReverseTokenResult(nil)
-	}
-	cret, __err := gopyh.Embed(vifc, reflect.TypeOf(linksocks.LinkSocksServer{})).(*linksocks.LinkSocksServer).AddReverseToken(ptrFromHandle_Ptr_linksocks_ReverseTokenOptions(opts))
+//export linksocks_TokenRequest_AllowManageConnector_Get
+func linksocks_TokenRequest_AllowManageConnector_Get(handle CGoHandle) C.char {
+	op := ptrFromHandle_linksocks_TokenRequest(handle)
+	return boolGoToPy(op.AllowManageConnector)
+}
 
-	C.PyEval_RestoreThread(_saved_thread)
-	if __err != nil {
-		estr := C.CString(__err.Error())
-		C.PyErr_SetString(C.PyExc_RuntimeError, estr)
-		C.free(unsafe.Pointer(estr))
-		return handleFromPtr_Ptr_linksocks_ReverseTokenResult(nil)
-	}
-	return handleFromPtr_Ptr_linksocks_ReverseTokenResult(cret)
+//export linksocks_TokenRequest_AllowManageConnector_Set
+func linksocks_TokenRequest_AllowManageConnector_Set(handle CGoHandle, val C.char) {
+	op := ptrFromHandle_linksocks_TokenRequest(handle)
+	op.AllowManageConnector = boolPyToGo(val)
 }
 
-//export linksocks_LinkSocksServer_AddForwardToken
-func linksocks_LinkSocksServer_AddForwardToken(_handle CGoHandle, token *C.char) *C.char {
-	_saved_thread := C.PyEval_SaveThread()
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.LinkSocksServer")
-	if __err != nil {
-		return C.CString("")
-	}
-	cret, __err := gopyh.Embed(vifc, reflect.TypeOf(linksocks.LinkSocksServer{})).(*linksocks.LinkSocksServer).AddForwardToken(C.GoString(token))
+// --- wrapping struct: linksocks.TokenResponse ---
+//
+//export linksocks_TokenResponse_CTor
+func linksocks_TokenResponse_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_linksocks_TokenResponse(&linksocks.TokenResponse{}))
+}
 
-	C.PyEval_RestoreThread(_saved_thread)
-	if __err != nil {
-		estr := C.CString(__err.Error())
-		C.PyErr_SetString(C.PyExc_RuntimeError, estr)
-		C.free(unsafe.Pointer(estr))
-		return C.CString("")
-	}
-	return C.CString(cret)
+//export linksocks_TokenResponse_Success_Get
+func linksocks_TokenResponse_Success_Get(handle CGoHandle) C.char {
+	op := ptrFromHandle_linksocks_TokenResponse(handle)
+	return boolGoToPy(op.Success)
 }
 
-//export linksocks_LinkSocksServer_AddConnectorToken
-func linksocks_LinkSocksServer_AddConnectorToken(_handle CGoHandle, connectorToken *C.char, reverseToken *C.char) *C.char {
-	_saved_thread := C.PyEval_SaveThread()
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.LinkSocksServer")
-	if __err != nil {
-		return C.CString("")
-	}
-	cret, __err := gopyh.Embed(vifc, reflect.TypeOf(linksocks.LinkSocksServer{})).(*linksocks.LinkSocksServer).AddConnectorToken(C.GoString(connectorToken), C.GoString(reverseToken))
+//export linksocks_TokenResponse_Success_Set
+func linksocks_TokenResponse_Success_Set(handle CGoHandle, val C.char) {
+	op := ptrFromHandle_linksocks_TokenResponse(handle)
+	op.Success = boolPyToGo(val)
+}
 
-	C.PyEval_RestoreThread(_saved_thread)
-	if __err != nil {
-		estr := C.CString(__err.Error())
-		C.PyErr_SetString(C.PyExc_RuntimeError, estr)
-		C.free(unsafe.Pointer(estr))
-		return C.CString("")
-	}
-	return C.CString(cret)
+//export linksocks_TokenResponse_Token_Get
+func linksocks_TokenResponse_Token_Get(handle CGoHandle) *C.char {
+	op := ptrFromHandle_linksocks_TokenResponse(handle)
+	return C.CString(op.Token)
 }
 
-//export linksocks_LinkSocksServer_RemoveToken
-func linksocks_LinkSocksServer_RemoveToken(_handle CGoHandle, token *C.char) C.char {
-	_saved_thread := C.PyEval_SaveThread()
-	defer C.PyEval_RestoreThread(_saved_thread)
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.LinkSocksServer")
-	if __err != nil {
-		return boolGoToPy(false)
-	}
-	return boolGoToPy(gopyh.Embed(vifc, reflect.TypeOf(linksocks.LinkSocksServer{})).(*linksocks.LinkSocksServer).RemoveToken(C.GoString(token)))
+//export linksocks_TokenResponse_Token_Set
+func linksocks_TokenResponse_Token_Set(handle CGoHandle, val *C.char) {
+	op := ptrFromHandle_linksocks_TokenResponse(handle)
+	op.Token = C.GoString(val)
+}
 
+//export linksocks_TokenResponse_Port_Get
+func linksocks_TokenResponse_Port_Get(handle CGoHandle) C.longlong {
+	op := ptrFromHandle_linksocks_TokenResponse(handle)
+	return C.longlong(op.Port)
 }
 
-//export linksocks_LinkSocksServer_Serve
-func linksocks_LinkSocksServer_Serve(_handle CGoHandle, ctx CGoHandle) *C.char {
-	_saved_thread := C.PyEval_SaveThread()
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.LinkSocksServer")
-	if __err != nil {
-		return errorGoToPy(nil)
-	}
-	__err = gopyh.Embed(vifc, reflect.TypeOf(linksocks.LinkSocksServer{})).(*linksocks.LinkSocksServer).Serve(ptrFromHandle_context_Context(ctx))
+//export linksocks_TokenResponse_Port_Set
+func linksocks_TokenResponse_Port_Set(handle CGoHandle, val C.longlong) {
+	op := ptrFromHandle_linksocks_TokenResponse(handle)
+	op.Port = int(val)
+}
 
-	C.PyEval_RestoreThread(_saved_thread)
-	if __err != nil {
-		estr := C.CString(__err.Error())
-		C.PyErr_SetString(C.PyExc_RuntimeError, estr)
-		return estr
-	}
-	return C.CString("")
+//export linksocks_TokenResponse_Error_Get
+func linksocks_TokenResponse_Error_Get(handle CGoHandle) *C.char {
+	op := ptrFromHandle_linksocks_TokenResponse(handle)
+	return C.CString(op.Error)
 }
 
-//export linksocks_LinkSocksServer_WaitReady
-func linksocks_LinkSocksServer_WaitReady(_handle CGoHandle, ctx CGoHandle, timeout C.longlong) *C.char {
-	_saved_thread := C.PyEval_SaveThread()
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.LinkSocksServer")
-	if __err != nil {
-		return errorGoToPy(nil)
-	}
-	__err = gopyh.Embed(vifc, reflect.TypeOf(linksocks.LinkSocksServer{})).(*linksocks.LinkSocksServer).WaitReady(ptrFromHandle_context_Context(ctx), time.Duration(int64(timeout)))
+//export linksocks_TokenResponse_Error_Set
+func linksocks_TokenResponse_Error_Set(handle CGoHandle, val *C.char) {
+	op := ptrFromHandle_linksocks_TokenResponse(handle)
+	op.Error = C.GoString(val)
+}
 
-	C.PyEval_RestoreThread(_saved_thread)
-	if __err != nil {
-		estr := C.CString(__err.Error())
-		C.PyErr_SetString(C.PyExc_RuntimeError, estr)
-		return estr
-	}
-	return C.CString("")
+// --- wrapping struct: linksocks.DynamicForwarder ---
+//
+//export linksocks_DynamicForwarder_CTor
+func linksocks_DynamicForwarder_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_linksocks_DynamicForwarder(&linksocks.DynamicForwarder{}))
 }
 
-//export linksocks_LinkSocksServer_Close
-func linksocks_LinkSocksServer_Close(_handle CGoHandle, goRun C.char) {
+//export linksocks_DynamicForwarder_ProcessReads
+func linksocks_DynamicForwarder_ProcessReads(_handle CGoHandle, conn CGoHandle, goRun C.char) {
 	_saved_thread := C.PyEval_SaveThread()
 	defer C.PyEval_RestoreThread(_saved_thread)
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.LinkSocksServer")
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.DynamicForwarder")
 	if __err != nil {
 		return
 	}
 	if boolPyToGo(goRun) {
-		go gopyh.Embed(vifc, reflect.TypeOf(linksocks.LinkSocksServer{})).(*linksocks.LinkSocksServer).Close()
+		go gopyh.Embed(vifc, reflect.TypeOf(linksocks.DynamicForwarder{})).(*linksocks.DynamicForwarder).ProcessReads(ptrFromHandle_io_Reader(conn))
 	} else {
-		gopyh.Embed(vifc, reflect.TypeOf(linksocks.LinkSocksServer{})).(*linksocks.LinkSocksServer).Close()
-	}
-}
-
-//export linksocks_LinkSocksServer_GetClientCount
-func linksocks_LinkSocksServer_GetClientCount(_handle CGoHandle) C.longlong {
-	_saved_thread := C.PyEval_SaveThread()
-	defer C.PyEval_RestoreThread(_saved_thread)
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.LinkSocksServer")
-	if __err != nil {
-		return C.longlong(0)
+		gopyh.Embed(vifc, reflect.TypeOf(linksocks.DynamicForwarder{})).(*linksocks.DynamicForwarder).ProcessReads(ptrFromHandle_io_Reader(conn))
 	}
-	return C.longlong(gopyh.Embed(vifc, reflect.TypeOf(linksocks.LinkSocksServer{})).(*linksocks.LinkSocksServer).GetClientCount())
-
 }
 
-//export linksocks_LinkSocksServer_HasClients
-func linksocks_LinkSocksServer_HasClients(_handle CGoHandle) C.char {
+//export linksocks_DynamicForwarder_ProcessReadsImmediate
+func linksocks_DynamicForwarder_ProcessReadsImmediate(_handle CGoHandle, conn CGoHandle, goRun C.char) {
 	_saved_thread := C.PyEval_SaveThread()
 	defer C.PyEval_RestoreThread(_saved_thread)
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.LinkSocksServer")
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.DynamicForwarder")
 	if __err != nil {
-		return boolGoToPy(false)
+		return
+	}
+	if boolPyToGo(goRun) {
+		go gopyh.Embed(vifc, reflect.TypeOf(linksocks.DynamicForwarder{})).(*linksocks.DynamicForwarder).ProcessReadsImmediate(ptrFromHandle_io_Reader(conn))
+	} else {
+		gopyh.Embed(vifc, reflect.TypeOf(linksocks.DynamicForwarder{})).(*linksocks.DynamicForwarder).ProcessReadsImmediate(ptrFromHandle_io_Reader(conn))
 	}
-	return boolGoToPy(gopyh.Embed(vifc, reflect.TypeOf(linksocks.LinkSocksServer{})).(*linksocks.LinkSocksServer).HasClients())
-
 }
 
-//export linksocks_LinkSocksServer_GetTokenClientCount
-func linksocks_LinkSocksServer_GetTokenClientCount(_handle CGoHandle, token *C.char) C.longlong {
+//export linksocks_DynamicForwarder_ProcessUDPReads
+func linksocks_DynamicForwarder_ProcessUDPReads(_handle CGoHandle, conn CGoHandle, goRun C.char) {
 	_saved_thread := C.PyEval_SaveThread()
 	defer C.PyEval_RestoreThread(_saved_thread)
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.LinkSocksServer")
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.DynamicForwarder")
 	if __err != nil {
-		return C.longlong(0)
+		return
+	}
+	if boolPyToGo(goRun) {
+		go gopyh.Embed(vifc, reflect.TypeOf(linksocks.DynamicForwarder{})).(*linksocks.DynamicForwarder).ProcessUDPReads(ptrFromHandle_Ptr_net_UDPConn(conn))
+	} else {
+		gopyh.Embed(vifc, reflect.TypeOf(linksocks.DynamicForwarder{})).(*linksocks.DynamicForwarder).ProcessUDPReads(ptrFromHandle_Ptr_net_UDPConn(conn))
 	}
-	return C.longlong(gopyh.Embed(vifc, reflect.TypeOf(linksocks.LinkSocksServer{})).(*linksocks.LinkSocksServer).GetTokenClientCount(C.GoString(token)))
-
 }
 
-// --- wrapping struct: linksocks.Relay ---
+// --- wrapping struct: linksocks.LogEntry ---
 //
-//export linksocks_Relay_CTor
-func linksocks_Relay_CTor() CGoHandle {
-	return CGoHandle(handleFromPtr_linksocks_Relay(&linksocks.Relay{}))
+//export linksocks_LogEntry_CTor
+func linksocks_LogEntry_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_linksocks_LogEntry(&linksocks.LogEntry{}))
 }
 
-//export linksocks_Relay_RefuseSocksRequest
-func linksocks_Relay_RefuseSocksRequest(_handle CGoHandle, conn CGoHandle, reason C.char) *C.char {
-	_saved_thread := C.PyEval_SaveThread()
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.Relay")
-	if __err != nil {
-		return errorGoToPy(nil)
-	}
-	__err = gopyh.Embed(vifc, reflect.TypeOf(linksocks.Relay{})).(*linksocks.Relay).RefuseSocksRequest(ptrFromHandle_net_Conn(conn), byte(reason))
+//export linksocks_LogEntry_LoggerID_Get
+func linksocks_LogEntry_LoggerID_Get(handle CGoHandle) *C.char {
+	op := ptrFromHandle_linksocks_LogEntry(handle)
+	return C.CString(op.LoggerID)
+}
 
-	C.PyEval_RestoreThread(_saved_thread)
-	if __err != nil {
-		estr := C.CString(__err.Error())
-		C.PyErr_SetString(C.PyExc_RuntimeError, estr)
-		return estr
-	}
-	return C.CString("")
+//export linksocks_LogEntry_LoggerID_Set
+func linksocks_LogEntry_LoggerID_Set(handle CGoHandle, val *C.char) {
+	op := ptrFromHandle_linksocks_LogEntry(handle)
+	op.LoggerID = C.GoString(val)
 }
 
-//export linksocks_Relay_HandleNetworkConnection
-func linksocks_Relay_HandleNetworkConnection(_handle CGoHandle, ctx CGoHandle, ws CGoHandle, request CGoHandle) *C.char {
-	_saved_thread := C.PyEval_SaveThread()
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.Relay")
-	if __err != nil {
-		return errorGoToPy(nil)
-	}
-	__err = gopyh.Embed(vifc, reflect.TypeOf(linksocks.Relay{})).(*linksocks.Relay).HandleNetworkConnection(ptrFromHandle_context_Context(ctx), ptrFromHandle_Ptr_linksocks_WSConn(ws), *ptrFromHandle_linksocks_ConnectMessage(request))
+//export linksocks_LogEntry_Message_Get
+func linksocks_LogEntry_Message_Get(handle CGoHandle) *C.char {
+	op := ptrFromHandle_linksocks_LogEntry(handle)
+	return C.CString(op.Message)
+}
 
-	C.PyEval_RestoreThread(_saved_thread)
-	if __err != nil {
-		estr := C.CString(__err.Error())
-		C.PyErr_SetString(C.PyExc_RuntimeError, estr)
-		return estr
-	}
-	return C.CString("")
+//export linksocks_LogEntry_Message_Set
+func linksocks_LogEntry_Message_Set(handle CGoHandle, val *C.char) {
+	op := ptrFromHandle_linksocks_LogEntry(handle)
+	op.Message = C.GoString(val)
 }
 
-//export linksocks_Relay_HandleTCPConnection
-func linksocks_Relay_HandleTCPConnection(_handle CGoHandle, ctx CGoHandle, ws CGoHandle, request CGoHandle) *C.char {
-	_saved_thread := C.PyEval_SaveThread()
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.Relay")
-	if __err != nil {
-		return errorGoToPy(nil)
-	}
-	__err = gopyh.Embed(vifc, reflect.TypeOf(linksocks.Relay{})).(*linksocks.Relay).HandleTCPConnection(ptrFromHandle_context_Context(ctx), ptrFromHandle_Ptr_linksocks_WSConn(ws), *ptrFromHandle_linksocks_ConnectMessage(request))
+//export linksocks_LogEntry_Time_Get
+func linksocks_LogEntry_Time_Get(handle CGoHandle) C.longlong {
+	op := ptrFromHandle_linksocks_LogEntry(handle)
+	return C.longlong(op.Time)
+}
 
-	C.PyEval_RestoreThread(_saved_thread)
-	if __err != nil {
-		estr := C.CString(__err.Error())
-		C.PyErr_SetString(C.PyExc_RuntimeError, estr)
-		return estr
-	}
-	return C.CString("")
+//export linksocks_LogEntry_Time_Set
+func linksocks_LogEntry_Time_Set(handle CGoHandle, val C.longlong) {
+	op := ptrFromHandle_linksocks_LogEntry(handle)
+	op.Time = int64(val)
 }
 
-//export linksocks_Relay_HandleUDPConnection
-func linksocks_Relay_HandleUDPConnection(_handle CGoHandle, ctx CGoHandle, ws CGoHandle, request CGoHandle) *C.char {
-	_saved_thread := C.PyEval_SaveThread()
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.Relay")
-	if __err != nil {
-		return errorGoToPy(nil)
-	}
-	__err = gopyh.Embed(vifc, reflect.TypeOf(linksocks.Relay{})).(*linksocks.Relay).HandleUDPConnection(ptrFromHandle_context_Context(ctx), ptrFromHandle_Ptr_linksocks_WSConn(ws), *ptrFromHandle_linksocks_ConnectMessage(request))
+// --- wrapping struct: linksocks.ReverseTokenResult ---
+//
+//export linksocks_ReverseTokenResult_CTor
+func linksocks_ReverseTokenResult_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_linksocks_ReverseTokenResult(&linksocks.ReverseTokenResult{}))
+}
 
-	C.PyEval_RestoreThread(_saved_thread)
-	if __err != nil {
-		estr := C.CString(__err.Error())
-		C.PyErr_SetString(C.PyExc_RuntimeError, estr)
-		return estr
-	}
-	return C.CString("")
+//export linksocks_ReverseTokenResult_Token_Get
+func linksocks_ReverseTokenResult_Token_Get(handle CGoHandle) *C.char {
+	op := ptrFromHandle_linksocks_ReverseTokenResult(handle)
+	return C.CString(op.Token)
 }
 
-//export linksocks_Relay_HandleSocksRequest
-func linksocks_Relay_HandleSocksRequest(_handle CGoHandle, ctx CGoHandle, ws CGoHandle, socksConn CGoHandle, socksUsername *C.char, socksPassword *C.char) *C.char {
-	_saved_thread := C.PyEval_SaveThread()
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.Relay")
-	if __err != nil {
-		return errorGoToPy(nil)
-	}
-	__err = gopyh.Embed(vifc, reflect.TypeOf(linksocks.Relay{})).(*linksocks.Relay).HandleSocksRequest(ptrFromHandle_context_Context(ctx), ptrFromHandle_Ptr_linksocks_WSConn(ws), ptrFromHandle_net_Conn(socksConn), C.GoString(socksUsername), C.GoString(socksPassword))
+//export linksocks_ReverseTokenResult_Token_Set
+func linksocks_ReverseTokenResult_Token_Set(handle CGoHandle, val *C.char) {
+	op := ptrFromHandle_linksocks_ReverseTokenResult(handle)
+	op.Token = C.GoString(val)
+}
 
-	C.PyEval_RestoreThread(_saved_thread)
-	if __err != nil {
-		estr := C.CString(__err.Error())
-		C.PyErr_SetString(C.PyExc_RuntimeError, estr)
-		return estr
-	}
-	return C.CString("")
+//export linksocks_ReverseTokenResult_Port_Get
+func linksocks_ReverseTokenResult_Port_Get(handle CGoHandle) C.longlong {
+	op := ptrFromHandle_linksocks_ReverseTokenResult(handle)
+	return C.longlong(op.Port)
 }
 
-//export linksocks_Relay_HandleRemoteTCPForward
-func linksocks_Relay_HandleRemoteTCPForward(_handle CGoHandle, ctx CGoHandle, ws CGoHandle, remoteConn CGoHandle, channelID CGoHandle) *C.char {
-	_saved_thread := C.PyEval_SaveThread()
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.Relay")
-	if __err != nil {
-		return errorGoToPy(nil)
-	}
-	__err = gopyh.Embed(vifc, reflect.TypeOf(linksocks.Relay{})).(*linksocks.Relay).HandleRemoteTCPForward(ptrFromHandle_context_Context(ctx), ptrFromHandle_Ptr_linksocks_WSConn(ws), ptrFromHandle_net_Conn(remoteConn), deptrFromHandle_uuid_UUID(channelID))
+//export linksocks_ReverseTokenResult_Port_Set
+func linksocks_ReverseTokenResult_Port_Set(handle CGoHandle, val C.longlong) {
+	op := ptrFromHandle_linksocks_ReverseTokenResult(handle)
+	op.Port = int(val)
+}
 
-	C.PyEval_RestoreThread(_saved_thread)
-	if __err != nil {
-		estr := C.CString(__err.Error())
-		C.PyErr_SetString(C.PyExc_RuntimeError, estr)
-		return estr
-	}
-	return C.CString("")
+// --- wrapping struct: linksocks.ReverseTokenStatus ---
+//
+//export linksocks_ReverseTokenStatus_CTor
+func linksocks_ReverseTokenStatus_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_linksocks_ReverseTokenStatus(&linksocks.ReverseTokenStatus{}))
 }
 
-//export linksocks_Relay_HandleRemoteUDPForward
-func linksocks_Relay_HandleRemoteUDPForward(_handle CGoHandle, ctx CGoHandle, ws CGoHandle, udpConn CGoHandle, channelID CGoHandle) *C.char {
-	_saved_thread := C.PyEval_SaveThread()
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.Relay")
-	if __err != nil {
-		return errorGoToPy(nil)
-	}
-	__err = gopyh.Embed(vifc, reflect.TypeOf(linksocks.Relay{})).(*linksocks.Relay).HandleRemoteUDPForward(ptrFromHandle_context_Context(ctx), ptrFromHandle_Ptr_linksocks_WSConn(ws), ptrFromHandle_Ptr_net_UDPConn(udpConn), deptrFromHandle_uuid_UUID(channelID))
+//export linksocks_ReverseTokenStatus_Port_Get
+func linksocks_ReverseTokenStatus_Port_Get(handle CGoHandle) C.longlong {
+	op := ptrFromHandle_linksocks_ReverseTokenStatus(handle)
+	return C.longlong(op.Port)
+}
 
-	C.PyEval_RestoreThread(_saved_thread)
-	if __err != nil {
-		estr := C.CString(__err.Error())
-		C.PyErr_SetString(C.PyExc_RuntimeError, estr)
-		return estr
-	}
-	return C.CString("")
+//export linksocks_ReverseTokenStatus_Port_Set
+func linksocks_ReverseTokenStatus_Port_Set(handle CGoHandle, val C.longlong) {
+	op := ptrFromHandle_linksocks_ReverseTokenStatus(handle)
+	op.Port = int(val)
 }
 
-//export linksocks_Relay_HandleSocksTCPForward
-func linksocks_Relay_HandleSocksTCPForward(_handle CGoHandle, ctx CGoHandle, ws CGoHandle, socksConn CGoHandle, channelID CGoHandle) *C.char {
-	_saved_thread := C.PyEval_SaveThread()
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.Relay")
-	if __err != nil {
-		return errorGoToPy(nil)
-	}
-	__err = gopyh.Embed(vifc, reflect.TypeOf(linksocks.Relay{})).(*linksocks.Relay).HandleSocksTCPForward(ptrFromHandle_context_Context(ctx), ptrFromHandle_Ptr_linksocks_WSConn(ws), ptrFromHandle_net_Conn(socksConn), deptrFromHandle_uuid_UUID(channelID))
+//export linksocks_ReverseTokenStatus_ConnectorTokens_Get
+func linksocks_ReverseTokenStatus_ConnectorTokens_Get(handle CGoHandle) CGoHandle {
+	op := ptrFromHandle_linksocks_ReverseTokenStatus(handle)
+	return handleFromPtr_Slice_string(&op.ConnectorTokens)
+}
 
-	C.PyEval_RestoreThread(_saved_thread)
-	if __err != nil {
-		estr := C.CString(__err.Error())
-		C.PyErr_SetString(C.PyExc_RuntimeError, estr)
-		return estr
-	}
-	return C.CString("")
+//export linksocks_ReverseTokenStatus_ConnectorTokens_Set
+func linksocks_ReverseTokenStatus_ConnectorTokens_Set(handle CGoHandle, val CGoHandle) {
+	op := ptrFromHandle_linksocks_ReverseTokenStatus(handle)
+	op.ConnectorTokens = deptrFromHandle_Slice_string(val)
 }
 
-//export linksocks_Relay_HandleSocksUDPForward
-func linksocks_Relay_HandleSocksUDPForward(_handle CGoHandle, ctx CGoHandle, ws CGoHandle, udpConn CGoHandle, socksConn CGoHandle, channelID CGoHandle) *C.char {
+// --- wrapping struct: linksocks.SocketManager ---
+//
+//export linksocks_SocketManager_CTor
+func linksocks_SocketManager_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_linksocks_SocketManager(&linksocks.SocketManager{}))
+}
+
+//export linksocks_SocketManager_GetListener
+func linksocks_SocketManager_GetListener(_handle CGoHandle, port C.longlong) CGoHandle {
 	_saved_thread := C.PyEval_SaveThread()
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.Relay")
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.SocketManager")
 	if __err != nil {
-		return errorGoToPy(nil)
+		return handleFromPtr_net_Listener(nil)
 	}
-	__err = gopyh.Embed(vifc, reflect.TypeOf(linksocks.Relay{})).(*linksocks.Relay).HandleSocksUDPForward(ptrFromHandle_context_Context(ctx), ptrFromHandle_Ptr_linksocks_WSConn(ws), ptrFromHandle_Ptr_net_UDPConn(udpConn), ptrFromHandle_net_Conn(socksConn), deptrFromHandle_uuid_UUID(channelID))
+	cret, __err := gopyh.Embed(vifc, reflect.TypeOf(linksocks.SocketManager{})).(*linksocks.SocketManager).GetListener(int(port))
 
 	C.PyEval_RestoreThread(_saved_thread)
 	if __err != nil {
 		estr := C.CString(__err.Error())
 		C.PyErr_SetString(C.PyExc_RuntimeError, estr)
-		return estr
+		C.free(unsafe.Pointer(estr))
+		return handleFromPtr_net_Listener(nil)
 	}
-	return C.CString("")
+	return handleFromPtr_net_Listener(cret)
 }
 
-//export linksocks_Relay_Close
-func linksocks_Relay_Close(_handle CGoHandle, goRun C.char) {
+//export linksocks_SocketManager_ReleaseListener
+func linksocks_SocketManager_ReleaseListener(_handle CGoHandle, port C.longlong, goRun C.char) {
 	_saved_thread := C.PyEval_SaveThread()
 	defer C.PyEval_RestoreThread(_saved_thread)
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.Relay")
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.SocketManager")
 	if __err != nil {
 		return
 	}
 	if boolPyToGo(goRun) {
-		go gopyh.Embed(vifc, reflect.TypeOf(linksocks.Relay{})).(*linksocks.Relay).Close()
+		go gopyh.Embed(vifc, reflect.TypeOf(linksocks.SocketManager{})).(*linksocks.SocketManager).ReleaseListener(int(port))
 	} else {
-		gopyh.Embed(vifc, reflect.TypeOf(linksocks.Relay{})).(*linksocks.Relay).Close()
+		gopyh.Embed(vifc, reflect.TypeOf(linksocks.SocketManager{})).(*linksocks.SocketManager).ReleaseListener(int(port))
 	}
 }
 
-//export linksocks_Relay_SetConnectionSuccess
-func linksocks_Relay_SetConnectionSuccess(_handle CGoHandle, channelID CGoHandle, goRun C.char) {
+//export linksocks_SocketManager_Close
+func linksocks_SocketManager_Close(_handle CGoHandle, goRun C.char) {
 	_saved_thread := C.PyEval_SaveThread()
 	defer C.PyEval_RestoreThread(_saved_thread)
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.Relay")
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.SocketManager")
 	if __err != nil {
 		return
 	}
 	if boolPyToGo(goRun) {
-		go gopyh.Embed(vifc, reflect.TypeOf(linksocks.Relay{})).(*linksocks.Relay).SetConnectionSuccess(deptrFromHandle_uuid_UUID(channelID))
+		go gopyh.Embed(vifc, reflect.TypeOf(linksocks.SocketManager{})).(*linksocks.SocketManager).Close()
 	} else {
-		gopyh.Embed(vifc, reflect.TypeOf(linksocks.Relay{})).(*linksocks.Relay).SetConnectionSuccess(deptrFromHandle_uuid_UUID(channelID))
+		gopyh.Embed(vifc, reflect.TypeOf(linksocks.SocketManager{})).(*linksocks.SocketManager).Close()
 	}
 }
 
@@ -8076,43 +8076,43 @@ func linksocks_Relay_SetConnectionSuccess(_handle CGoHandle, channelID CGoHandle
 
 // ---- Constructors ---
 
-//export linksocks_DefaultClientOption
-func linksocks_DefaultClientOption() CGoHandle {
+//export linksocks_NewContextWithCancel
+func linksocks_NewContextWithCancel() CGoHandle {
 	_saved_thread := C.PyEval_SaveThread()
 	defer C.PyEval_RestoreThread(_saved_thread)
-	return handleFromPtr_Ptr_linksocks_ClientOption(linksocks.DefaultClientOption())
+	return handleFromPtr_Ptr_linksocks_ContextWithCancel(linksocks.NewContextWithCancel())
 
 }
 
-//export linksocks_DefaultReverseTokenOptions
-func linksocks_DefaultReverseTokenOptions() CGoHandle {
+//export linksocks_NewLinkSocksServer
+func linksocks_NewLinkSocksServer(opt CGoHandle) CGoHandle {
 	_saved_thread := C.PyEval_SaveThread()
 	defer C.PyEval_RestoreThread(_saved_thread)
-	return handleFromPtr_Ptr_linksocks_ReverseTokenOptions(linksocks.DefaultReverseTokenOptions())
+	return handleFromPtr_Ptr_linksocks_LinkSocksServer(linksocks.NewLinkSocksServer(ptrFromHandle_Ptr_linksocks_ServerOption(opt)))
 
 }
 
-//export linksocks_NewAPIHandler
-func linksocks_NewAPIHandler(server CGoHandle, apiKey *C.char) CGoHandle {
+//export linksocks_NewRelay
+func linksocks_NewRelay(logger CGoHandle, option CGoHandle) CGoHandle {
 	_saved_thread := C.PyEval_SaveThread()
 	defer C.PyEval_RestoreThread(_saved_thread)
-	return handleFromPtr_Ptr_linksocks_APIHandler(linksocks.NewAPIHandler(ptrFromHandle_Ptr_linksocks_LinkSocksServer(server), C.GoString(apiKey)))
+	return handleFromPtr_Ptr_linksocks_Relay(linksocks.NewRelay(*ptrFromHandle_zerolog_Logger(logger), ptrFromHandle_Ptr_linksocks_RelayOption(option)))
 
 }
 
-//export linksocks_NewPortPool
-func linksocks_NewPortPool(ports CGoHandle) CGoHandle {
+//export linksocks_NewWSConn
+func linksocks_NewWSConn(conn CGoHandle, label *C.char, logger CGoHandle) CGoHandle {
 	_saved_thread := C.PyEval_SaveThread()
 	defer C.PyEval_RestoreThread(_saved_thread)
-	return handleFromPtr_Ptr_linksocks_PortPool(linksocks.NewPortPool(deptrFromHandle_Slice_int(ports)))
+	return handleFromPtr_Ptr_linksocks_WSConn(linksocks.NewWSConn(ptrFromHandle_Ptr_websocket_Conn(conn), C.GoString(label), *ptrFromHandle_zerolog_Logger(logger)))
 
 }
 
-//export linksocks_NewPortPoolFromRange
-func linksocks_NewPortPoolFromRange(start C.longlong, end C.longlong) CGoHandle {
+//export linksocks_DefaultClientOption
+func linksocks_DefaultClientOption() CGoHandle {
 	_saved_thread := C.PyEval_SaveThread()
 	defer C.PyEval_RestoreThread(_saved_thread)
-	return handleFromPtr_Ptr_linksocks_PortPool(linksocks.NewPortPoolFromRange(int(start), int(end)))
+	return handleFromPtr_Ptr_linksocks_ClientOption(linksocks.DefaultClientOption())
 
 }
 
@@ -8124,22 +8124,6 @@ func linksocks_DefaultServerOption() CGoHandle {
 
 }
 
-//export linksocks_NewSocketManager
-func linksocks_NewSocketManager(host *C.char, log CGoHandle) CGoHandle {
-	_saved_thread := C.PyEval_SaveThread()
-	defer C.PyEval_RestoreThread(_saved_thread)
-	return handleFromPtr_Ptr_linksocks_SocketManager(linksocks.NewSocketManager(C.GoString(host), *ptrFromHandle_zerolog_Logger(log)))
-
-}
-
-//export linksocks_NewWSConn
-func linksocks_NewWSConn(conn CGoHandle, label *C.char, logger CGoHandle) CGoHandle {
-	_saved_thread := C.PyEval_SaveThread()
-	defer C.PyEval_RestoreThread(_saved_thread)
-	return handleFromPtr_Ptr_linksocks_WSConn(linksocks.NewWSConn(ptrFromHandle_Ptr_websocket_Conn(conn), C.GoString(label), *ptrFromHandle_zerolog_Logger(logger)))
-
-}
-
 //export linksocks_NewCLI
 func linksocks_NewCLI() CGoHandle {
 	_saved_thread := C.PyEval_SaveThread()
@@ -8148,11 +8132,11 @@ func linksocks_NewCLI() CGoHandle {
 
 }
 
-//export linksocks_NewContextWithCancel
-func linksocks_NewContextWithCancel() CGoHandle {
+//export linksocks_NewDefaultRelayOption
+func linksocks_NewDefaultRelayOption() CGoHandle {
 	_saved_thread := C.PyEval_SaveThread()
 	defer C.PyEval_RestoreThread(_saved_thread)
-	return handleFromPtr_Ptr_linksocks_ContextWithCancel(linksocks.NewContextWithCancel())
+	return handleFromPtr_Ptr_linksocks_RelayOption(linksocks.NewDefaultRelayOption())
 
 }
 
@@ -8164,68 +8148,47 @@ func linksocks_NewLinkSocksClient(token *C.char, opt CGoHandle) CGoHandle {
 
 }
 
-//export linksocks_NewDefaultRelayOption
-func linksocks_NewDefaultRelayOption() CGoHandle {
+//export linksocks_DefaultReverseTokenOptions
+func linksocks_DefaultReverseTokenOptions() CGoHandle {
 	_saved_thread := C.PyEval_SaveThread()
 	defer C.PyEval_RestoreThread(_saved_thread)
-	return handleFromPtr_Ptr_linksocks_RelayOption(linksocks.NewDefaultRelayOption())
+	return handleFromPtr_Ptr_linksocks_ReverseTokenOptions(linksocks.DefaultReverseTokenOptions())
 
 }
 
-//export linksocks_NewLinkSocksServer
-func linksocks_NewLinkSocksServer(opt CGoHandle) CGoHandle {
+//export linksocks_NewAPIHandler
+func linksocks_NewAPIHandler(server CGoHandle, apiKey *C.char) CGoHandle {
 	_saved_thread := C.PyEval_SaveThread()
 	defer C.PyEval_RestoreThread(_saved_thread)
-	return handleFromPtr_Ptr_linksocks_LinkSocksServer(linksocks.NewLinkSocksServer(ptrFromHandle_Ptr_linksocks_ServerOption(opt)))
+	return handleFromPtr_Ptr_linksocks_APIHandler(linksocks.NewAPIHandler(ptrFromHandle_Ptr_linksocks_LinkSocksServer(server), C.GoString(apiKey)))
 
 }
 
-//export linksocks_NewRelay
-func linksocks_NewRelay(logger CGoHandle, option CGoHandle) CGoHandle {
+//export linksocks_NewPortPoolFromRange
+func linksocks_NewPortPoolFromRange(start C.longlong, end C.longlong) CGoHandle {
 	_saved_thread := C.PyEval_SaveThread()
 	defer C.PyEval_RestoreThread(_saved_thread)
-	return handleFromPtr_Ptr_linksocks_Relay(linksocks.NewRelay(*ptrFromHandle_zerolog_Logger(logger), ptrFromHandle_Ptr_linksocks_RelayOption(option)))
+	return handleFromPtr_Ptr_linksocks_PortPool(linksocks.NewPortPoolFromRange(int(start), int(end)))
 
 }
 
-// ---- Functions ---
-
-//export linksocks_Background
-func linksocks_Background() CGoHandle {
+//export linksocks_NewPortPool
+func linksocks_NewPortPool(ports CGoHandle) CGoHandle {
 	_saved_thread := C.PyEval_SaveThread()
 	defer C.PyEval_RestoreThread(_saved_thread)
-	return handleFromPtr_context_Context(linksocks.Background())
+	return handleFromPtr_Ptr_linksocks_PortPool(linksocks.NewPortPool(deptrFromHandle_Slice_int(ports)))
 
 }
 
-//export linksocks_NewContext
-func linksocks_NewContext() CGoHandle {
+//export linksocks_NewSocketManager
+func linksocks_NewSocketManager(host *C.char, log CGoHandle) CGoHandle {
 	_saved_thread := C.PyEval_SaveThread()
 	defer C.PyEval_RestoreThread(_saved_thread)
-	return handleFromPtr_context_Context(linksocks.NewContext())
+	return handleFromPtr_Ptr_linksocks_SocketManager(linksocks.NewSocketManager(C.GoString(host), *ptrFromHandle_zerolog_Logger(log)))
 
 }
 
-//export linksocks_NewLogger
-func linksocks_NewLogger(cb *C.PyObject) CGoHandle {
-	_fun_arg := cb
-	_saved_thread := C.PyEval_SaveThread()
-	defer C.PyEval_RestoreThread(_saved_thread)
-	cret := linksocks.NewLogger(func(line string) {
-		if C.PyCallable_Check(_fun_arg) == 0 {
-			return
-		}
-		_gstate := C.PyGILState_Ensure()
-		_fcargs := C.PyTuple_New(1)
-		C.PyTuple_SetItem(_fcargs, 0, C.gopy_build_string(C.CString(line)))
-		C.PyObject_CallObject(_fun_arg, _fcargs)
-		C.gopy_decref(_fcargs)
-		C.gopy_err_handle()
-		C.PyGILState_Release(_gstate)
-	})
-
-	return handleFromPtr_zerolog_Logger(&cret)
-}
+// ---- Functions ---
 
 //export linksocks_DebugLog
 func linksocks_DebugLog(logger CGoHandle, msg *C.char, goRun C.char) {
@@ -8238,45 +8201,6 @@ func linksocks_DebugLog(logger CGoHandle, msg *C.char, goRun C.char) {
 	}
 }
 
-//export linksocks_GetLogEntries
-func linksocks_GetLogEntries() CGoHandle {
-	_saved_thread := C.PyEval_SaveThread()
-	defer C.PyEval_RestoreThread(_saved_thread)
-	cret := linksocks.GetLogEntries()
-
-	return handleFromPtr_Slice_linksocks_LogEntry(&cret)
-}
-
-//export linksocks_PackMessage
-func linksocks_PackMessage(msg CGoHandle) CGoHandle {
-	_saved_thread := C.PyEval_SaveThread()
-	cret, __err := linksocks.PackMessage(ptrFromHandle_linksocks_BaseMessage(msg))
-
-	C.PyEval_RestoreThread(_saved_thread)
-	if __err != nil {
-		estr := C.CString(__err.Error())
-		C.PyErr_SetString(C.PyExc_RuntimeError, estr)
-		C.free(unsafe.Pointer(estr))
-		return handleFromPtr_Slice_byte(nil)
-	}
-	return handleFromPtr_Slice_byte(&cret)
-}
-
-//export linksocks_ParseMessage
-func linksocks_ParseMessage(data CGoHandle) CGoHandle {
-	_saved_thread := C.PyEval_SaveThread()
-	cret, __err := linksocks.ParseMessage(deptrFromHandle_Slice_byte(data))
-
-	C.PyEval_RestoreThread(_saved_thread)
-	if __err != nil {
-		estr := C.CString(__err.Error())
-		C.PyErr_SetString(C.PyExc_RuntimeError, estr)
-		C.free(unsafe.Pointer(estr))
-		return handleFromPtr_linksocks_BaseMessage(nil)
-	}
-	return handleFromPtr_linksocks_BaseMessage(cret)
-}
-
 //export linksocks_ParseDuration
 func linksocks_ParseDuration(s *C.char) C.longlong {
 	_saved_thread := C.PyEval_SaveThread()
@@ -8303,20 +8227,41 @@ func linksocks_CancelGlobalContext(goRun C.char) {
 	}
 }
 
-//export linksocks_WaitForLogEntries
-func linksocks_WaitForLogEntries(timeoutMs C.longlong) CGoHandle {
+//export linksocks_NewLoggerWithID
+func linksocks_NewLoggerWithID(id *C.char) CGoHandle {
 	_saved_thread := C.PyEval_SaveThread()
 	defer C.PyEval_RestoreThread(_saved_thread)
-	cret := linksocks.WaitForLogEntries(int64(timeoutMs))
+	cret := linksocks.NewLoggerWithID(C.GoString(id))
+
+	return handleFromPtr_zerolog_Logger(&cret)
+}
+
+//export linksocks_GetLogEntries
+func linksocks_GetLogEntries() CGoHandle {
+	_saved_thread := C.PyEval_SaveThread()
+	defer C.PyEval_RestoreThread(_saved_thread)
+	cret := linksocks.GetLogEntries()
 
 	return handleFromPtr_Slice_linksocks_LogEntry(&cret)
 }
 
-//export linksocks_NewLoggerWithIDAndLevel
-func linksocks_NewLoggerWithIDAndLevel(id *C.char, level C.char) CGoHandle {
+//export linksocks_NewLogger
+func linksocks_NewLogger(cb *C.PyObject) CGoHandle {
+	_fun_arg := cb
 	_saved_thread := C.PyEval_SaveThread()
 	defer C.PyEval_RestoreThread(_saved_thread)
-	cret := linksocks.NewLoggerWithIDAndLevel(C.GoString(id), zerolog.Level(int8(level)))
+	cret := linksocks.NewLogger(func(line string) {
+		if C.PyCallable_Check(_fun_arg) == 0 {
+			return
+		}
+		_gstate := C.PyGILState_Ensure()
+		_fcargs := C.PyTuple_New(1)
+		C.PyTuple_SetItem(_fcargs, 0, C.gopy_build_string(C.CString(line)))
+		C.PyObject_CallObject(_fun_arg, _fcargs)
+		C.gopy_decref(_fcargs)
+		C.gopy_err_handle()
+		C.PyGILState_Release(_gstate)
+	})
 
 	return handleFromPtr_zerolog_Logger(&cret)
 }
@@ -8332,13 +8277,35 @@ func linksocks_CancelLogWaiters(goRun C.char) {
 	}
 }
 
-//export linksocks_NewLoggerWithID
-func linksocks_NewLoggerWithID(id *C.char) CGoHandle {
+//export linksocks_PackMessage
+func linksocks_PackMessage(msg CGoHandle) CGoHandle {
+	_saved_thread := C.PyEval_SaveThread()
+	cret, __err := linksocks.PackMessage(ptrFromHandle_linksocks_BaseMessage(msg))
+
+	C.PyEval_RestoreThread(_saved_thread)
+	if __err != nil {
+		estr := C.CString(__err.Error())
+		C.PyErr_SetString(C.PyExc_RuntimeError, estr)
+		C.free(unsafe.Pointer(estr))
+		return handleFromPtr_Slice_byte(nil)
+	}
+	return handleFromPtr_Slice_byte(&cret)
+}
+
+//export linksocks_Background
+func linksocks_Background() CGoHandle {
 	_saved_thread := C.PyEval_SaveThread()
 	defer C.PyEval_RestoreThread(_saved_thread)
-	cret := linksocks.NewLoggerWithID(C.GoString(id))
+	return handleFromPtr_context_Context(linksocks.Background())
+
+}
+
+//export linksocks_NewContext
+func linksocks_NewContext() CGoHandle {
+	_saved_thread := C.PyEval_SaveThread()
+	defer C.PyEval_RestoreThread(_saved_thread)
+	return handleFromPtr_context_Context(linksocks.NewContext())
 
-	return handleFromPtr_zerolog_Logger(&cret)
 }
 
 //export linksocks_NewLoggerWithLevel
@@ -8372,3 +8339,36 @@ func linksocks_SetLoggerGlobalLevel(level C.char, goRun C.char) {
 		linksocks.SetLoggerGlobalLevel(zerolog.Level(int8(level)))
 	}
 }
+
+//export linksocks_NewLoggerWithIDAndLevel
+func linksocks_NewLoggerWithIDAndLevel(id *C.char, level C.char) CGoHandle {
+	_saved_thread := C.PyEval_SaveThread()
+	defer C.PyEval_RestoreThread(_saved_thread)
+	cret := linksocks.NewLoggerWithIDAndLevel(C.GoString(id), zerolog.Level(int8(level)))
+
+	return handleFromPtr_zerolog_Logger(&cret)
+}
+
+//export linksocks_WaitForLogEntries
+func linksocks_WaitForLogEntries(timeoutMs C.longlong) CGoHandle {
+	_saved_thread := C.PyEval_SaveThread()
+	defer C.PyEval_RestoreThread(_saved_thread)
+	cret := linksocks.WaitForLogEntries(int64(timeoutMs))
+
+	return handleFromPtr_Slice_linksocks_LogEntry(&cret)
+}
+
+//export linksocks_ParseMessage
+func linksocks_ParseMessage(data CGoHandle) CGoHandle {
+	_saved_thread := C.PyEval_SaveThread()
+	cret, __err := linksocks.ParseMessage(deptrFromHandle_Slice_byte(data))
+
+	C.PyEval_RestoreThread(_saved_thread)
+	if __err != nil {
+		estr := C.CString(__err.Error())
+		C.PyErr_SetString(C.PyExc_RuntimeError, estr)
+		C.free(unsafe.Pointer(estr))
+		return handleFromPtr_linksocks_BaseMessage(nil)
+	}
+	return handleFromPtr_linksocks_BaseMessage(cret)
+}