linksocks 3.0.12__cp312-cp312-win_amd64.whl → 3.0.13__cp312-cp312-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_2jn5e566\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_rki5036q\venv\Scripts\python.exe -output=D:\a\linksocks\linksocks\_bindings\python\linksockslib -name=linksockslib -no-make=true ./linksocks_go
 */
 
 package main
@@ -5228,121 +5228,227 @@ func linksocks_BaseMessage_GetType(_handle CGoHandle) *C.char {
 
 // ---- Structs ---
 
-// --- wrapping struct: linksocks.LogMessage ---
+// --- wrapping struct: linksocks.DataMessage ---
 //
-//export linksocks_LogMessage_CTor
-func linksocks_LogMessage_CTor() CGoHandle {
-	return CGoHandle(handleFromPtr_linksocks_LogMessage(&linksocks.LogMessage{}))
+//export linksocks_DataMessage_CTor
+func linksocks_DataMessage_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_linksocks_DataMessage(&linksocks.DataMessage{}))
 }
 
-//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_DataMessage_Protocol_Get
+func linksocks_DataMessage_Protocol_Get(handle CGoHandle) *C.char {
+	op := ptrFromHandle_linksocks_DataMessage(handle)
+	return C.CString(op.Protocol)
 }
 
-//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_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_LogMessage_Msg_Get
-func linksocks_LogMessage_Msg_Get(handle CGoHandle) *C.char {
-	op := ptrFromHandle_linksocks_LogMessage(handle)
-	return C.CString(op.Msg)
+//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_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_DataMessage_Data_Get
+func linksocks_DataMessage_Data_Get(handle CGoHandle) CGoHandle {
+	op := ptrFromHandle_linksocks_DataMessage(handle)
+	return handleFromPtr_Slice_byte(&op.Data)
 }
 
-//export linksocks_LogMessage_GetType
-func linksocks_LogMessage_GetType(_handle CGoHandle) *C.char {
+//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_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)
+}
+
+//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_DataMessage_TargetAddr_Get
+func linksocks_DataMessage_TargetAddr_Get(handle CGoHandle) *C.char {
+	op := ptrFromHandle_linksocks_DataMessage(handle)
+	return C.CString(op.TargetAddr)
+}
+
+//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_DataMessage_TargetPort_Get
+func linksocks_DataMessage_TargetPort_Get(handle CGoHandle) C.longlong {
+	op := ptrFromHandle_linksocks_DataMessage(handle)
+	return C.longlong(op.TargetPort)
+}
+
+//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_DataMessage_GetType
+func linksocks_DataMessage_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.DataMessage")
 	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.DataMessage{})).(*linksocks.DataMessage).GetType())
 
 }
 
-// --- wrapping struct: linksocks.TokenStatus ---
+// --- wrapping struct: linksocks.DynamicForwarder ---
 //
-//export linksocks_TokenStatus_CTor
-func linksocks_TokenStatus_CTor() CGoHandle {
-	return CGoHandle(handleFromPtr_linksocks_TokenStatus(&linksocks.TokenStatus{}))
+//export linksocks_DynamicForwarder_CTor
+func linksocks_DynamicForwarder_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_linksocks_DynamicForwarder(&linksocks.DynamicForwarder{}))
 }
 
-//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_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_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_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_TokenStatus_Type_Get
-func linksocks_TokenStatus_Type_Get(handle CGoHandle) *C.char {
-	op := ptrFromHandle_linksocks_TokenStatus(handle)
-	return C.CString(op.Type)
+//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_TokenStatus_Type_Set
-func linksocks_TokenStatus_Type_Set(handle CGoHandle, val *C.char) {
-	op := ptrFromHandle_linksocks_TokenStatus(handle)
-	op.Type = C.GoString(val)
+// --- wrapping struct: linksocks.ReverseTokenResult ---
+//
+//export linksocks_ReverseTokenResult_CTor
+func linksocks_ReverseTokenResult_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_linksocks_ReverseTokenResult(&linksocks.ReverseTokenResult{}))
 }
 
-//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_ReverseTokenResult_Token_Get
+func linksocks_ReverseTokenResult_Token_Get(handle CGoHandle) *C.char {
+	op := ptrFromHandle_linksocks_ReverseTokenResult(handle)
+	return C.CString(op.Token)
 }
 
-//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_ReverseTokenResult_Token_Set
+func linksocks_ReverseTokenResult_Token_Set(handle CGoHandle, val *C.char) {
+	op := ptrFromHandle_linksocks_ReverseTokenResult(handle)
+	op.Token = C.GoString(val)
 }
 
-// --- wrapping struct: linksocks.ReverseTokenStatus ---
+//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)
+}
+
+// --- wrapping struct: linksocks.StatusResponse ---
 //
-//export linksocks_ReverseTokenStatus_CTor
-func linksocks_ReverseTokenStatus_CTor() CGoHandle {
-	return CGoHandle(handleFromPtr_linksocks_ReverseTokenStatus(&linksocks.ReverseTokenStatus{}))
+//export linksocks_StatusResponse_CTor
+func linksocks_StatusResponse_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_linksocks_StatusResponse(&linksocks.StatusResponse{}))
 }
 
-//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_StatusResponse_Version_Get
+func linksocks_StatusResponse_Version_Get(handle CGoHandle) *C.char {
+	op := ptrFromHandle_linksocks_StatusResponse(handle)
+	return C.CString(op.Version)
 }
 
-//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_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_ReverseTokenStatus_ConnectorTokens_Get
-func linksocks_ReverseTokenStatus_ConnectorTokens_Get(handle CGoHandle) CGoHandle {
-	op := ptrFromHandle_linksocks_ReverseTokenStatus(handle)
-	return handleFromPtr_Slice_string(&op.ConnectorTokens)
+//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_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_StatusResponse_Tokens_Set
+func linksocks_StatusResponse_Tokens_Set(handle CGoHandle, val CGoHandle) {
+	op := ptrFromHandle_linksocks_StatusResponse(handle)
+	op.Tokens = deptrFromHandle_Slice_interface_(val)
 }
 
 // --- wrapping struct: linksocks.AuthMessage ---
@@ -5437,211 +5543,47 @@ func linksocks_AuthResponseMessage_GetType(_handle CGoHandle) *C.char {
 
 }
 
-// --- wrapping struct: linksocks.DataMessage ---
+// --- wrapping struct: linksocks.LogMessage ---
 //
-//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_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)
-}
-
-//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_LogMessage_CTor
+func linksocks_LogMessage_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_linksocks_LogMessage(&linksocks.LogMessage{}))
 }
 
-//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_LogMessage_Level_Get
+func linksocks_LogMessage_Level_Get(handle CGoHandle) *C.char {
+	op := ptrFromHandle_linksocks_LogMessage(handle)
+	return C.CString(op.Level)
 }
 
-//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_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_DataMessage_TargetPort_Get
-func linksocks_DataMessage_TargetPort_Get(handle CGoHandle) C.longlong {
-	op := ptrFromHandle_linksocks_DataMessage(handle)
-	return C.longlong(op.TargetPort)
+//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_DataMessage_TargetPort_Set
-func linksocks_DataMessage_TargetPort_Set(handle CGoHandle, val C.longlong) {
-	op := ptrFromHandle_linksocks_DataMessage(handle)
-	op.TargetPort = int(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_DataMessage_GetType
-func linksocks_DataMessage_GetType(_handle CGoHandle) *C.char {
+//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.DataMessage")
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.LogMessage")
 	if __err != nil {
 		return C.CString("")
 	}
-	return C.CString(gopyh.Embed(vifc, reflect.TypeOf(linksocks.DataMessage{})).(*linksocks.DataMessage).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)
-}
-
-//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_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_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_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_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_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_ReverseTokenResult_Port_Get
-func linksocks_ReverseTokenResult_Port_Get(handle CGoHandle) C.longlong {
-	op := ptrFromHandle_linksocks_ReverseTokenResult(handle)
-	return C.longlong(op.Port)
-}
+	return C.CString(gopyh.Embed(vifc, reflect.TypeOf(linksocks.LogMessage{})).(*linksocks.LogMessage).GetType())
 
-//export linksocks_ReverseTokenResult_Port_Set
-func linksocks_ReverseTokenResult_Port_Set(handle CGoHandle, val C.longlong) {
-	op := ptrFromHandle_linksocks_ReverseTokenResult(handle)
-	op.Port = int(val)
 }
 
 // --- wrapping struct: linksocks.ServerOption ---
@@ -5975,265 +5917,113 @@ func linksocks_ServerOption_WithUpstreamAuth(_handle CGoHandle, username *C.char
 
 }
 
-// --- wrapping struct: linksocks.TokenRequest ---
+// --- wrapping struct: linksocks.ConnectorMessage ---
 //
-//export linksocks_TokenRequest_CTor
-func linksocks_TokenRequest_CTor() CGoHandle {
-	return CGoHandle(handleFromPtr_linksocks_TokenRequest(&linksocks.TokenRequest{}))
+//export linksocks_ConnectorMessage_CTor
+func linksocks_ConnectorMessage_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_linksocks_ConnectorMessage(&linksocks.ConnectorMessage{}))
 }
 
-//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_ConnectorMessage_ChannelID_Get
+func linksocks_ConnectorMessage_ChannelID_Get(handle CGoHandle) CGoHandle {
+	op := ptrFromHandle_linksocks_ConnectorMessage(handle)
+	return handleFromPtr_uuid_UUID(&op.ChannelID)
 }
 
-//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_ConnectorMessage_ConnectorToken_Get
+func linksocks_ConnectorMessage_ConnectorToken_Get(handle CGoHandle) *C.char {
+	op := ptrFromHandle_linksocks_ConnectorMessage(handle)
+	return C.CString(op.ConnectorToken)
 }
 
-//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_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_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_ConnectorMessage_Operation_Get
+func linksocks_ConnectorMessage_Operation_Get(handle CGoHandle) *C.char {
+	op := ptrFromHandle_linksocks_ConnectorMessage(handle)
+	return C.CString(op.Operation)
 }
 
-//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_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_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)
-}
-
-//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_TokenRequest_Password_Get
-func linksocks_TokenRequest_Password_Get(handle CGoHandle) *C.char {
-	op := ptrFromHandle_linksocks_TokenRequest(handle)
-	return C.CString(op.Password)
-}
-
-//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_TokenRequest_ReverseToken_Get
-func linksocks_TokenRequest_ReverseToken_Get(handle CGoHandle) *C.char {
-	op := ptrFromHandle_linksocks_TokenRequest(handle)
-	return C.CString(op.ReverseToken)
-}
-
-//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_TokenRequest_AllowManageConnector_Get
-func linksocks_TokenRequest_AllowManageConnector_Get(handle CGoHandle) C.char {
-	op := ptrFromHandle_linksocks_TokenRequest(handle)
-	return boolGoToPy(op.AllowManageConnector)
-}
-
-//export linksocks_TokenRequest_AllowManageConnector_Set
-func linksocks_TokenRequest_AllowManageConnector_Set(handle CGoHandle, val C.char) {
-	op := ptrFromHandle_linksocks_TokenRequest(handle)
-	op.AllowManageConnector = boolPyToGo(val)
-}
-
-// --- wrapping struct: linksocks.WSConn ---
-//
-//export linksocks_WSConn_CTor
-func linksocks_WSConn_CTor() CGoHandle {
-	return CGoHandle(handleFromPtr_linksocks_WSConn(&linksocks.WSConn{}))
-}
-
-//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.WSConn")
-	if __err != nil {
-		return C.CString("")
-	}
-	return C.CString(gopyh.Embed(vifc, reflect.TypeOf(linksocks.WSConn{})).(*linksocks.WSConn).Label())
-
-}
-
-//export linksocks_WSConn_GetClientIP
-func linksocks_WSConn_GetClientIP(_handle CGoHandle) *C.char {
+//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.WSConn")
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.ConnectorMessage")
 	if __err != nil {
 		return C.CString("")
 	}
-	return C.CString(gopyh.Embed(vifc, reflect.TypeOf(linksocks.WSConn{})).(*linksocks.WSConn).GetClientIP())
+	return C.CString(gopyh.Embed(vifc, reflect.TypeOf(linksocks.ConnectorMessage{})).(*linksocks.ConnectorMessage).GetType())
 
 }
 
-//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))
-	}
+// --- wrapping struct: linksocks.ConnectorResponseMessage ---
+//
+//export linksocks_ConnectorResponseMessage_CTor
+func linksocks_ConnectorResponseMessage_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_linksocks_ConnectorResponseMessage(&linksocks.ConnectorResponseMessage{}))
 }
 
-//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))
-
-	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_ConnectorResponseMessage_Success_Get
+func linksocks_ConnectorResponseMessage_Success_Get(handle CGoHandle) C.char {
+	op := ptrFromHandle_linksocks_ConnectorResponseMessage(handle)
+	return boolGoToPy(op.Success)
 }
 
-//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()
-
-	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_ConnectorResponseMessage_Success_Set
+func linksocks_ConnectorResponseMessage_Success_Set(handle CGoHandle, val C.char) {
+	op := ptrFromHandle_linksocks_ConnectorResponseMessage(handle)
+	op.Success = boolPyToGo(val)
 }
 
-//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))
-
-	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_ConnectorResponseMessage_Error_Get
+func linksocks_ConnectorResponseMessage_Error_Get(handle CGoHandle) *C.char {
+	op := ptrFromHandle_linksocks_ConnectorResponseMessage(handle)
+	return C.CString(op.Error)
 }
 
-//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))
-
-	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_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_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_ConnectorResponseMessage_ChannelID_Get
+func linksocks_ConnectorResponseMessage_ChannelID_Get(handle CGoHandle) CGoHandle {
+	op := ptrFromHandle_linksocks_ConnectorResponseMessage(handle)
+	return handleFromPtr_uuid_UUID(&op.ChannelID)
 }
 
-// --- wrapping struct: linksocks.ContextWithCancel ---
-//
-//export linksocks_ContextWithCancel_CTor
-func linksocks_ContextWithCancel_CTor() CGoHandle {
-	return CGoHandle(handleFromPtr_linksocks_ContextWithCancel(&linksocks.ContextWithCancel{}))
+//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_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_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_ContextWithCancel_Context
-func linksocks_ContextWithCancel_Context(_handle CGoHandle) CGoHandle {
+//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.ContextWithCancel")
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.ConnectorResponseMessage")
 	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.ConnectorResponseMessage{})).(*linksocks.ConnectorResponseMessage).GetType())
 
 }
 
@@ -6470,403 +6260,308 @@ func linksocks_Relay_SetConnectionSuccess(_handle CGoHandle, channelID CGoHandle
 	}
 }
 
-// --- wrapping struct: linksocks.RelayOption ---
+// --- wrapping struct: linksocks.TokenStatus ---
 //
-//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_TokenStatus_CTor
+func linksocks_TokenStatus_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_linksocks_TokenStatus(&linksocks.TokenStatus{}))
 }
 
-//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_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_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_RelayOption_UpstreamUsername_Get
-func linksocks_RelayOption_UpstreamUsername_Get(handle CGoHandle) *C.char {
-	op := ptrFromHandle_linksocks_RelayOption(handle)
-	return C.CString(op.UpstreamUsername)
-}
-
-//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_RelayOption_UpstreamPassword_Get
-func linksocks_RelayOption_UpstreamPassword_Get(handle CGoHandle) *C.char {
-	op := ptrFromHandle_linksocks_RelayOption(handle)
-	return C.CString(op.UpstreamPassword)
-}
-
-//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_RelayOption_EnableDynamicBatching_Get
-func linksocks_RelayOption_EnableDynamicBatching_Get(handle CGoHandle) C.char {
-	op := ptrFromHandle_linksocks_RelayOption(handle)
-	return boolGoToPy(op.EnableDynamicBatching)
-}
-
-//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_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_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_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_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_RelayOption_HighSpeedThreshold_Get
-func linksocks_RelayOption_HighSpeedThreshold_Get(handle CGoHandle) C.double {
-	op := ptrFromHandle_linksocks_RelayOption(handle)
-	return C.double(op.HighSpeedThreshold)
+//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_HighSpeedThreshold_Set
-func linksocks_RelayOption_HighSpeedThreshold_Set(handle CGoHandle, val C.double) {
-	op := ptrFromHandle_linksocks_RelayOption(handle)
-	op.HighSpeedThreshold = float64(val)
+//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_LowSpeedThreshold_Get
-func linksocks_RelayOption_LowSpeedThreshold_Get(handle CGoHandle) C.double {
-	op := ptrFromHandle_linksocks_RelayOption(handle)
-	return C.double(op.LowSpeedThreshold)
+//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_LowSpeedThreshold_Set
-func linksocks_RelayOption_LowSpeedThreshold_Set(handle CGoHandle, val C.double) {
-	op := ptrFromHandle_linksocks_RelayOption(handle)
-	op.LowSpeedThreshold = float64(val)
+//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_CompressionThreshold_Get
-func linksocks_RelayOption_CompressionThreshold_Get(handle CGoHandle) C.longlong {
-	op := ptrFromHandle_linksocks_RelayOption(handle)
-	return C.longlong(op.CompressionThreshold)
+//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_CompressionThreshold_Set
-func linksocks_RelayOption_CompressionThreshold_Set(handle CGoHandle, val C.longlong) {
-	op := ptrFromHandle_linksocks_RelayOption(handle)
-	op.CompressionThreshold = int(val)
+// --- wrapping struct: linksocks.WSConn ---
+//
+//export linksocks_WSConn_CTor
+func linksocks_WSConn_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_linksocks_WSConn(&linksocks.WSConn{}))
 }
 
-//export linksocks_RelayOption_WithBufferSize
-func linksocks_RelayOption_WithBufferSize(_handle CGoHandle, size C.longlong) CGoHandle {
+//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.RelayOption")
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.WSConn")
 	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).WithBufferSize(int(size)))
+	return C.CString(gopyh.Embed(vifc, reflect.TypeOf(linksocks.WSConn{})).(*linksocks.WSConn).Label())
 
 }
 
-//export linksocks_RelayOption_WithChannelTimeout
-func linksocks_RelayOption_WithChannelTimeout(_handle CGoHandle, timeout C.longlong) CGoHandle {
+//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.RelayOption")
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.WSConn")
 	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).WithChannelTimeout(time.Duration(int64(timeout))))
+	return C.CString(gopyh.Embed(vifc, reflect.TypeOf(linksocks.WSConn{})).(*linksocks.WSConn).GetClientIP())
 
 }
 
-//export linksocks_RelayOption_WithConnectTimeout
-func linksocks_RelayOption_WithConnectTimeout(_handle CGoHandle, timeout C.longlong) CGoHandle {
+//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.RelayOption")
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.WSConn")
 	if __err != nil {
-		return handleFromPtr_Ptr_linksocks_RelayOption(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))
 	}
-	return handleFromPtr_Ptr_linksocks_RelayOption(gopyh.Embed(vifc, reflect.TypeOf(linksocks.RelayOption{})).(*linksocks.RelayOption).WithConnectTimeout(time.Duration(int64(timeout))))
-
 }
 
-//export linksocks_RelayOption_WithFastOpen
-func linksocks_RelayOption_WithFastOpen(_handle CGoHandle, fastOpen C.char) CGoHandle {
+//export linksocks_WSConn_SyncWriteBinary
+func linksocks_WSConn_SyncWriteBinary(_handle CGoHandle, data 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.WSConn")
 	if __err != nil {
-		return handleFromPtr_Ptr_linksocks_RelayOption(nil)
+		return errorGoToPy(nil)
 	}
-	return handleFromPtr_Ptr_linksocks_RelayOption(gopyh.Embed(vifc, reflect.TypeOf(linksocks.RelayOption{})).(*linksocks.RelayOption).WithFastOpen(boolPyToGo(fastOpen)))
-
-}
+	__err = gopyh.Embed(vifc, reflect.TypeOf(linksocks.WSConn{})).(*linksocks.WSConn).SyncWriteBinary(deptrFromHandle_Slice_byte(data))
 
-//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.RelayOption")
+	C.PyEval_RestoreThread(_saved_thread)
 	if __err != nil {
-		return handleFromPtr_Ptr_linksocks_RelayOption(nil)
+		estr := C.CString(__err.Error())
+		C.PyErr_SetString(C.PyExc_RuntimeError, estr)
+		return estr
 	}
-	return handleFromPtr_Ptr_linksocks_RelayOption(gopyh.Embed(vifc, reflect.TypeOf(linksocks.RelayOption{})).(*linksocks.RelayOption).WithUpstreamProxy(C.GoString(proxy)))
-
+	return C.CString("")
 }
 
-//export linksocks_RelayOption_WithUpstreamAuth
-func linksocks_RelayOption_WithUpstreamAuth(_handle CGoHandle, username *C.char, password *C.char) CGoHandle {
+//export linksocks_WSConn_ReadMessage
+func linksocks_WSConn_ReadMessage(_handle CGoHandle) CGoHandle {
 	_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.WSConn")
 	if __err != nil {
-		return handleFromPtr_Ptr_linksocks_RelayOption(nil)
+		return handleFromPtr_linksocks_BaseMessage(nil)
 	}
-	return handleFromPtr_Ptr_linksocks_RelayOption(gopyh.Embed(vifc, reflect.TypeOf(linksocks.RelayOption{})).(*linksocks.RelayOption).WithUpstreamAuth(C.GoString(username), C.GoString(password)))
-
-}
+	cret, __err := gopyh.Embed(vifc, reflect.TypeOf(linksocks.WSConn{})).(*linksocks.WSConn).ReadMessage()
 
-//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.RelayOption")
+	C.PyEval_RestoreThread(_saved_thread)
 	if __err != nil {
-		return handleFromPtr_Ptr_linksocks_RelayOption(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_Ptr_linksocks_RelayOption(gopyh.Embed(vifc, reflect.TypeOf(linksocks.RelayOption{})).(*linksocks.RelayOption).WithDynamicBatching(boolPyToGo(enabled)))
-
+	return handleFromPtr_linksocks_BaseMessage(cret)
 }
 
-//export linksocks_RelayOption_WithBatchingTimeLimits
-func linksocks_RelayOption_WithBatchingTimeLimits(_handle CGoHandle, min C.longlong, max C.longlong) CGoHandle {
+//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.RelayOption")
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.WSConn")
 	if __err != nil {
-		return handleFromPtr_Ptr_linksocks_RelayOption(nil)
+		return errorGoToPy(nil)
 	}
-	return handleFromPtr_Ptr_linksocks_RelayOption(gopyh.Embed(vifc, reflect.TypeOf(linksocks.RelayOption{})).(*linksocks.RelayOption).WithBatchingTimeLimits(time.Duration(int64(min)), time.Duration(int64(max))))
-
-}
+	__err = gopyh.Embed(vifc, reflect.TypeOf(linksocks.WSConn{})).(*linksocks.WSConn).WriteMessage(ptrFromHandle_linksocks_BaseMessage(msg))
 
-//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")
+	C.PyEval_RestoreThread(_saved_thread)
 	if __err != nil {
-		return handleFromPtr_Ptr_linksocks_RelayOption(nil)
+		estr := C.CString(__err.Error())
+		C.PyErr_SetString(C.PyExc_RuntimeError, estr)
+		return estr
 	}
-	return handleFromPtr_Ptr_linksocks_RelayOption(gopyh.Embed(vifc, reflect.TypeOf(linksocks.RelayOption{})).(*linksocks.RelayOption).WithHighSpeedThreshold(float64(threshold)))
-
+	return C.CString("")
 }
 
-//export linksocks_RelayOption_WithLowSpeedThreshold
-func linksocks_RelayOption_WithLowSpeedThreshold(_handle CGoHandle, threshold C.double) CGoHandle {
+//export linksocks_WSConn_SyncWriteControl
+func linksocks_WSConn_SyncWriteControl(_handle CGoHandle, messageType C.longlong, data CGoHandle, deadline 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.WSConn")
 	if __err != nil {
-		return handleFromPtr_Ptr_linksocks_RelayOption(nil)
+		return errorGoToPy(nil)
 	}
-	return handleFromPtr_Ptr_linksocks_RelayOption(gopyh.Embed(vifc, reflect.TypeOf(linksocks.RelayOption{})).(*linksocks.RelayOption).WithLowSpeedThreshold(float64(threshold)))
+	__err = gopyh.Embed(vifc, reflect.TypeOf(linksocks.WSConn{})).(*linksocks.WSConn).SyncWriteControl(int(messageType), deptrFromHandle_Slice_byte(data), *ptrFromHandle_time_Time(deadline))
 
+	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_RelayOption_WithCompressionThreshold
-func linksocks_RelayOption_WithCompressionThreshold(_handle CGoHandle, threshold C.longlong) CGoHandle {
+//export linksocks_WSConn_Close
+func linksocks_WSConn_Close(_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.WSConn")
 	if __err != nil {
-		return handleFromPtr_Ptr_linksocks_RelayOption(nil)
+		return errorGoToPy(nil)
 	}
-	return handleFromPtr_Ptr_linksocks_RelayOption(gopyh.Embed(vifc, reflect.TypeOf(linksocks.RelayOption{})).(*linksocks.RelayOption).WithCompressionThreshold(int(threshold)))
+	__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("")
 }
 
-// --- wrapping struct: linksocks.LinkSocksServer ---
+// --- wrapping struct: linksocks.CLI ---
 //
-//export linksocks_LinkSocksServer_CTor
-func linksocks_LinkSocksServer_CTor() CGoHandle {
-	return CGoHandle(handleFromPtr_linksocks_LinkSocksServer(&linksocks.LinkSocksServer{}))
+//export linksocks_CLI_CTor
+func linksocks_CLI_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_linksocks_CLI(&linksocks.CLI{}))
 }
 
-//export linksocks_LinkSocksServer_AddReverseToken
-func linksocks_LinkSocksServer_AddReverseToken(_handle CGoHandle, opts CGoHandle) CGoHandle {
+//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.LinkSocksServer")
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.CLI")
 	if __err != nil {
-		return handleFromPtr_Ptr_linksocks_ReverseTokenResult(nil)
+		return errorGoToPy(nil)
 	}
-	cret, __err := gopyh.Embed(vifc, reflect.TypeOf(linksocks.LinkSocksServer{})).(*linksocks.LinkSocksServer).AddReverseToken(ptrFromHandle_Ptr_linksocks_ReverseTokenOptions(opts))
+	__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)
-		C.free(unsafe.Pointer(estr))
-		return handleFromPtr_Ptr_linksocks_ReverseTokenResult(nil)
+		return estr
 	}
-	return handleFromPtr_Ptr_linksocks_ReverseTokenResult(cret)
+	return C.CString("")
 }
 
-//export linksocks_LinkSocksServer_AddForwardToken
-func linksocks_LinkSocksServer_AddForwardToken(_handle CGoHandle, token *C.char) *C.char {
+// --- wrapping struct: linksocks.LinkSocksClient ---
+//
+//export linksocks_LinkSocksClient_CTor
+func linksocks_LinkSocksClient_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_linksocks_LinkSocksClient(&linksocks.LinkSocksClient{}))
+}
+
+//export linksocks_LinkSocksClient_IsConnected_Get
+func linksocks_LinkSocksClient_IsConnected_Get(handle CGoHandle) C.char {
+	op := ptrFromHandle_linksocks_LinkSocksClient(handle)
+	return boolGoToPy(op.IsConnected)
+}
+
+//export linksocks_LinkSocksClient_IsConnected_Set
+func linksocks_LinkSocksClient_IsConnected_Set(handle CGoHandle, val C.char) {
+	op := ptrFromHandle_linksocks_LinkSocksClient(handle)
+	op.IsConnected = boolPyToGo(val)
+}
+
+//export linksocks_LinkSocksClient_WaitReady
+func linksocks_LinkSocksClient_WaitReady(_handle CGoHandle, ctx CGoHandle, timeout C.longlong) *C.char {
 	_saved_thread := C.PyEval_SaveThread()
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.LinkSocksServer")
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.LinkSocksClient")
 	if __err != nil {
-		return C.CString("")
+		return errorGoToPy(nil)
 	}
-	cret, __err := gopyh.Embed(vifc, reflect.TypeOf(linksocks.LinkSocksServer{})).(*linksocks.LinkSocksServer).AddForwardToken(C.GoString(token))
+	__err = gopyh.Embed(vifc, reflect.TypeOf(linksocks.LinkSocksClient{})).(*linksocks.LinkSocksClient).WaitReady(ptrFromHandle_context_Context(ctx), time.Duration(int64(timeout)))
 
 	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 estr
 	}
-	return C.CString(cret)
+	return C.CString("")
 }
 
-//export linksocks_LinkSocksServer_AddConnectorToken
-func linksocks_LinkSocksServer_AddConnectorToken(_handle CGoHandle, connectorToken *C.char, reverseToken *C.char) *C.char {
+//export linksocks_LinkSocksClient_Connect
+func linksocks_LinkSocksClient_Connect(_handle CGoHandle, ctx CGoHandle) *C.char {
 	_saved_thread := C.PyEval_SaveThread()
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.LinkSocksServer")
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.LinkSocksClient")
 	if __err != nil {
-		return C.CString("")
+		return errorGoToPy(nil)
 	}
-	cret, __err := gopyh.Embed(vifc, reflect.TypeOf(linksocks.LinkSocksServer{})).(*linksocks.LinkSocksServer).AddConnectorToken(C.GoString(connectorToken), C.GoString(reverseToken))
+	__err = gopyh.Embed(vifc, reflect.TypeOf(linksocks.LinkSocksClient{})).(*linksocks.LinkSocksClient).Connect(ptrFromHandle_context_Context(ctx))
 
 	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 estr
 	}
-	return C.CString(cret)
+	return C.CString("")
 }
 
-//export linksocks_LinkSocksServer_RemoveToken
-func linksocks_LinkSocksServer_RemoveToken(_handle CGoHandle, token *C.char) C.char {
+//export linksocks_LinkSocksClient_Close
+func linksocks_LinkSocksClient_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.LinkSocksServer")
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.LinkSocksClient")
 	if __err != nil {
-		return boolGoToPy(false)
+		return
+	}
+	if boolPyToGo(goRun) {
+		go gopyh.Embed(vifc, reflect.TypeOf(linksocks.LinkSocksClient{})).(*linksocks.LinkSocksClient).Close()
+	} else {
+		gopyh.Embed(vifc, reflect.TypeOf(linksocks.LinkSocksClient{})).(*linksocks.LinkSocksClient).Close()
 	}
-	return boolGoToPy(gopyh.Embed(vifc, reflect.TypeOf(linksocks.LinkSocksServer{})).(*linksocks.LinkSocksServer).RemoveToken(C.GoString(token)))
-
 }
 
-//export linksocks_LinkSocksServer_Serve
-func linksocks_LinkSocksServer_Serve(_handle CGoHandle, ctx CGoHandle) *C.char {
+//export linksocks_LinkSocksClient_AddConnector
+func linksocks_LinkSocksClient_AddConnector(_handle CGoHandle, connectorToken *C.char) *C.char {
 	_saved_thread := C.PyEval_SaveThread()
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.LinkSocksServer")
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.LinkSocksClient")
 	if __err != nil {
-		return errorGoToPy(nil)
+		return C.CString("")
 	}
-	__err = gopyh.Embed(vifc, reflect.TypeOf(linksocks.LinkSocksServer{})).(*linksocks.LinkSocksServer).Serve(ptrFromHandle_context_Context(ctx))
+	cret, __err := gopyh.Embed(vifc, reflect.TypeOf(linksocks.LinkSocksClient{})).(*linksocks.LinkSocksClient).AddConnector(C.GoString(connectorToken))
 
 	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 C.CString("")
 	}
-	return C.CString("")
+	return C.CString(cret)
 }
 
-//export linksocks_LinkSocksServer_WaitReady
-func linksocks_LinkSocksServer_WaitReady(_handle CGoHandle, ctx CGoHandle, timeout C.longlong) *C.char {
+//export linksocks_LinkSocksClient_RemoveConnector
+func linksocks_LinkSocksClient_RemoveConnector(_handle CGoHandle, connectorToken *C.char) *C.char {
 	_saved_thread := C.PyEval_SaveThread()
-	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.LinkSocksServer")
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.LinkSocksClient")
 	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)))
+	__err = gopyh.Embed(vifc, reflect.TypeOf(linksocks.LinkSocksClient{})).(*linksocks.LinkSocksClient).RemoveConnector(C.GoString(connectorToken))
 
 	C.PyEval_RestoreThread(_saved_thread)
 	if __err != nil {
@@ -6877,286 +6572,366 @@ func linksocks_LinkSocksServer_WaitReady(_handle CGoHandle, ctx CGoHandle, timeo
 	return C.CString("")
 }
 
-//export linksocks_LinkSocksServer_Close
-func linksocks_LinkSocksServer_Close(_handle CGoHandle, goRun C.char) {
+//export linksocks_LinkSocksClient_GetPartnersCount
+func linksocks_LinkSocksClient_GetPartnersCount(_handle CGoHandle) C.longlong {
 	_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.LinkSocksClient")
 	if __err != 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 C.longlong(0)
 	}
+	return C.longlong(gopyh.Embed(vifc, reflect.TypeOf(linksocks.LinkSocksClient{})).(*linksocks.LinkSocksClient).GetPartnersCount())
+
 }
 
-//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)
-	}
-	return C.longlong(gopyh.Embed(vifc, reflect.TypeOf(linksocks.LinkSocksServer{})).(*linksocks.LinkSocksServer).GetClientCount())
+// --- wrapping struct: linksocks.TokenRequest ---
+//
+//export linksocks_TokenRequest_CTor
+func linksocks_TokenRequest_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_linksocks_TokenRequest(&linksocks.TokenRequest{}))
+}
+
+//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_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.LinkSocksServer")
-	if __err != nil {
-		return boolGoToPy(false)
-	}
-	return boolGoToPy(gopyh.Embed(vifc, reflect.TypeOf(linksocks.LinkSocksServer{})).(*linksocks.LinkSocksServer).HasClients())
+//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_LinkSocksServer_GetTokenClientCount
-func linksocks_LinkSocksServer_GetTokenClientCount(_handle CGoHandle, token *C.char) C.longlong {
+//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_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)
+}
+
+//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_TokenRequest_Password_Get
+func linksocks_TokenRequest_Password_Get(handle CGoHandle) *C.char {
+	op := ptrFromHandle_linksocks_TokenRequest(handle)
+	return C.CString(op.Password)
+}
+
+//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_TokenRequest_ReverseToken_Get
+func linksocks_TokenRequest_ReverseToken_Get(handle CGoHandle) *C.char {
+	op := ptrFromHandle_linksocks_TokenRequest(handle)
+	return C.CString(op.ReverseToken)
+}
+
+//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_TokenRequest_AllowManageConnector_Get
+func linksocks_TokenRequest_AllowManageConnector_Get(handle CGoHandle) C.char {
+	op := ptrFromHandle_linksocks_TokenRequest(handle)
+	return boolGoToPy(op.AllowManageConnector)
+}
+
+//export linksocks_TokenRequest_AllowManageConnector_Set
+func linksocks_TokenRequest_AllowManageConnector_Set(handle CGoHandle, val C.char) {
+	op := ptrFromHandle_linksocks_TokenRequest(handle)
+	op.AllowManageConnector = boolPyToGo(val)
+}
+
+// --- 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) {
 	_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.APIHandler")
 	if __err != nil {
-		return C.longlong(0)
+		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 C.longlong(gopyh.Embed(vifc, reflect.TypeOf(linksocks.LinkSocksServer{})).(*linksocks.LinkSocksServer).GetTokenClientCount(C.GoString(token)))
-
 }
 
-// --- wrapping struct: linksocks.StatusResponse ---
+// --- wrapping struct: linksocks.ConnectResponseMessage ---
 //
-//export linksocks_StatusResponse_CTor
-func linksocks_StatusResponse_CTor() CGoHandle {
-	return CGoHandle(handleFromPtr_linksocks_StatusResponse(&linksocks.StatusResponse{}))
+//export linksocks_ConnectResponseMessage_CTor
+func linksocks_ConnectResponseMessage_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_linksocks_ConnectResponseMessage(&linksocks.ConnectResponseMessage{}))
 }
 
-//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_ConnectResponseMessage_Success_Get
+func linksocks_ConnectResponseMessage_Success_Get(handle CGoHandle) C.char {
+	op := ptrFromHandle_linksocks_ConnectResponseMessage(handle)
+	return boolGoToPy(op.Success)
 }
 
-//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_ConnectResponseMessage_Success_Set
+func linksocks_ConnectResponseMessage_Success_Set(handle CGoHandle, val C.char) {
+	op := ptrFromHandle_linksocks_ConnectResponseMessage(handle)
+	op.Success = boolPyToGo(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_ConnectResponseMessage_Error_Get
+func linksocks_ConnectResponseMessage_Error_Get(handle CGoHandle) *C.char {
+	op := ptrFromHandle_linksocks_ConnectResponseMessage(handle)
+	return C.CString(op.Error)
 }
 
-//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_ConnectResponseMessage_Error_Set
+func linksocks_ConnectResponseMessage_Error_Set(handle CGoHandle, val *C.char) {
+	op := ptrFromHandle_linksocks_ConnectResponseMessage(handle)
+	op.Error = C.GoString(val)
 }
 
-// --- wrapping struct: linksocks.CLI ---
-//
-//export linksocks_CLI_CTor
-func linksocks_CLI_CTor() CGoHandle {
-	return CGoHandle(handleFromPtr_linksocks_CLI(&linksocks.CLI{}))
+//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_CLI_Execute
-func linksocks_CLI_Execute(_handle CGoHandle) *C.char {
+//export linksocks_ConnectResponseMessage_GetType
+func linksocks_ConnectResponseMessage_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.ConnectResponseMessage")
 	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.ConnectResponseMessage{})).(*linksocks.ConnectResponseMessage).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.ConnectMessage ---
+// --- wrapping struct: linksocks.PartnersMessage ---
 //
-//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_PartnersMessage_CTor
+func linksocks_PartnersMessage_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_linksocks_PartnersMessage(&linksocks.PartnersMessage{}))
 }
 
-//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_PartnersMessage_Count_Get
+func linksocks_PartnersMessage_Count_Get(handle CGoHandle) C.longlong {
+	op := ptrFromHandle_linksocks_PartnersMessage(handle)
+	return C.longlong(op.Count)
 }
 
-//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_PartnersMessage_Count_Set
+func linksocks_PartnersMessage_Count_Set(handle CGoHandle, val C.longlong) {
+	op := ptrFromHandle_linksocks_PartnersMessage(handle)
+	op.Count = int(val)
 }
 
-//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_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.PartnersMessage")
+	if __err != nil {
+		return C.CString("")
+	}
+	return C.CString(gopyh.Embed(vifc, reflect.TypeOf(linksocks.PartnersMessage{})).(*linksocks.PartnersMessage).GetType())
 
-//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)
+// --- wrapping struct: linksocks.ContextWithCancel ---
+//
+//export linksocks_ContextWithCancel_CTor
+func linksocks_ContextWithCancel_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_linksocks_ContextWithCancel(&linksocks.ContextWithCancel{}))
 }
 
-//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_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_ConnectMessage_GetType
-func linksocks_ConnectMessage_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.ConnectMessage")
+	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.ConnectMessage{})).(*linksocks.ConnectMessage).GetType())
+	return handleFromPtr_context_Context(gopyh.Embed(vifc, reflect.TypeOf(linksocks.ContextWithCancel{})).(*linksocks.ContextWithCancel).Context())
 
 }
 
-// --- wrapping struct: linksocks.ConnectorMessage ---
+// --- wrapping struct: linksocks.DisconnectMessage ---
 //
-//export linksocks_ConnectorMessage_CTor
-func linksocks_ConnectorMessage_CTor() CGoHandle {
-	return CGoHandle(handleFromPtr_linksocks_ConnectorMessage(&linksocks.ConnectorMessage{}))
+//export linksocks_DisconnectMessage_CTor
+func linksocks_DisconnectMessage_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_linksocks_DisconnectMessage(&linksocks.DisconnectMessage{}))
 }
 
-//export linksocks_ConnectorMessage_ChannelID_Get
-func linksocks_ConnectorMessage_ChannelID_Get(handle CGoHandle) CGoHandle {
-	op := ptrFromHandle_linksocks_ConnectorMessage(handle)
+//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_ConnectorMessage_ConnectorToken_Get
-func linksocks_ConnectorMessage_ConnectorToken_Get(handle CGoHandle) *C.char {
-	op := ptrFromHandle_linksocks_ConnectorMessage(handle)
-	return C.CString(op.ConnectorToken)
-}
-
-//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_ConnectorMessage_Operation_Get
-func linksocks_ConnectorMessage_Operation_Get(handle CGoHandle) *C.char {
-	op := ptrFromHandle_linksocks_ConnectorMessage(handle)
-	return C.CString(op.Operation)
+//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_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_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_ConnectorMessage_GetType
-func linksocks_ConnectorMessage_GetType(_handle CGoHandle) *C.char {
+//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.ConnectorMessage")
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.DisconnectMessage")
 	if __err != nil {
 		return C.CString("")
 	}
-	return C.CString(gopyh.Embed(vifc, reflect.TypeOf(linksocks.ConnectorMessage{})).(*linksocks.ConnectorMessage).GetType())
+	return C.CString(gopyh.Embed(vifc, reflect.TypeOf(linksocks.DisconnectMessage{})).(*linksocks.DisconnectMessage).GetType())
 
 }
 
-// --- wrapping struct: linksocks.LogEntry ---
+// --- wrapping struct: linksocks.TokenResponse ---
 //
-//export linksocks_LogEntry_CTor
-func linksocks_LogEntry_CTor() CGoHandle {
-	return CGoHandle(handleFromPtr_linksocks_LogEntry(&linksocks.LogEntry{}))
+//export linksocks_TokenResponse_CTor
+func linksocks_TokenResponse_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_linksocks_TokenResponse(&linksocks.TokenResponse{}))
 }
 
-//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_TokenResponse_Success_Get
+func linksocks_TokenResponse_Success_Get(handle CGoHandle) C.char {
+	op := ptrFromHandle_linksocks_TokenResponse(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_TokenResponse_Success_Set
+func linksocks_TokenResponse_Success_Set(handle CGoHandle, val C.char) {
+	op := ptrFromHandle_linksocks_TokenResponse(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_TokenResponse_Token_Get
+func linksocks_TokenResponse_Token_Get(handle CGoHandle) *C.char {
+	op := ptrFromHandle_linksocks_TokenResponse(handle)
+	return C.CString(op.Token)
 }
 
-//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_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_LogEntry_Time_Get
-func linksocks_LogEntry_Time_Get(handle CGoHandle) C.longlong {
-	op := ptrFromHandle_linksocks_LogEntry(handle)
-	return C.longlong(op.Time)
+//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_LogEntry_Time_Set
-func linksocks_LogEntry_Time_Set(handle CGoHandle, val C.longlong) {
-	op := ptrFromHandle_linksocks_LogEntry(handle)
-	op.Time = int64(val)
+//export linksocks_TokenResponse_Port_Set
+func linksocks_TokenResponse_Port_Set(handle CGoHandle, val C.longlong) {
+	op := ptrFromHandle_linksocks_TokenResponse(handle)
+	op.Port = int(val)
 }
 
-// --- wrapping struct: linksocks.APIHandler ---
+//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_TokenResponse_Error_Set
+func linksocks_TokenResponse_Error_Set(handle CGoHandle, val *C.char) {
+	op := ptrFromHandle_linksocks_TokenResponse(handle)
+	op.Error = C.GoString(val)
+}
+
+// --- wrapping struct: linksocks.ReverseTokenStatus ---
 //
-//export linksocks_APIHandler_CTor
-func linksocks_APIHandler_CTor() CGoHandle {
-	return CGoHandle(handleFromPtr_linksocks_APIHandler(&linksocks.APIHandler{}))
+//export linksocks_ReverseTokenStatus_CTor
+func linksocks_ReverseTokenStatus_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_linksocks_ReverseTokenStatus(&linksocks.ReverseTokenStatus{}))
 }
 
-//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.APIHandler")
-	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))
-	}
+//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_ReverseTokenStatus_Port_Set
+func linksocks_ReverseTokenStatus_Port_Set(handle CGoHandle, val C.longlong) {
+	op := ptrFromHandle_linksocks_ReverseTokenStatus(handle)
+	op.Port = int(val)
+}
+
+//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_ReverseTokenStatus_ConnectorTokens_Set
+func linksocks_ReverseTokenStatus_ConnectorTokens_Set(handle CGoHandle, val CGoHandle) {
+	op := ptrFromHandle_linksocks_ReverseTokenStatus(handle)
+	op.ConnectorTokens = deptrFromHandle_Slice_string(val)
 }
 
 // --- wrapping struct: linksocks.ClientOption ---
@@ -7590,384 +7365,594 @@ func linksocks_ClientOption_WithUpstreamProxy(_handle CGoHandle, proxy *C.char)
 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")
+	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_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)))
+
+}
+
+// --- wrapping struct: linksocks.LogEntry ---
+//
+//export linksocks_LogEntry_CTor
+func linksocks_LogEntry_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_linksocks_LogEntry(&linksocks.LogEntry{}))
+}
+
+//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_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_LogEntry_Message_Get
+func linksocks_LogEntry_Message_Get(handle CGoHandle) *C.char {
+	op := ptrFromHandle_linksocks_LogEntry(handle)
+	return C.CString(op.Message)
+}
+
+//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_LogEntry_Time_Get
+func linksocks_LogEntry_Time_Get(handle CGoHandle) C.longlong {
+	op := ptrFromHandle_linksocks_LogEntry(handle)
+	return C.longlong(op.Time)
+}
+
+//export linksocks_LogEntry_Time_Set
+func linksocks_LogEntry_Time_Set(handle CGoHandle, val C.longlong) {
+	op := ptrFromHandle_linksocks_LogEntry(handle)
+	op.Time = int64(val)
+}
+
+// --- wrapping struct: linksocks.RelayOption ---
+//
+//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_RelayOption_UpstreamUsername_Get
+func linksocks_RelayOption_UpstreamUsername_Get(handle CGoHandle) *C.char {
+	op := ptrFromHandle_linksocks_RelayOption(handle)
+	return C.CString(op.UpstreamUsername)
+}
+
+//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_RelayOption_UpstreamPassword_Get
+func linksocks_RelayOption_UpstreamPassword_Get(handle CGoHandle) *C.char {
+	op := ptrFromHandle_linksocks_RelayOption(handle)
+	return C.CString(op.UpstreamPassword)
+}
+
+//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_RelayOption_EnableDynamicBatching_Get
+func linksocks_RelayOption_EnableDynamicBatching_Get(handle CGoHandle) C.char {
+	op := ptrFromHandle_linksocks_RelayOption(handle)
+	return boolGoToPy(op.EnableDynamicBatching)
+}
+
+//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_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_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_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_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_RelayOption_HighSpeedThreshold_Get
+func linksocks_RelayOption_HighSpeedThreshold_Get(handle CGoHandle) C.double {
+	op := ptrFromHandle_linksocks_RelayOption(handle)
+	return C.double(op.HighSpeedThreshold)
+}
+
+//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_RelayOption_LowSpeedThreshold_Get
+func linksocks_RelayOption_LowSpeedThreshold_Get(handle CGoHandle) C.double {
+	op := ptrFromHandle_linksocks_RelayOption(handle)
+	return C.double(op.LowSpeedThreshold)
+}
+
+//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_RelayOption_CompressionThreshold_Get
+func linksocks_RelayOption_CompressionThreshold_Get(handle CGoHandle) C.longlong {
+	op := ptrFromHandle_linksocks_RelayOption(handle)
+	return C.longlong(op.CompressionThreshold)
+}
+
+//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_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_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_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_ClientOption(nil)
+		return handleFromPtr_Ptr_linksocks_RelayOption(nil)
 	}
-	return handleFromPtr_Ptr_linksocks_ClientOption(gopyh.Embed(vifc, reflect.TypeOf(linksocks.ClientOption{})).(*linksocks.ClientOption).WithUpstreamAuth(C.GoString(username), C.GoString(password)))
+	return handleFromPtr_Ptr_linksocks_RelayOption(gopyh.Embed(vifc, reflect.TypeOf(linksocks.RelayOption{})).(*linksocks.RelayOption).WithConnectTimeout(time.Duration(int64(timeout))))
 
 }
 
-//export linksocks_ClientOption_WithNoEnvProxy
-func linksocks_ClientOption_WithNoEnvProxy(_handle CGoHandle, noEnvProxy C.char) CGoHandle {
+//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.ClientOption")
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.RelayOption")
 	if __err != nil {
-		return handleFromPtr_Ptr_linksocks_ClientOption(nil)
+		return handleFromPtr_Ptr_linksocks_RelayOption(nil)
 	}
-	return handleFromPtr_Ptr_linksocks_ClientOption(gopyh.Embed(vifc, reflect.TypeOf(linksocks.ClientOption{})).(*linksocks.ClientOption).WithNoEnvProxy(boolPyToGo(noEnvProxy)))
-
-}
-
-// --- wrapping struct: linksocks.DisconnectMessage ---
-//
-//export linksocks_DisconnectMessage_CTor
-func linksocks_DisconnectMessage_CTor() CGoHandle {
-	return CGoHandle(handleFromPtr_linksocks_DisconnectMessage(&linksocks.DisconnectMessage{}))
-}
-
-//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_DisconnectMessage_Error_Get
-func linksocks_DisconnectMessage_Error_Get(handle CGoHandle) *C.char {
-	op := ptrFromHandle_linksocks_DisconnectMessage(handle)
-	return C.CString(op.Error)
-}
+	return handleFromPtr_Ptr_linksocks_RelayOption(gopyh.Embed(vifc, reflect.TypeOf(linksocks.RelayOption{})).(*linksocks.RelayOption).WithFastOpen(boolPyToGo(fastOpen)))
 
-//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 {
+//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.DisconnectMessage")
+	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.DisconnectMessage{})).(*linksocks.DisconnectMessage).GetType())
-
-}
+	return handleFromPtr_Ptr_linksocks_RelayOption(gopyh.Embed(vifc, reflect.TypeOf(linksocks.RelayOption{})).(*linksocks.RelayOption).WithUpstreamProxy(C.GoString(proxy)))
 
-// --- wrapping struct: linksocks.DynamicForwarder ---
-//
-//export linksocks_DynamicForwarder_CTor
-func linksocks_DynamicForwarder_CTor() CGoHandle {
-	return CGoHandle(handleFromPtr_linksocks_DynamicForwarder(&linksocks.DynamicForwarder{}))
 }
 
-//export linksocks_DynamicForwarder_ProcessReads
-func linksocks_DynamicForwarder_ProcessReads(_handle CGoHandle, conn CGoHandle, goRun 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.DynamicForwarder")
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.RelayOption")
 	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))
+		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)))
+
 }
 
-//export linksocks_DynamicForwarder_ProcessReadsImmediate
-func linksocks_DynamicForwarder_ProcessReadsImmediate(_handle CGoHandle, conn 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.DynamicForwarder")
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.RelayOption")
 	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))
+		return handleFromPtr_Ptr_linksocks_RelayOption(nil)
 	}
+	return handleFromPtr_Ptr_linksocks_RelayOption(gopyh.Embed(vifc, reflect.TypeOf(linksocks.RelayOption{})).(*linksocks.RelayOption).WithDynamicBatching(boolPyToGo(enabled)))
+
 }
 
-//export linksocks_DynamicForwarder_ProcessUDPReads
-func linksocks_DynamicForwarder_ProcessUDPReads(_handle CGoHandle, conn CGoHandle, goRun C.char) {
+//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.DynamicForwarder")
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.RelayOption")
 	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))
+		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))))
 
-// --- 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 {
+//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.SocketManager")
+	defer C.PyEval_RestoreThread(_saved_thread)
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.RelayOption")
 	if __err != nil {
-		return handleFromPtr_net_Listener(nil)
+		return handleFromPtr_Ptr_linksocks_RelayOption(nil)
 	}
-	cret, __err := gopyh.Embed(vifc, reflect.TypeOf(linksocks.SocketManager{})).(*linksocks.SocketManager).GetListener(int(port))
+	return handleFromPtr_Ptr_linksocks_RelayOption(gopyh.Embed(vifc, reflect.TypeOf(linksocks.RelayOption{})).(*linksocks.RelayOption).WithHighSpeedThreshold(float64(threshold)))
 
-	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_SocketManager_ReleaseListener
-func linksocks_SocketManager_ReleaseListener(_handle CGoHandle, port C.longlong, goRun C.char) {
+//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.SocketManager")
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.RelayOption")
 	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))
+		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_SocketManager_Close
-func linksocks_SocketManager_Close(_handle CGoHandle, goRun C.char) {
+//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.SocketManager")
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.RelayOption")
 	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()
+		return handleFromPtr_Ptr_linksocks_RelayOption(nil)
 	}
-}
-
-// --- wrapping struct: linksocks.TokenResponse ---
-//
-//export linksocks_TokenResponse_CTor
-func linksocks_TokenResponse_CTor() CGoHandle {
-	return CGoHandle(handleFromPtr_linksocks_TokenResponse(&linksocks.TokenResponse{}))
-}
+	return handleFromPtr_Ptr_linksocks_RelayOption(gopyh.Embed(vifc, reflect.TypeOf(linksocks.RelayOption{})).(*linksocks.RelayOption).WithCompressionThreshold(int(threshold)))
 
-//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_TokenResponse_Success_Set
-func linksocks_TokenResponse_Success_Set(handle CGoHandle, val C.char) {
-	op := ptrFromHandle_linksocks_TokenResponse(handle)
-	op.Success = boolPyToGo(val)
+// --- wrapping struct: linksocks.ReverseTokenOptions ---
+//
+//export linksocks_ReverseTokenOptions_CTor
+func linksocks_ReverseTokenOptions_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_linksocks_ReverseTokenOptions(&linksocks.ReverseTokenOptions{}))
 }
 
-//export linksocks_TokenResponse_Token_Get
-func linksocks_TokenResponse_Token_Get(handle CGoHandle) *C.char {
-	op := ptrFromHandle_linksocks_TokenResponse(handle)
+//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_TokenResponse_Token_Set
-func linksocks_TokenResponse_Token_Set(handle CGoHandle, val *C.char) {
-	op := ptrFromHandle_linksocks_TokenResponse(handle)
+//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_TokenResponse_Port_Get
-func linksocks_TokenResponse_Port_Get(handle CGoHandle) C.longlong {
-	op := ptrFromHandle_linksocks_TokenResponse(handle)
+//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_TokenResponse_Port_Set
-func linksocks_TokenResponse_Port_Set(handle CGoHandle, val C.longlong) {
-	op := ptrFromHandle_linksocks_TokenResponse(handle)
+//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_TokenResponse_Error_Get
-func linksocks_TokenResponse_Error_Get(handle CGoHandle) *C.char {
-	op := ptrFromHandle_linksocks_TokenResponse(handle)
-	return C.CString(op.Error)
+//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_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_ReverseTokenOptions_Username_Set
+func linksocks_ReverseTokenOptions_Username_Set(handle CGoHandle, val *C.char) {
+	op := ptrFromHandle_linksocks_ReverseTokenOptions(handle)
+	op.Username = C.GoString(val)
 }
 
-// --- wrapping struct: linksocks.ConnectorResponseMessage ---
+//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_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_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.ConnectMessage ---
 //
-//export linksocks_ConnectorResponseMessage_CTor
-func linksocks_ConnectorResponseMessage_CTor() CGoHandle {
-	return CGoHandle(handleFromPtr_linksocks_ConnectorResponseMessage(&linksocks.ConnectorResponseMessage{}))
+//export linksocks_ConnectMessage_CTor
+func linksocks_ConnectMessage_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_linksocks_ConnectMessage(&linksocks.ConnectMessage{}))
 }
 
-//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_ConnectMessage_Protocol_Get
+func linksocks_ConnectMessage_Protocol_Get(handle CGoHandle) *C.char {
+	op := ptrFromHandle_linksocks_ConnectMessage(handle)
+	return C.CString(op.Protocol)
 }
 
-//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_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_ConnectorResponseMessage_Error_Get
-func linksocks_ConnectorResponseMessage_Error_Get(handle CGoHandle) *C.char {
-	op := ptrFromHandle_linksocks_ConnectorResponseMessage(handle)
-	return C.CString(op.Error)
+//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_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_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_ConnectorResponseMessage_ChannelID_Get
-func linksocks_ConnectorResponseMessage_ChannelID_Get(handle CGoHandle) CGoHandle {
-	op := ptrFromHandle_linksocks_ConnectorResponseMessage(handle)
-	return handleFromPtr_uuid_UUID(&op.ChannelID)
+//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_ConnectorResponseMessage_ConnectorToken_Get
-func linksocks_ConnectorResponseMessage_ConnectorToken_Get(handle CGoHandle) *C.char {
-	op := ptrFromHandle_linksocks_ConnectorResponseMessage(handle)
-	return C.CString(op.ConnectorToken)
+//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_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_ConnectMessage_ChannelID_Get
+func linksocks_ConnectMessage_ChannelID_Get(handle CGoHandle) CGoHandle {
+	op := ptrFromHandle_linksocks_ConnectMessage(handle)
+	return handleFromPtr_uuid_UUID(&op.ChannelID)
 }
 
-//export linksocks_ConnectorResponseMessage_GetType
-func linksocks_ConnectorResponseMessage_GetType(_handle CGoHandle) *C.char {
+//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.ConnectorResponseMessage")
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.ConnectMessage")
 	if __err != nil {
 		return C.CString("")
 	}
-	return C.CString(gopyh.Embed(vifc, reflect.TypeOf(linksocks.ConnectorResponseMessage{})).(*linksocks.ConnectorResponseMessage).GetType())
+	return C.CString(gopyh.Embed(vifc, reflect.TypeOf(linksocks.ConnectMessage{})).(*linksocks.ConnectMessage).GetType())
 
 }
 
-// --- wrapping struct: linksocks.LinkSocksClient ---
+// --- wrapping struct: linksocks.LinkSocksServer ---
 //
-//export linksocks_LinkSocksClient_CTor
-func linksocks_LinkSocksClient_CTor() CGoHandle {
-	return CGoHandle(handleFromPtr_linksocks_LinkSocksClient(&linksocks.LinkSocksClient{}))
+//export linksocks_LinkSocksServer_CTor
+func linksocks_LinkSocksServer_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_linksocks_LinkSocksServer(&linksocks.LinkSocksServer{}))
 }
 
-//export linksocks_LinkSocksClient_IsConnected_Get
-func linksocks_LinkSocksClient_IsConnected_Get(handle CGoHandle) C.char {
-	op := ptrFromHandle_linksocks_LinkSocksClient(handle)
-	return boolGoToPy(op.IsConnected)
-}
+//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_LinkSocksClient_IsConnected_Set
-func linksocks_LinkSocksClient_IsConnected_Set(handle CGoHandle, val C.char) {
-	op := ptrFromHandle_linksocks_LinkSocksClient(handle)
-	op.IsConnected = 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_LinkSocksClient_WaitReady
-func linksocks_LinkSocksClient_WaitReady(_handle CGoHandle, ctx CGoHandle, timeout C.longlong) *C.char {
+//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.LinkSocksClient")
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.LinkSocksServer")
 	if __err != nil {
-		return errorGoToPy(nil)
+		return C.CString("")
 	}
-	__err = gopyh.Embed(vifc, reflect.TypeOf(linksocks.LinkSocksClient{})).(*linksocks.LinkSocksClient).WaitReady(ptrFromHandle_context_Context(ctx), time.Duration(int64(timeout)))
+	cret, __err := gopyh.Embed(vifc, reflect.TypeOf(linksocks.LinkSocksServer{})).(*linksocks.LinkSocksServer).AddForwardToken(C.GoString(token))
 
 	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 C.CString("")
 	}
-	return C.CString("")
+	return C.CString(cret)
 }
 
-//export linksocks_LinkSocksClient_Connect
-func linksocks_LinkSocksClient_Connect(_handle CGoHandle, ctx CGoHandle) *C.char {
+//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.LinkSocksClient")
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.LinkSocksServer")
 	if __err != nil {
-		return errorGoToPy(nil)
+		return C.CString("")
 	}
-	__err = gopyh.Embed(vifc, reflect.TypeOf(linksocks.LinkSocksClient{})).(*linksocks.LinkSocksClient).Connect(ptrFromHandle_context_Context(ctx))
+	cret, __err := gopyh.Embed(vifc, reflect.TypeOf(linksocks.LinkSocksServer{})).(*linksocks.LinkSocksServer).AddConnectorToken(C.GoString(connectorToken), C.GoString(reverseToken))
 
 	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 C.CString("")
 	}
-	return C.CString("")
+	return C.CString(cret)
 }
 
-//export linksocks_LinkSocksClient_Close
-func linksocks_LinkSocksClient_Close(_handle CGoHandle, goRun C.char) {
+//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.LinkSocksClient")
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.LinkSocksServer")
 	if __err != nil {
-		return
-	}
-	if boolPyToGo(goRun) {
-		go gopyh.Embed(vifc, reflect.TypeOf(linksocks.LinkSocksClient{})).(*linksocks.LinkSocksClient).Close()
-	} else {
-		gopyh.Embed(vifc, reflect.TypeOf(linksocks.LinkSocksClient{})).(*linksocks.LinkSocksClient).Close()
+		return boolGoToPy(false)
 	}
+	return boolGoToPy(gopyh.Embed(vifc, reflect.TypeOf(linksocks.LinkSocksServer{})).(*linksocks.LinkSocksServer).RemoveToken(C.GoString(token)))
+
 }
 
-//export linksocks_LinkSocksClient_AddConnector
-func linksocks_LinkSocksClient_AddConnector(_handle CGoHandle, connectorToken *C.char) *C.char {
+//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.LinkSocksClient")
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.LinkSocksServer")
 	if __err != nil {
-		return C.CString("")
+		return errorGoToPy(nil)
 	}
-	cret, __err := gopyh.Embed(vifc, reflect.TypeOf(linksocks.LinkSocksClient{})).(*linksocks.LinkSocksClient).AddConnector(C.GoString(connectorToken))
+	__err = gopyh.Embed(vifc, reflect.TypeOf(linksocks.LinkSocksServer{})).(*linksocks.LinkSocksServer).Serve(ptrFromHandle_context_Context(ctx))
 
 	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 estr
 	}
-	return C.CString(cret)
+	return C.CString("")
 }
 
-//export linksocks_LinkSocksClient_RemoveConnector
-func linksocks_LinkSocksClient_RemoveConnector(_handle CGoHandle, connectorToken *C.char) *C.char {
+//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.LinkSocksClient")
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.LinkSocksServer")
 	if __err != nil {
 		return errorGoToPy(nil)
 	}
-	__err = gopyh.Embed(vifc, reflect.TypeOf(linksocks.LinkSocksClient{})).(*linksocks.LinkSocksClient).RemoveConnector(C.GoString(connectorToken))
+	__err = gopyh.Embed(vifc, reflect.TypeOf(linksocks.LinkSocksServer{})).(*linksocks.LinkSocksServer).WaitReady(ptrFromHandle_context_Context(ctx), time.Duration(int64(timeout)))
 
 	C.PyEval_RestoreThread(_saved_thread)
 	if __err != nil {
@@ -7978,96 +7963,111 @@ func linksocks_LinkSocksClient_RemoveConnector(_handle CGoHandle, connectorToken
 	return C.CString("")
 }
 
-//export linksocks_LinkSocksClient_GetPartnersCount
-func linksocks_LinkSocksClient_GetPartnersCount(_handle CGoHandle) C.longlong {
+//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.LinkSocksClient")
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.LinkSocksServer")
 	if __err != nil {
-		return C.longlong(0)
+		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 C.longlong(gopyh.Embed(vifc, reflect.TypeOf(linksocks.LinkSocksClient{})).(*linksocks.LinkSocksClient).GetPartnersCount())
-
-}
-
-// --- wrapping struct: linksocks.PartnersMessage ---
-//
-//export linksocks_PartnersMessage_CTor
-func linksocks_PartnersMessage_CTor() CGoHandle {
-	return CGoHandle(handleFromPtr_linksocks_PartnersMessage(&linksocks.PartnersMessage{}))
 }
 
-//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_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)
+	}
+	return C.longlong(gopyh.Embed(vifc, reflect.TypeOf(linksocks.LinkSocksServer{})).(*linksocks.LinkSocksServer).GetClientCount())
 
-//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 {
+//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.PartnersMessage")
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.LinkSocksServer")
 	if __err != nil {
-		return C.CString("")
+		return boolGoToPy(false)
 	}
-	return C.CString(gopyh.Embed(vifc, reflect.TypeOf(linksocks.PartnersMessage{})).(*linksocks.PartnersMessage).GetType())
-
-}
+	return boolGoToPy(gopyh.Embed(vifc, reflect.TypeOf(linksocks.LinkSocksServer{})).(*linksocks.LinkSocksServer).HasClients())
 
-// --- 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_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.LinkSocksServer")
+	if __err != nil {
+		return C.longlong(0)
+	}
+	return C.longlong(gopyh.Embed(vifc, reflect.TypeOf(linksocks.LinkSocksServer{})).(*linksocks.LinkSocksServer).GetTokenClientCount(C.GoString(token)))
 
-//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)
+// --- wrapping struct: linksocks.SocketManager ---
+//
+//export linksocks_SocketManager_CTor
+func linksocks_SocketManager_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_linksocks_SocketManager(&linksocks.SocketManager{}))
 }
 
-//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_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))
 
-//export linksocks_ConnectResponseMessage_ChannelID_Get
-func linksocks_ConnectResponseMessage_ChannelID_Get(handle CGoHandle) CGoHandle {
-	op := ptrFromHandle_linksocks_ConnectResponseMessage(handle)
-	return handleFromPtr_uuid_UUID(&op.ChannelID)
+	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_ConnectResponseMessage_GetType
-func linksocks_ConnectResponseMessage_GetType(_handle CGoHandle) *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.ConnectResponseMessage")
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*linksocks.SocketManager")
 	if __err != nil {
-		return C.CString("")
+		return
 	}
-	return C.CString(gopyh.Embed(vifc, reflect.TypeOf(linksocks.ConnectResponseMessage{})).(*linksocks.ConnectResponseMessage).GetType())
+	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_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()
+	}
 }
 
 // ---- Slices ---
@@ -8076,14 +8076,6 @@ func linksocks_ConnectResponseMessage_GetType(_handle CGoHandle) *C.char {
 
 // ---- Constructors ---
 
-//export linksocks_DefaultReverseTokenOptions
-func linksocks_DefaultReverseTokenOptions() CGoHandle {
-	_saved_thread := C.PyEval_SaveThread()
-	defer C.PyEval_RestoreThread(_saved_thread)
-	return handleFromPtr_Ptr_linksocks_ReverseTokenOptions(linksocks.DefaultReverseTokenOptions())
-
-}
-
 //export linksocks_DefaultServerOption
 func linksocks_DefaultServerOption() CGoHandle {
 	_saved_thread := C.PyEval_SaveThread()
@@ -8092,19 +8084,11 @@ func linksocks_DefaultServerOption() 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_WSConn(linksocks.NewWSConn(ptrFromHandle_Ptr_websocket_Conn(conn), C.GoString(label), *ptrFromHandle_zerolog_Logger(logger)))
-
-}
-
-//export linksocks_NewContextWithCancel
-func linksocks_NewContextWithCancel() 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_ContextWithCancel(linksocks.NewContextWithCancel())
+	return handleFromPtr_Ptr_linksocks_PortPool(linksocks.NewPortPoolFromRange(int(start), int(end)))
 
 }
 
@@ -8116,14 +8100,6 @@ func linksocks_NewPortPool(ports 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_PortPool(linksocks.NewPortPoolFromRange(int(start), int(end)))
-
-}
-
 //export linksocks_NewRelay
 func linksocks_NewRelay(logger CGoHandle, option CGoHandle) CGoHandle {
 	_saved_thread := C.PyEval_SaveThread()
@@ -8132,27 +8108,27 @@ func linksocks_NewRelay(logger CGoHandle, option CGoHandle) CGoHandle {
 
 }
 
-//export linksocks_NewDefaultRelayOption
-func linksocks_NewDefaultRelayOption() 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_RelayOption(linksocks.NewDefaultRelayOption())
+	return handleFromPtr_Ptr_linksocks_WSConn(linksocks.NewWSConn(ptrFromHandle_Ptr_websocket_Conn(conn), C.GoString(label), *ptrFromHandle_zerolog_Logger(logger)))
 
 }
 
-//export linksocks_NewLinkSocksServer
-func linksocks_NewLinkSocksServer(opt CGoHandle) CGoHandle {
+//export linksocks_NewCLI
+func linksocks_NewCLI() 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_CLI(linksocks.NewCLI())
 
 }
 
-//export linksocks_NewCLI
-func linksocks_NewCLI() CGoHandle {
+//export linksocks_NewLinkSocksClient
+func linksocks_NewLinkSocksClient(token *C.char, opt CGoHandle) CGoHandle {
 	_saved_thread := C.PyEval_SaveThread()
 	defer C.PyEval_RestoreThread(_saved_thread)
-	return handleFromPtr_Ptr_linksocks_CLI(linksocks.NewCLI())
+	return handleFromPtr_Ptr_linksocks_LinkSocksClient(linksocks.NewLinkSocksClient(C.GoString(token), ptrFromHandle_Ptr_linksocks_ClientOption(opt)))
 
 }
 
@@ -8164,6 +8140,14 @@ func linksocks_NewAPIHandler(server CGoHandle, apiKey *C.char) CGoHandle {
 
 }
 
+//export linksocks_NewContextWithCancel
+func linksocks_NewContextWithCancel() CGoHandle {
+	_saved_thread := C.PyEval_SaveThread()
+	defer C.PyEval_RestoreThread(_saved_thread)
+	return handleFromPtr_Ptr_linksocks_ContextWithCancel(linksocks.NewContextWithCancel())
+
+}
+
 //export linksocks_DefaultClientOption
 func linksocks_DefaultClientOption() CGoHandle {
 	_saved_thread := C.PyEval_SaveThread()
@@ -8172,53 +8156,100 @@ func linksocks_DefaultClientOption() CGoHandle {
 
 }
 
-//export linksocks_NewSocketManager
-func linksocks_NewSocketManager(host *C.char, log CGoHandle) CGoHandle {
+//export linksocks_NewDefaultRelayOption
+func linksocks_NewDefaultRelayOption() 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)))
+	return handleFromPtr_Ptr_linksocks_RelayOption(linksocks.NewDefaultRelayOption())
 
 }
 
-//export linksocks_NewLinkSocksClient
-func linksocks_NewLinkSocksClient(token *C.char, opt CGoHandle) CGoHandle {
+//export linksocks_DefaultReverseTokenOptions
+func linksocks_DefaultReverseTokenOptions() CGoHandle {
 	_saved_thread := C.PyEval_SaveThread()
 	defer C.PyEval_RestoreThread(_saved_thread)
-	return handleFromPtr_Ptr_linksocks_LinkSocksClient(linksocks.NewLinkSocksClient(C.GoString(token), ptrFromHandle_Ptr_linksocks_ClientOption(opt)))
+	return handleFromPtr_Ptr_linksocks_ReverseTokenOptions(linksocks.DefaultReverseTokenOptions())
 
 }
 
-// ---- Functions ---
+//export linksocks_NewLinkSocksServer
+func linksocks_NewLinkSocksServer(opt CGoHandle) CGoHandle {
+	_saved_thread := C.PyEval_SaveThread()
+	defer C.PyEval_RestoreThread(_saved_thread)
+	return handleFromPtr_Ptr_linksocks_LinkSocksServer(linksocks.NewLinkSocksServer(ptrFromHandle_Ptr_linksocks_ServerOption(opt)))
 
-//export linksocks_GetLogEntries
-func linksocks_GetLogEntries() CGoHandle {
+}
+
+//export linksocks_NewSocketManager
+func linksocks_NewSocketManager(host *C.char, log CGoHandle) CGoHandle {
 	_saved_thread := C.PyEval_SaveThread()
 	defer C.PyEval_RestoreThread(_saved_thread)
-	cret := linksocks.GetLogEntries()
+	return handleFromPtr_Ptr_linksocks_SocketManager(linksocks.NewSocketManager(C.GoString(host), *ptrFromHandle_zerolog_Logger(log)))
 
-	return handleFromPtr_Slice_linksocks_LogEntry(&cret)
 }
 
-//export linksocks_SetLoggerGlobalLevel
-func linksocks_SetLoggerGlobalLevel(level C.char, goRun C.char) {
+// ---- Functions ---
+
+//export linksocks_CancelLogWaiters
+func linksocks_CancelLogWaiters(goRun C.char) {
 	_saved_thread := C.PyEval_SaveThread()
 	defer C.PyEval_RestoreThread(_saved_thread)
 	if boolPyToGo(goRun) {
-		go linksocks.SetLoggerGlobalLevel(zerolog.Level(int8(level)))
+		go linksocks.CancelLogWaiters()
 	} else {
-		linksocks.SetLoggerGlobalLevel(zerolog.Level(int8(level)))
+		linksocks.CancelLogWaiters()
 	}
 }
 
-//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_WaitForLogEntries
+func linksocks_WaitForLogEntries(timeoutMs C.longlong) CGoHandle {
 	_saved_thread := C.PyEval_SaveThread()
 	defer C.PyEval_RestoreThread(_saved_thread)
-	cret := linksocks.NewLoggerWithID(C.GoString(id))
+	cret := linksocks.WaitForLogEntries(int64(timeoutMs))
+
+	return handleFromPtr_Slice_linksocks_LogEntry(&cret)
+}
+
+//export linksocks_NewContext
+func linksocks_NewContext() CGoHandle {
+	_saved_thread := C.PyEval_SaveThread()
+	defer C.PyEval_RestoreThread(_saved_thread)
+	return handleFromPtr_context_Context(linksocks.NewContext())
+
+}
+
+//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_Background
+func linksocks_Background() CGoHandle {
+	_saved_thread := C.PyEval_SaveThread()
+	defer C.PyEval_RestoreThread(_saved_thread)
+	return handleFromPtr_context_Context(linksocks.Background())
+
+}
+
 //export linksocks_DebugLog
 func linksocks_DebugLog(logger CGoHandle, msg *C.char, goRun C.char) {
 	_saved_thread := C.PyEval_SaveThread()
@@ -8230,21 +8261,21 @@ func linksocks_DebugLog(logger CGoHandle, msg *C.char, goRun C.char) {
 	}
 }
 
-//export linksocks_NewLoggerWithIDAndLevel
-func linksocks_NewLoggerWithIDAndLevel(id *C.char, level C.char) CGoHandle {
+//export linksocks_GetLogEntries
+func linksocks_GetLogEntries() CGoHandle {
 	_saved_thread := C.PyEval_SaveThread()
 	defer C.PyEval_RestoreThread(_saved_thread)
-	cret := linksocks.NewLoggerWithIDAndLevel(C.GoString(id), zerolog.Level(int8(level)))
+	cret := linksocks.GetLogEntries()
 
-	return handleFromPtr_zerolog_Logger(&cret)
+	return handleFromPtr_Slice_linksocks_LogEntry(&cret)
 }
 
-//export linksocks_NewLoggerWithLevel
-func linksocks_NewLoggerWithLevel(level C.char, cb *C.PyObject) 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.NewLoggerWithLevel(zerolog.Level(int8(level)), func(line string) {
+	cret := linksocks.NewLogger(func(line string) {
 		if C.PyCallable_Check(_fun_arg) == 0 {
 			return
 		}
@@ -8260,14 +8291,6 @@ func linksocks_NewLoggerWithLevel(level C.char, cb *C.PyObject) CGoHandle {
 	return handleFromPtr_zerolog_Logger(&cret)
 }
 
-//export linksocks_Background
-func linksocks_Background() CGoHandle {
-	_saved_thread := C.PyEval_SaveThread()
-	defer C.PyEval_RestoreThread(_saved_thread)
-	return handleFromPtr_context_Context(linksocks.Background())
-
-}
-
 //export linksocks_CancelGlobalContext
 func linksocks_CancelGlobalContext(goRun C.char) {
 	_saved_thread := C.PyEval_SaveThread()
@@ -8279,12 +8302,21 @@ func linksocks_CancelGlobalContext(goRun C.char) {
 	}
 }
 
-//export linksocks_NewLogger
-func linksocks_NewLogger(cb *C.PyObject) CGoHandle {
+//export linksocks_NewLoggerWithID
+func linksocks_NewLoggerWithID(id *C.char) CGoHandle {
+	_saved_thread := C.PyEval_SaveThread()
+	defer C.PyEval_RestoreThread(_saved_thread)
+	cret := linksocks.NewLoggerWithID(C.GoString(id))
+
+	return handleFromPtr_zerolog_Logger(&cret)
+}
+
+//export linksocks_NewLoggerWithLevel
+func linksocks_NewLoggerWithLevel(level C.char, cb *C.PyObject) CGoHandle {
 	_fun_arg := cb
 	_saved_thread := C.PyEval_SaveThread()
 	defer C.PyEval_RestoreThread(_saved_thread)
-	cret := linksocks.NewLogger(func(line string) {
+	cret := linksocks.NewLoggerWithLevel(zerolog.Level(int8(level)), func(line string) {
 		if C.PyCallable_Check(_fun_arg) == 0 {
 			return
 		}
@@ -8300,47 +8332,15 @@ func linksocks_NewLogger(cb *C.PyObject) CGoHandle {
 	return handleFromPtr_zerolog_Logger(&cret)
 }
 
-//export linksocks_CancelLogWaiters
-func linksocks_CancelLogWaiters(goRun C.char) {
+//export linksocks_SetLoggerGlobalLevel
+func linksocks_SetLoggerGlobalLevel(level C.char, goRun C.char) {
 	_saved_thread := C.PyEval_SaveThread()
 	defer C.PyEval_RestoreThread(_saved_thread)
 	if boolPyToGo(goRun) {
-		go linksocks.CancelLogWaiters()
+		go linksocks.SetLoggerGlobalLevel(zerolog.Level(int8(level)))
 	} else {
-		linksocks.CancelLogWaiters()
-	}
-}
-
-//export linksocks_NewContext
-func linksocks_NewContext() CGoHandle {
-	_saved_thread := C.PyEval_SaveThread()
-	defer C.PyEval_RestoreThread(_saved_thread)
-	return handleFromPtr_context_Context(linksocks.NewContext())
-
-}
-
-//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)
+		linksocks.SetLoggerGlobalLevel(zerolog.Level(int8(level)))
 	}
-	return handleFromPtr_Slice_byte(&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_ParseDuration