linksocks 3.0.12__cp311-cp311-win_amd64.whl → 3.0.13__cp311-cp311-win_amd64.whl

linksockslib/linksocks.py

@@ -2,7 +2,7 @@
 # python wrapper for package github.com/linksocks/linksocks/linksocks_go within overall package linksockslib
 # This is what you import to use the package.
 # File is generated by gopy. Do not edit.
-# gopy.EXE build -vm=C:\Users\RUNNER~1\AppData\Local\Temp\linksocks_pyvenv_zqf2yhv2\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_5sgky1ki\venv\Scripts\python.exe -output=D:\a\linksocks\linksocks\_bindings\python\linksockslib -name=linksockslib -no-make=true ./linksocks_go
 
 # the following is required to enable dlopen to open the _go.so file
 import os,sys,inspect,collections
@@ -2548,9 +2548,9 @@ class BaseMessage(go.GoClass):
 
 # ---- Structs ---
 
-# Python type for struct linksocks.ConnectResponseMessage
-class ConnectResponseMessage(go.GoClass):
-	"""ConnectResponseMessage represents a connection response\n"""
+# Python type for struct linksocks.LinkSocksClient
+class LinkSocksClient(go.GoClass):
+	"""LinkSocksClient represents a SOCKS5 over WebSocket protocol client\n"""
 	def __init__(self, *args, **kwargs):
 		"""
 		handle=A Go-side object is always initialized with an explicit handle=arg
@@ -2564,25 +2564,17 @@ class ConnectResponseMessage(go.GoClass):
 			self.handle = args[0].handle
 			_linksockslib.IncRef(self.handle)
 		else:
-			self.handle = _linksockslib.linksocks_ConnectResponseMessage_CTor()
+			self.handle = _linksockslib.linksocks_LinkSocksClient_CTor()
 			_linksockslib.IncRef(self.handle)
-			if  0 < len(args):
-				self.Success = args[0]
-			if "Success" in kwargs:
-				self.Success = kwargs["Success"]
-			if  1 < len(args):
-				self.Error = args[1]
-			if "Error" in kwargs:
-				self.Error = kwargs["Error"]
 			if  2 < len(args):
-				self.ChannelID = args[2]
-			if "ChannelID" in kwargs:
-				self.ChannelID = kwargs["ChannelID"]
+				self.IsConnected = args[2]
+			if "IsConnected" in kwargs:
+				self.IsConnected = kwargs["IsConnected"]
 	def __del__(self):
 		_linksockslib.DecRef(self.handle)
 	def __str__(self):
 		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
-		sv = 'linksocks.ConnectResponseMessage{'
+		sv = 'linksocks.LinkSocksClient{'
 		first = True
 		for v in pr:
 			if callable(v[1]):
@@ -2595,39 +2587,62 @@ class ConnectResponseMessage(go.GoClass):
 		return sv + '}'
 	def __repr__(self):
 		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
-		sv = 'linksocks.ConnectResponseMessage ( '
+		sv = 'linksocks.LinkSocksClient ( '
 		for v in pr:
 			if not callable(v[1]):
 				sv += v[0] + '=' + str(v[1]) + ', '
 		return sv + ')'
 	@property
-	def Success(self):
-		return _linksockslib.linksocks_ConnectResponseMessage_Success_Get(self.handle)
-	@Success.setter
-	def Success(self, value):
-		if isinstance(value, go.GoClass):
-			_linksockslib.linksocks_ConnectResponseMessage_Success_Set(self.handle, value.handle)
-		else:
-			_linksockslib.linksocks_ConnectResponseMessage_Success_Set(self.handle, value)
-	@property
-	def Error(self):
-		return _linksockslib.linksocks_ConnectResponseMessage_Error_Get(self.handle)
-	@Error.setter
-	def Error(self, value):
+	def IsConnected(self):
+		return _linksockslib.linksocks_LinkSocksClient_IsConnected_Get(self.handle)
+	@IsConnected.setter
+	def IsConnected(self, value):
 		if isinstance(value, go.GoClass):
-			_linksockslib.linksocks_ConnectResponseMessage_Error_Set(self.handle, value.handle)
+			_linksockslib.linksocks_LinkSocksClient_IsConnected_Set(self.handle, value.handle)
 		else:
-			_linksockslib.linksocks_ConnectResponseMessage_Error_Set(self.handle, value)
-	@property
-	def ChannelID(self):
-		return go.uuid_UUID(handle=_linksockslib.linksocks_ConnectResponseMessage_ChannelID_Get(self.handle))
-	def GetType(self):
-		"""GetType() str"""
-		return _linksockslib.linksocks_ConnectResponseMessage_GetType(self.handle)
+			_linksockslib.linksocks_LinkSocksClient_IsConnected_Set(self.handle, value)
+	def WaitReady(self, ctx, timeout):
+		"""WaitReady(object ctx, long timeout) str
+		
+		WaitReady start the client and waits for the client to be ready with optional timeout
+		"""
+		return _linksockslib.linksocks_LinkSocksClient_WaitReady(self.handle, ctx.handle, timeout)
+	def Connect(self, ctx):
+		"""Connect(object ctx) str
+		
+		Connect starts the client operation
+		"""
+		return _linksockslib.linksocks_LinkSocksClient_Connect(self.handle, ctx.handle)
+	def Close(self, goRun=False):
+		"""Close() 
+		
+		Close gracefully shuts down the LinkSocksClient
+		"""
+		_linksockslib.linksocks_LinkSocksClient_Close(self.handle, goRun)
+	def AddConnector(self, connectorToken):
+		"""AddConnector(str connectorToken) str, str
+		
+		AddConnector sends a request to add a new connector token and waits for response.
+		This function is only available in reverse proxy mode.
+		"""
+		return _linksockslib.linksocks_LinkSocksClient_AddConnector(self.handle, connectorToken)
+	def RemoveConnector(self, connectorToken):
+		"""RemoveConnector(str connectorToken) str
+		
+		RemoveConnector sends a request to remove a connector token and waits for response.
+		This function is only available in reverse proxy mode.
+		"""
+		return _linksockslib.linksocks_LinkSocksClient_RemoveConnector(self.handle, connectorToken)
+	def GetPartnersCount(self):
+		"""GetPartnersCount() int
+		
+		GetPartnersCount returns the current number of partners
+		"""
+		return _linksockslib.linksocks_LinkSocksClient_GetPartnersCount(self.handle)
 
-# Python type for struct linksocks.ConnectorResponseMessage
-class ConnectorResponseMessage(go.GoClass):
-	"""ConnectorResponseMessage represents a connector management response\n"""
+# Python type for struct linksocks.Relay
+class Relay(go.GoClass):
+	"""Relay handles stream transport between SOCKS5 and WebSocket\n"""
 	def __init__(self, *args, **kwargs):
 		"""
 		handle=A Go-side object is always initialized with an explicit handle=arg
@@ -2641,29 +2656,13 @@ class ConnectorResponseMessage(go.GoClass):
 			self.handle = args[0].handle
 			_linksockslib.IncRef(self.handle)
 		else:
-			self.handle = _linksockslib.linksocks_ConnectorResponseMessage_CTor()
+			self.handle = _linksockslib.linksocks_Relay_CTor()
 			_linksockslib.IncRef(self.handle)
-			if  0 < len(args):
-				self.Success = args[0]
-			if "Success" in kwargs:
-				self.Success = kwargs["Success"]
-			if  1 < len(args):
-				self.Error = args[1]
-			if "Error" in kwargs:
-				self.Error = kwargs["Error"]
-			if  2 < len(args):
-				self.ChannelID = args[2]
-			if "ChannelID" in kwargs:
-				self.ChannelID = kwargs["ChannelID"]
-			if  3 < len(args):
-				self.ConnectorToken = args[3]
-			if "ConnectorToken" in kwargs:
-				self.ConnectorToken = kwargs["ConnectorToken"]
 	def __del__(self):
 		_linksockslib.DecRef(self.handle)
 	def __str__(self):
 		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
-		sv = 'linksocks.ConnectorResponseMessage{'
+		sv = 'linksocks.Relay{'
 		first = True
 		for v in pr:
 			if callable(v[1]):
@@ -2676,48 +2675,81 @@ class ConnectorResponseMessage(go.GoClass):
 		return sv + '}'
 	def __repr__(self):
 		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
-		sv = 'linksocks.ConnectorResponseMessage ( '
+		sv = 'linksocks.Relay ( '
 		for v in pr:
 			if not callable(v[1]):
 				sv += v[0] + '=' + str(v[1]) + ', '
 		return sv + ')'
-	@property
-	def Success(self):
-		return _linksockslib.linksocks_ConnectorResponseMessage_Success_Get(self.handle)
-	@Success.setter
-	def Success(self, value):
-		if isinstance(value, go.GoClass):
-			_linksockslib.linksocks_ConnectorResponseMessage_Success_Set(self.handle, value.handle)
-		else:
-			_linksockslib.linksocks_ConnectorResponseMessage_Success_Set(self.handle, value)
-	@property
-	def Error(self):
-		return _linksockslib.linksocks_ConnectorResponseMessage_Error_Get(self.handle)
-	@Error.setter
-	def Error(self, value):
-		if isinstance(value, go.GoClass):
-			_linksockslib.linksocks_ConnectorResponseMessage_Error_Set(self.handle, value.handle)
-		else:
-			_linksockslib.linksocks_ConnectorResponseMessage_Error_Set(self.handle, value)
-	@property
-	def ChannelID(self):
-		return go.uuid_UUID(handle=_linksockslib.linksocks_ConnectorResponseMessage_ChannelID_Get(self.handle))
-	@property
-	def ConnectorToken(self):
-		return _linksockslib.linksocks_ConnectorResponseMessage_ConnectorToken_Get(self.handle)
-	@ConnectorToken.setter
-	def ConnectorToken(self, value):
-		if isinstance(value, go.GoClass):
-			_linksockslib.linksocks_ConnectorResponseMessage_ConnectorToken_Set(self.handle, value.handle)
-		else:
-			_linksockslib.linksocks_ConnectorResponseMessage_ConnectorToken_Set(self.handle, value)
-	def GetType(self):
-		"""GetType() str"""
-		return _linksockslib.linksocks_ConnectorResponseMessage_GetType(self.handle)
+	def RefuseSocksRequest(self, conn, reason):
+		"""RefuseSocksRequest(object conn, int reason) str
+		
+		RefuseSocksRequest refuses a SOCKS5 client request with the specified reason
+		"""
+		return _linksockslib.linksocks_Relay_RefuseSocksRequest(self.handle, conn.handle, reason)
+	def HandleNetworkConnection(self, ctx, ws, request):
+		"""HandleNetworkConnection(object ctx, object ws, object request) str
+		
+		HandleNetworkConnection handles network connection based on protocol type
+		"""
+		return _linksockslib.linksocks_Relay_HandleNetworkConnection(self.handle, ctx.handle, ws.handle, request.handle)
+	def HandleTCPConnection(self, ctx, ws, request):
+		"""HandleTCPConnection(object ctx, object ws, object request) str
+		
+		HandleTCPConnection handles TCP network connection
+		"""
+		return _linksockslib.linksocks_Relay_HandleTCPConnection(self.handle, ctx.handle, ws.handle, request.handle)
+	def HandleUDPConnection(self, ctx, ws, request):
+		"""HandleUDPConnection(object ctx, object ws, object request) str
+		
+		HandleUDPConnection handles UDP network connection
+		"""
+		return _linksockslib.linksocks_Relay_HandleUDPConnection(self.handle, ctx.handle, ws.handle, request.handle)
+	def HandleSocksRequest(self, ctx, ws, socksConn, socksUsername, socksPassword):
+		"""HandleSocksRequest(object ctx, object ws, object socksConn, str socksUsername, str socksPassword) str
+		
+		HandleSocksRequest handles incoming SOCKS5 client request
+		"""
+		return _linksockslib.linksocks_Relay_HandleSocksRequest(self.handle, ctx.handle, ws.handle, socksConn.handle, socksUsername, socksPassword)
+	def HandleRemoteTCPForward(self, ctx, ws, remoteConn, channelID):
+		"""HandleRemoteTCPForward(object ctx, object ws, object remoteConn, []int channelID) str
+		
+		HandleRemoteTCPForward handles remote TCP forwarding
+		"""
+		return _linksockslib.linksocks_Relay_HandleRemoteTCPForward(self.handle, ctx.handle, ws.handle, remoteConn.handle, channelID.handle)
+	def HandleRemoteUDPForward(self, ctx, ws, udpConn, channelID):
+		"""HandleRemoteUDPForward(object ctx, object ws, object udpConn, []int channelID) str
+		
+		HandleRemoteUDPForward handles remote UDP forwarding
+		"""
+		return _linksockslib.linksocks_Relay_HandleRemoteUDPForward(self.handle, ctx.handle, ws.handle, udpConn.handle, channelID.handle)
+	def HandleSocksTCPForward(self, ctx, ws, socksConn, channelID):
+		"""HandleSocksTCPForward(object ctx, object ws, object socksConn, []int channelID) str
+		
+		HandleSocksTCPForward handles TCP forwarding between SOCKS client and WebSocket
+		"""
+		return _linksockslib.linksocks_Relay_HandleSocksTCPForward(self.handle, ctx.handle, ws.handle, socksConn.handle, channelID.handle)
+	def HandleSocksUDPForward(self, ctx, ws, udpConn, socksConn, channelID):
+		"""HandleSocksUDPForward(object ctx, object ws, object udpConn, object socksConn, []int channelID) str
+		
+		HandleSocksUDPForward handles SOCKS5 UDP forwarding
+		"""
+		return _linksockslib.linksocks_Relay_HandleSocksUDPForward(self.handle, ctx.handle, ws.handle, udpConn.handle, socksConn.handle, channelID.handle)
+	def Close(self, goRun=False):
+		"""Close() 
+		
+		Close gracefully shuts down the Relay
+		"""
+		_linksockslib.linksocks_Relay_Close(self.handle, goRun)
+	def SetConnectionSuccess(self, channelID, goRun=False):
+		"""SetConnectionSuccess([]int channelID) 
+		
+		SetConnectionSuccess sets the connection success status for a channel
+		"""
+		_linksockslib.linksocks_Relay_SetConnectionSuccess(self.handle, channelID.handle, goRun)
 
-# Python type for struct linksocks.ContextWithCancel
-class ContextWithCancel(go.GoClass):
-	"""ContextWithCancel wraps context and cancel function for Python bindings\n"""
+# Python type for struct linksocks.AuthMessage
+class AuthMessage(go.GoClass):
+	"""AuthMessage represents an authentication request\n"""
 	def __init__(self, *args, **kwargs):
 		"""
 		handle=A Go-side object is always initialized with an explicit handle=arg
@@ -2731,13 +2763,25 @@ class ContextWithCancel(go.GoClass):
 			self.handle = args[0].handle
 			_linksockslib.IncRef(self.handle)
 		else:
-			self.handle = _linksockslib.linksocks_ContextWithCancel_CTor()
+			self.handle = _linksockslib.linksocks_AuthMessage_CTor()
 			_linksockslib.IncRef(self.handle)
+			if  0 < len(args):
+				self.Token = args[0]
+			if "Token" in kwargs:
+				self.Token = kwargs["Token"]
+			if  1 < len(args):
+				self.Reverse = args[1]
+			if "Reverse" in kwargs:
+				self.Reverse = kwargs["Reverse"]
+			if  2 < len(args):
+				self.Instance = args[2]
+			if "Instance" in kwargs:
+				self.Instance = kwargs["Instance"]
 	def __del__(self):
 		_linksockslib.DecRef(self.handle)
 	def __str__(self):
 		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
-		sv = 'linksocks.ContextWithCancel{'
+		sv = 'linksocks.AuthMessage{'
 		first = True
 		for v in pr:
 			if callable(v[1]):
@@ -2750,27 +2794,39 @@ class ContextWithCancel(go.GoClass):
 		return sv + '}'
 	def __repr__(self):
 		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
-		sv = 'linksocks.ContextWithCancel ( '
+		sv = 'linksocks.AuthMessage ( '
 		for v in pr:
 			if not callable(v[1]):
 				sv += v[0] + '=' + str(v[1]) + ', '
 		return sv + ')'
-	def Cancel(self, goRun=False):
-		"""Cancel() 
-		
-		Cancel calls the cancel function to cancel the context
-		"""
-		_linksockslib.linksocks_ContextWithCancel_Cancel(self.handle, goRun)
-	def Context(self):
-		"""Context() object
-		
-		Context returns the underlying context.Context
-		"""
-		return go.context_Context(handle=_linksockslib.linksocks_ContextWithCancel_Context(self.handle))
-
-# Python type for struct linksocks.PortPool
-class PortPool(go.GoClass):
-	"""PortPool is a thread-safe port pool for managing available network ports\n"""
+	@property
+	def Token(self):
+		return _linksockslib.linksocks_AuthMessage_Token_Get(self.handle)
+	@Token.setter
+	def Token(self, value):
+		if isinstance(value, go.GoClass):
+			_linksockslib.linksocks_AuthMessage_Token_Set(self.handle, value.handle)
+		else:
+			_linksockslib.linksocks_AuthMessage_Token_Set(self.handle, value)
+	@property
+	def Reverse(self):
+		return _linksockslib.linksocks_AuthMessage_Reverse_Get(self.handle)
+	@Reverse.setter
+	def Reverse(self, value):
+		if isinstance(value, go.GoClass):
+			_linksockslib.linksocks_AuthMessage_Reverse_Set(self.handle, value.handle)
+		else:
+			_linksockslib.linksocks_AuthMessage_Reverse_Set(self.handle, value)
+	@property
+	def Instance(self):
+		return go.uuid_UUID(handle=_linksockslib.linksocks_AuthMessage_Instance_Get(self.handle))
+	def GetType(self):
+		"""GetType() str"""
+		return _linksockslib.linksocks_AuthMessage_GetType(self.handle)
+
+# Python type for struct linksocks.ConnectorMessage
+class ConnectorMessage(go.GoClass):
+	"""ConnectorMessage represents a connector management command from reverse client\n"""
 	def __init__(self, *args, **kwargs):
 		"""
 		handle=A Go-side object is always initialized with an explicit handle=arg
@@ -2784,13 +2840,25 @@ class PortPool(go.GoClass):
 			self.handle = args[0].handle
 			_linksockslib.IncRef(self.handle)
 		else:
-			self.handle = _linksockslib.linksocks_PortPool_CTor()
+			self.handle = _linksockslib.linksocks_ConnectorMessage_CTor()
 			_linksockslib.IncRef(self.handle)
+			if  0 < len(args):
+				self.ChannelID = args[0]
+			if "ChannelID" in kwargs:
+				self.ChannelID = kwargs["ChannelID"]
+			if  1 < len(args):
+				self.ConnectorToken = args[1]
+			if "ConnectorToken" in kwargs:
+				self.ConnectorToken = kwargs["ConnectorToken"]
+			if  2 < len(args):
+				self.Operation = args[2]
+			if "Operation" in kwargs:
+				self.Operation = kwargs["Operation"]
 	def __del__(self):
 		_linksockslib.DecRef(self.handle)
 	def __str__(self):
 		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
-		sv = 'linksocks.PortPool{'
+		sv = 'linksocks.ConnectorMessage{'
 		first = True
 		for v in pr:
 			if callable(v[1]):
@@ -2803,28 +2871,39 @@ class PortPool(go.GoClass):
 		return sv + '}'
 	def __repr__(self):
 		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
-		sv = 'linksocks.PortPool ( '
+		sv = 'linksocks.ConnectorMessage ( '
 		for v in pr:
 			if not callable(v[1]):
 				sv += v[0] + '=' + str(v[1]) + ', '
 		return sv + ')'
-	def Get(self, requestedPort):
-		"""Get(int requestedPort) int
-		
-		Get retrieves an available port from the pool
-		If a specific port is requested, it will try to allocate that port
-		"""
-		return _linksockslib.linksocks_PortPool_Get(self.handle, requestedPort)
-	def Put(self, port, goRun=False):
-		"""Put(int port) 
-		
-		Put returns a port back to the pool
-		"""
-		_linksockslib.linksocks_PortPool_Put(self.handle, port, goRun)
+	@property
+	def ChannelID(self):
+		return go.uuid_UUID(handle=_linksockslib.linksocks_ConnectorMessage_ChannelID_Get(self.handle))
+	@property
+	def ConnectorToken(self):
+		return _linksockslib.linksocks_ConnectorMessage_ConnectorToken_Get(self.handle)
+	@ConnectorToken.setter
+	def ConnectorToken(self, value):
+		if isinstance(value, go.GoClass):
+			_linksockslib.linksocks_ConnectorMessage_ConnectorToken_Set(self.handle, value.handle)
+		else:
+			_linksockslib.linksocks_ConnectorMessage_ConnectorToken_Set(self.handle, value)
+	@property
+	def Operation(self):
+		return _linksockslib.linksocks_ConnectorMessage_Operation_Get(self.handle)
+	@Operation.setter
+	def Operation(self, value):
+		if isinstance(value, go.GoClass):
+			_linksockslib.linksocks_ConnectorMessage_Operation_Set(self.handle, value.handle)
+		else:
+			_linksockslib.linksocks_ConnectorMessage_Operation_Set(self.handle, value)
+	def GetType(self):
+		"""GetType() str"""
+		return _linksockslib.linksocks_ConnectorMessage_GetType(self.handle)
 
-# Python type for struct linksocks.ReverseTokenResult
-class ReverseTokenResult(go.GoClass):
-	"""ReverseTokenResult represents the result of adding a reverse token\n"""
+# Python type for struct linksocks.DynamicForwarder
+class DynamicForwarder(go.GoClass):
+	"""DynamicForwarder handles dynamic batching and sending of network data\n"""
 	def __init__(self, *args, **kwargs):
 		"""
 		handle=A Go-side object is always initialized with an explicit handle=arg
@@ -2838,21 +2917,13 @@ class ReverseTokenResult(go.GoClass):
 			self.handle = args[0].handle
 			_linksockslib.IncRef(self.handle)
 		else:
-			self.handle = _linksockslib.linksocks_ReverseTokenResult_CTor()
+			self.handle = _linksockslib.linksocks_DynamicForwarder_CTor()
 			_linksockslib.IncRef(self.handle)
-			if  0 < len(args):
-				self.Token = args[0]
-			if "Token" in kwargs:
-				self.Token = kwargs["Token"]
-			if  1 < len(args):
-				self.Port = args[1]
-			if "Port" in kwargs:
-				self.Port = kwargs["Port"]
 	def __del__(self):
 		_linksockslib.DecRef(self.handle)
 	def __str__(self):
 		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
-		sv = 'linksocks.ReverseTokenResult{'
+		sv = 'linksocks.DynamicForwarder{'
 		first = True
 		for v in pr:
 			if callable(v[1]):
@@ -2865,33 +2936,33 @@ class ReverseTokenResult(go.GoClass):
 		return sv + '}'
 	def __repr__(self):
 		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
-		sv = 'linksocks.ReverseTokenResult ( '
+		sv = 'linksocks.DynamicForwarder ( '
 		for v in pr:
 			if not callable(v[1]):
 				sv += v[0] + '=' + str(v[1]) + ', '
 		return sv + ')'
-	@property
-	def Token(self):
-		return _linksockslib.linksocks_ReverseTokenResult_Token_Get(self.handle)
-	@Token.setter
-	def Token(self, value):
-		if isinstance(value, go.GoClass):
-			_linksockslib.linksocks_ReverseTokenResult_Token_Set(self.handle, value.handle)
-		else:
-			_linksockslib.linksocks_ReverseTokenResult_Token_Set(self.handle, value)
-	@property
-	def Port(self):
-		return _linksockslib.linksocks_ReverseTokenResult_Port_Get(self.handle)
-	@Port.setter
-	def Port(self, value):
-		if isinstance(value, go.GoClass):
-			_linksockslib.linksocks_ReverseTokenResult_Port_Set(self.handle, value.handle)
-		else:
-			_linksockslib.linksocks_ReverseTokenResult_Port_Set(self.handle, value)
+	def ProcessReads(self, conn, goRun=False):
+		"""ProcessReads(object conn) 
+		
+		ProcessReads handles reading from a network connection and forwarding to WebSocket with dynamic batching
+		"""
+		_linksockslib.linksocks_DynamicForwarder_ProcessReads(self.handle, conn.handle, goRun)
+	def ProcessReadsImmediate(self, conn, goRun=False):
+		"""ProcessReadsImmediate(object conn) 
+		
+		processReadsImmediate handles reading directly without batching
+		"""
+		_linksockslib.linksocks_DynamicForwarder_ProcessReadsImmediate(self.handle, conn.handle, goRun)
+	def ProcessUDPReads(self, conn, goRun=False):
+		"""ProcessUDPReads(object conn) 
+		
+		ProcessUDPReads handles reading from a UDP connection with appropriate metadata
+		"""
+		_linksockslib.linksocks_DynamicForwarder_ProcessUDPReads(self.handle, conn.handle, goRun)
 
-# Python type for struct linksocks.AuthResponseMessage
-class AuthResponseMessage(go.GoClass):
-	"""AuthResponseMessage represents an authentication response\n"""
+# Python type for struct linksocks.LinkSocksServer
+class LinkSocksServer(go.GoClass):
+	"""LinkSocksServer represents a SOCKS5 over WebSocket protocol server\n"""
 	def __init__(self, *args, **kwargs):
 		"""
 		handle=A Go-side object is always initialized with an explicit handle=arg
@@ -2905,21 +2976,13 @@ class AuthResponseMessage(go.GoClass):
 			self.handle = args[0].handle
 			_linksockslib.IncRef(self.handle)
 		else:
-			self.handle = _linksockslib.linksocks_AuthResponseMessage_CTor()
+			self.handle = _linksockslib.linksocks_LinkSocksServer_CTor()
 			_linksockslib.IncRef(self.handle)
-			if  0 < len(args):
-				self.Success = args[0]
-			if "Success" in kwargs:
-				self.Success = kwargs["Success"]
-			if  1 < len(args):
-				self.Error = args[1]
-			if "Error" in kwargs:
-				self.Error = kwargs["Error"]
 	def __del__(self):
 		_linksockslib.DecRef(self.handle)
 	def __str__(self):
 		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
-		sv = 'linksocks.AuthResponseMessage{'
+		sv = 'linksocks.LinkSocksServer{'
 		first = True
 		for v in pr:
 			if callable(v[1]):
@@ -2932,36 +2995,75 @@ class AuthResponseMessage(go.GoClass):
 		return sv + '}'
 	def __repr__(self):
 		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
-		sv = 'linksocks.AuthResponseMessage ( '
+		sv = 'linksocks.LinkSocksServer ( '
 		for v in pr:
 			if not callable(v[1]):
 				sv += v[0] + '=' + str(v[1]) + ', '
 		return sv + ')'
-	@property
-	def Success(self):
-		return _linksockslib.linksocks_AuthResponseMessage_Success_Get(self.handle)
-	@Success.setter
-	def Success(self, value):
-		if isinstance(value, go.GoClass):
-			_linksockslib.linksocks_AuthResponseMessage_Success_Set(self.handle, value.handle)
-		else:
-			_linksockslib.linksocks_AuthResponseMessage_Success_Set(self.handle, value)
-	@property
-	def Error(self):
-		return _linksockslib.linksocks_AuthResponseMessage_Error_Get(self.handle)
-	@Error.setter
-	def Error(self, value):
-		if isinstance(value, go.GoClass):
-			_linksockslib.linksocks_AuthResponseMessage_Error_Set(self.handle, value.handle)
-		else:
-			_linksockslib.linksocks_AuthResponseMessage_Error_Set(self.handle, value)
-	def GetType(self):
-		"""GetType() str"""
-		return _linksockslib.linksocks_AuthResponseMessage_GetType(self.handle)
+	def AddReverseToken(self, opts):
+		"""AddReverseToken(object opts) object, str
+		
+		AddReverseToken adds a new token for reverse socks and assigns a port
+		"""
+		return ReverseTokenResult(handle=_linksockslib.linksocks_LinkSocksServer_AddReverseToken(self.handle, opts.handle))
+	def AddForwardToken(self, token):
+		"""AddForwardToken(str token) str, str
+		
+		AddForwardToken adds a new token for forward socks proxy
+		"""
+		return _linksockslib.linksocks_LinkSocksServer_AddForwardToken(self.handle, token)
+	def AddConnectorToken(self, connectorToken, reverseToken):
+		"""AddConnectorToken(str connectorToken, str reverseToken) str, str
+		
+		AddConnectorToken adds a new connector token that forwards requests to a reverse token
+		"""
+		return _linksockslib.linksocks_LinkSocksServer_AddConnectorToken(self.handle, connectorToken, reverseToken)
+	def RemoveToken(self, token):
+		"""RemoveToken(str token) bool
+		
+		RemoveToken removes a token and disconnects all its clients
+		"""
+		return _linksockslib.linksocks_LinkSocksServer_RemoveToken(self.handle, token)
+	def Serve(self, ctx):
+		"""Serve(object ctx) str
+		
+		Serve starts the WebSocket server and waits for clients
+		"""
+		return _linksockslib.linksocks_LinkSocksServer_Serve(self.handle, ctx.handle)
+	def WaitReady(self, ctx, timeout):
+		"""WaitReady(object ctx, long timeout) str
+		
+		WaitReady starts the server and waits for the server to be ready with optional timeout
+		"""
+		return _linksockslib.linksocks_LinkSocksServer_WaitReady(self.handle, ctx.handle, timeout)
+	def Close(self, goRun=False):
+		"""Close() 
+		
+		Close gracefully shuts down the LinkSocksServer
+		"""
+		_linksockslib.linksocks_LinkSocksServer_Close(self.handle, goRun)
+	def GetClientCount(self):
+		"""GetClientCount() int
+		
+		GetClientCount returns the total number of connected clients
+		"""
+		return _linksockslib.linksocks_LinkSocksServer_GetClientCount(self.handle)
+	def HasClients(self):
+		"""HasClients() bool
+		
+		HasClients returns true if there are any connected clients
+		"""
+		return _linksockslib.linksocks_LinkSocksServer_HasClients(self.handle)
+	def GetTokenClientCount(self, token):
+		"""GetTokenClientCount(str token) int
+		
+		GetTokenClientCount counts clients connected for a given token
+		"""
+		return _linksockslib.linksocks_LinkSocksServer_GetTokenClientCount(self.handle, token)
 
-# Python type for struct linksocks.ClientOption
-class ClientOption(go.GoClass):
-	"""ClientOption represents configuration options for LinkSocksClient\n"""
+# Python type for struct linksocks.LogMessage
+class LogMessage(go.GoClass):
+	"""LogMessage represents a log message from server to client\n"""
 	def __init__(self, *args, **kwargs):
 		"""
 		handle=A Go-side object is always initialized with an explicit handle=arg
@@ -2975,12 +3077,175 @@ class ClientOption(go.GoClass):
 			self.handle = args[0].handle
 			_linksockslib.IncRef(self.handle)
 		else:
-			self.handle = _linksockslib.linksocks_ClientOption_CTor()
+			self.handle = _linksockslib.linksocks_LogMessage_CTor()
 			_linksockslib.IncRef(self.handle)
 			if  0 < len(args):
-				self.WSURL = args[0]
-			if "WSURL" in kwargs:
-				self.WSURL = kwargs["WSURL"]
+				self.Level = args[0]
+			if "Level" in kwargs:
+				self.Level = kwargs["Level"]
+			if  1 < len(args):
+				self.Msg = args[1]
+			if "Msg" in kwargs:
+				self.Msg = kwargs["Msg"]
+	def __del__(self):
+		_linksockslib.DecRef(self.handle)
+	def __str__(self):
+		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
+		sv = 'linksocks.LogMessage{'
+		first = True
+		for v in pr:
+			if callable(v[1]):
+				continue
+			if first:
+				first = False
+			else:
+				sv += ', '
+			sv += v[0] + '=' + str(v[1])
+		return sv + '}'
+	def __repr__(self):
+		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
+		sv = 'linksocks.LogMessage ( '
+		for v in pr:
+			if not callable(v[1]):
+				sv += v[0] + '=' + str(v[1]) + ', '
+		return sv + ')'
+	@property
+	def Level(self):
+		return _linksockslib.linksocks_LogMessage_Level_Get(self.handle)
+	@Level.setter
+	def Level(self, value):
+		if isinstance(value, go.GoClass):
+			_linksockslib.linksocks_LogMessage_Level_Set(self.handle, value.handle)
+		else:
+			_linksockslib.linksocks_LogMessage_Level_Set(self.handle, value)
+	@property
+	def Msg(self):
+		return _linksockslib.linksocks_LogMessage_Msg_Get(self.handle)
+	@Msg.setter
+	def Msg(self, value):
+		if isinstance(value, go.GoClass):
+			_linksockslib.linksocks_LogMessage_Msg_Set(self.handle, value.handle)
+		else:
+			_linksockslib.linksocks_LogMessage_Msg_Set(self.handle, value)
+	def GetType(self):
+		"""GetType() str"""
+		return _linksockslib.linksocks_LogMessage_GetType(self.handle)
+
+# Python type for struct linksocks.TokenResponse
+class TokenResponse(go.GoClass):
+	"""TokenResponse represents the response for token operations\n"""
+	def __init__(self, *args, **kwargs):
+		"""
+		handle=A Go-side object is always initialized with an explicit handle=arg
+		otherwise parameters can be unnamed in order of field names or named fields
+		in which case a new Go object is constructed first
+		"""
+		if len(kwargs) == 1 and 'handle' in kwargs:
+			self.handle = kwargs['handle']
+			_linksockslib.IncRef(self.handle)
+		elif len(args) == 1 and isinstance(args[0], go.GoClass):
+			self.handle = args[0].handle
+			_linksockslib.IncRef(self.handle)
+		else:
+			self.handle = _linksockslib.linksocks_TokenResponse_CTor()
+			_linksockslib.IncRef(self.handle)
+			if  0 < len(args):
+				self.Success = args[0]
+			if "Success" in kwargs:
+				self.Success = kwargs["Success"]
+			if  1 < len(args):
+				self.Token = args[1]
+			if "Token" in kwargs:
+				self.Token = kwargs["Token"]
+			if  2 < len(args):
+				self.Port = args[2]
+			if "Port" in kwargs:
+				self.Port = kwargs["Port"]
+			if  3 < len(args):
+				self.Error = args[3]
+			if "Error" in kwargs:
+				self.Error = kwargs["Error"]
+	def __del__(self):
+		_linksockslib.DecRef(self.handle)
+	def __str__(self):
+		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
+		sv = 'linksocks.TokenResponse{'
+		first = True
+		for v in pr:
+			if callable(v[1]):
+				continue
+			if first:
+				first = False
+			else:
+				sv += ', '
+			sv += v[0] + '=' + str(v[1])
+		return sv + '}'
+	def __repr__(self):
+		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
+		sv = 'linksocks.TokenResponse ( '
+		for v in pr:
+			if not callable(v[1]):
+				sv += v[0] + '=' + str(v[1]) + ', '
+		return sv + ')'
+	@property
+	def Success(self):
+		return _linksockslib.linksocks_TokenResponse_Success_Get(self.handle)
+	@Success.setter
+	def Success(self, value):
+		if isinstance(value, go.GoClass):
+			_linksockslib.linksocks_TokenResponse_Success_Set(self.handle, value.handle)
+		else:
+			_linksockslib.linksocks_TokenResponse_Success_Set(self.handle, value)
+	@property
+	def Token(self):
+		return _linksockslib.linksocks_TokenResponse_Token_Get(self.handle)
+	@Token.setter
+	def Token(self, value):
+		if isinstance(value, go.GoClass):
+			_linksockslib.linksocks_TokenResponse_Token_Set(self.handle, value.handle)
+		else:
+			_linksockslib.linksocks_TokenResponse_Token_Set(self.handle, value)
+	@property
+	def Port(self):
+		return _linksockslib.linksocks_TokenResponse_Port_Get(self.handle)
+	@Port.setter
+	def Port(self, value):
+		if isinstance(value, go.GoClass):
+			_linksockslib.linksocks_TokenResponse_Port_Set(self.handle, value.handle)
+		else:
+			_linksockslib.linksocks_TokenResponse_Port_Set(self.handle, value)
+	@property
+	def Error(self):
+		return _linksockslib.linksocks_TokenResponse_Error_Get(self.handle)
+	@Error.setter
+	def Error(self, value):
+		if isinstance(value, go.GoClass):
+			_linksockslib.linksocks_TokenResponse_Error_Set(self.handle, value.handle)
+		else:
+			_linksockslib.linksocks_TokenResponse_Error_Set(self.handle, value)
+
+# Python type for struct linksocks.ClientOption
+class ClientOption(go.GoClass):
+	"""ClientOption represents configuration options for LinkSocksClient\n"""
+	def __init__(self, *args, **kwargs):
+		"""
+		handle=A Go-side object is always initialized with an explicit handle=arg
+		otherwise parameters can be unnamed in order of field names or named fields
+		in which case a new Go object is constructed first
+		"""
+		if len(kwargs) == 1 and 'handle' in kwargs:
+			self.handle = kwargs['handle']
+			_linksockslib.IncRef(self.handle)
+		elif len(args) == 1 and isinstance(args[0], go.GoClass):
+			self.handle = args[0].handle
+			_linksockslib.IncRef(self.handle)
+		else:
+			self.handle = _linksockslib.linksocks_ClientOption_CTor()
+			_linksockslib.IncRef(self.handle)
+			if  0 < len(args):
+				self.WSURL = args[0]
+			if "WSURL" in kwargs:
+				self.WSURL = kwargs["WSURL"]
 			if  1 < len(args):
 				self.Reverse = args[1]
 			if "Reverse" in kwargs:
@@ -3355,9 +3620,9 @@ class ClientOption(go.GoClass):
 		"""
 		return ClientOption(handle=_linksockslib.linksocks_ClientOption_WithNoEnvProxy(self.handle, noEnvProxy))
 
-# Python type for struct linksocks.DisconnectMessage
-class DisconnectMessage(go.GoClass):
-	"""DisconnectMessage represents a connection termination message\n"""
+# Python type for struct linksocks.ConnectMessage
+class ConnectMessage(go.GoClass):
+	"""ConnectMessage represents a TCP connection request\n"""
 	def __init__(self, *args, **kwargs):
 		"""
 		handle=A Go-side object is always initialized with an explicit handle=arg
@@ -3371,21 +3636,29 @@ class DisconnectMessage(go.GoClass):
 			self.handle = args[0].handle
 			_linksockslib.IncRef(self.handle)
 		else:
-			self.handle = _linksockslib.linksocks_DisconnectMessage_CTor()
+			self.handle = _linksockslib.linksocks_ConnectMessage_CTor()
 			_linksockslib.IncRef(self.handle)
 			if  0 < len(args):
-				self.ChannelID = args[0]
+				self.Protocol = args[0]
+			if "Protocol" in kwargs:
+				self.Protocol = kwargs["Protocol"]
+			if  1 < len(args):
+				self.Address = args[1]
+			if "Address" in kwargs:
+				self.Address = kwargs["Address"]
+			if  2 < len(args):
+				self.Port = args[2]
+			if "Port" in kwargs:
+				self.Port = kwargs["Port"]
+			if  3 < len(args):
+				self.ChannelID = args[3]
 			if "ChannelID" in kwargs:
 				self.ChannelID = kwargs["ChannelID"]
-			if  1 < len(args):
-				self.Error = args[1]
-			if "Error" in kwargs:
-				self.Error = kwargs["Error"]
 	def __del__(self):
 		_linksockslib.DecRef(self.handle)
 	def __str__(self):
 		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
-		sv = 'linksocks.DisconnectMessage{'
+		sv = 'linksocks.ConnectMessage{'
 		first = True
 		for v in pr:
 			if callable(v[1]):
@@ -3398,30 +3671,48 @@ class DisconnectMessage(go.GoClass):
 		return sv + '}'
 	def __repr__(self):
 		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
-		sv = 'linksocks.DisconnectMessage ( '
+		sv = 'linksocks.ConnectMessage ( '
 		for v in pr:
 			if not callable(v[1]):
 				sv += v[0] + '=' + str(v[1]) + ', '
 		return sv + ')'
 	@property
-	def ChannelID(self):
-		return go.uuid_UUID(handle=_linksockslib.linksocks_DisconnectMessage_ChannelID_Get(self.handle))
+	def Protocol(self):
+		return _linksockslib.linksocks_ConnectMessage_Protocol_Get(self.handle)
+	@Protocol.setter
+	def Protocol(self, value):
+		if isinstance(value, go.GoClass):
+			_linksockslib.linksocks_ConnectMessage_Protocol_Set(self.handle, value.handle)
+		else:
+			_linksockslib.linksocks_ConnectMessage_Protocol_Set(self.handle, value)
 	@property
-	def Error(self):
-		return _linksockslib.linksocks_DisconnectMessage_Error_Get(self.handle)
-	@Error.setter
-	def Error(self, value):
+	def Address(self):
+		return _linksockslib.linksocks_ConnectMessage_Address_Get(self.handle)
+	@Address.setter
+	def Address(self, value):
 		if isinstance(value, go.GoClass):
-			_linksockslib.linksocks_DisconnectMessage_Error_Set(self.handle, value.handle)
+			_linksockslib.linksocks_ConnectMessage_Address_Set(self.handle, value.handle)
 		else:
-			_linksockslib.linksocks_DisconnectMessage_Error_Set(self.handle, value)
+			_linksockslib.linksocks_ConnectMessage_Address_Set(self.handle, value)
+	@property
+	def Port(self):
+		return _linksockslib.linksocks_ConnectMessage_Port_Get(self.handle)
+	@Port.setter
+	def Port(self, value):
+		if isinstance(value, go.GoClass):
+			_linksockslib.linksocks_ConnectMessage_Port_Set(self.handle, value.handle)
+		else:
+			_linksockslib.linksocks_ConnectMessage_Port_Set(self.handle, value)
+	@property
+	def ChannelID(self):
+		return go.uuid_UUID(handle=_linksockslib.linksocks_ConnectMessage_ChannelID_Get(self.handle))
 	def GetType(self):
 		"""GetType() str"""
-		return _linksockslib.linksocks_DisconnectMessage_GetType(self.handle)
+		return _linksockslib.linksocks_ConnectMessage_GetType(self.handle)
 
-# Python type for struct linksocks.PartnersMessage
-class PartnersMessage(go.GoClass):
-	"""PartnersMessage represents a partners count update message\n"""
+# Python type for struct linksocks.RelayOption
+class RelayOption(go.GoClass):
+	"""RelayOption contains configuration options for Relay\n"""
 	def __init__(self, *args, **kwargs):
 		"""
 		handle=A Go-side object is always initialized with an explicit handle=arg
@@ -3435,64 +3726,7 @@ class PartnersMessage(go.GoClass):
 			self.handle = args[0].handle
 			_linksockslib.IncRef(self.handle)
 		else:
-			self.handle = _linksockslib.linksocks_PartnersMessage_CTor()
-			_linksockslib.IncRef(self.handle)
-			if  0 < len(args):
-				self.Count = args[0]
-			if "Count" in kwargs:
-				self.Count = kwargs["Count"]
-	def __del__(self):
-		_linksockslib.DecRef(self.handle)
-	def __str__(self):
-		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
-		sv = 'linksocks.PartnersMessage{'
-		first = True
-		for v in pr:
-			if callable(v[1]):
-				continue
-			if first:
-				first = False
-			else:
-				sv += ', '
-			sv += v[0] + '=' + str(v[1])
-		return sv + '}'
-	def __repr__(self):
-		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
-		sv = 'linksocks.PartnersMessage ( '
-		for v in pr:
-			if not callable(v[1]):
-				sv += v[0] + '=' + str(v[1]) + ', '
-		return sv + ')'
-	@property
-	def Count(self):
-		return _linksockslib.linksocks_PartnersMessage_Count_Get(self.handle)
-	@Count.setter
-	def Count(self, value):
-		if isinstance(value, go.GoClass):
-			_linksockslib.linksocks_PartnersMessage_Count_Set(self.handle, value.handle)
-		else:
-			_linksockslib.linksocks_PartnersMessage_Count_Set(self.handle, value)
-	def GetType(self):
-		"""GetType() str"""
-		return _linksockslib.linksocks_PartnersMessage_GetType(self.handle)
-
-# Python type for struct linksocks.RelayOption
-class RelayOption(go.GoClass):
-	"""RelayOption contains configuration options for Relay\n"""
-	def __init__(self, *args, **kwargs):
-		"""
-		handle=A Go-side object is always initialized with an explicit handle=arg
-		otherwise parameters can be unnamed in order of field names or named fields
-		in which case a new Go object is constructed first
-		"""
-		if len(kwargs) == 1 and 'handle' in kwargs:
-			self.handle = kwargs['handle']
-			_linksockslib.IncRef(self.handle)
-		elif len(args) == 1 and isinstance(args[0], go.GoClass):
-			self.handle = args[0].handle
-			_linksockslib.IncRef(self.handle)
-		else:
-			self.handle = _linksockslib.linksocks_RelayOption_CTor()
+			self.handle = _linksockslib.linksocks_RelayOption_CTor()
 			_linksockslib.IncRef(self.handle)
 			if  0 < len(args):
 				self.BufferSize = args[0]
@@ -3768,9 +4002,9 @@ class RelayOption(go.GoClass):
 		"""
 		return RelayOption(handle=_linksockslib.linksocks_RelayOption_WithCompressionThreshold(self.handle, threshold))
 
-# Python type for struct linksocks.SocketManager
-class SocketManager(go.GoClass):
-	"""SocketManager manages socket lifecycle and reuse\n"""
+# Python type for struct linksocks.ReverseTokenOptions
+class ReverseTokenOptions(go.GoClass):
+	"""ReverseTokenOptions represents configuration options for reverse token\n"""
 	def __init__(self, *args, **kwargs):
 		"""
 		handle=A Go-side object is always initialized with an explicit handle=arg
@@ -3784,13 +4018,33 @@ class SocketManager(go.GoClass):
 			self.handle = args[0].handle
 			_linksockslib.IncRef(self.handle)
 		else:
-			self.handle = _linksockslib.linksocks_SocketManager_CTor()
+			self.handle = _linksockslib.linksocks_ReverseTokenOptions_CTor()
 			_linksockslib.IncRef(self.handle)
+			if  0 < len(args):
+				self.Token = args[0]
+			if "Token" in kwargs:
+				self.Token = kwargs["Token"]
+			if  1 < len(args):
+				self.Port = args[1]
+			if "Port" in kwargs:
+				self.Port = kwargs["Port"]
+			if  2 < len(args):
+				self.Username = args[2]
+			if "Username" in kwargs:
+				self.Username = kwargs["Username"]
+			if  3 < len(args):
+				self.Password = args[3]
+			if "Password" in kwargs:
+				self.Password = kwargs["Password"]
+			if  4 < len(args):
+				self.AllowManageConnector = args[4]
+			if "AllowManageConnector" in kwargs:
+				self.AllowManageConnector = kwargs["AllowManageConnector"]
 	def __del__(self):
 		_linksockslib.DecRef(self.handle)
 	def __str__(self):
 		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
-		sv = 'linksocks.SocketManager{'
+		sv = 'linksocks.ReverseTokenOptions{'
 		first = True
 		for v in pr:
 			if callable(v[1]):
@@ -3803,27 +4057,60 @@ class SocketManager(go.GoClass):
 		return sv + '}'
 	def __repr__(self):
 		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
-		sv = 'linksocks.SocketManager ( '
+		sv = 'linksocks.ReverseTokenOptions ( '
 		for v in pr:
 			if not callable(v[1]):
 				sv += v[0] + '=' + str(v[1]) + ', '
 		return sv + ')'
-	def GetListener(self, port):
-		"""GetListener(int port) object, str"""
-		return go.net_Listener(handle=_linksockslib.linksocks_SocketManager_GetListener(self.handle, port))
-	def ReleaseListener(self, port, goRun=False):
-		"""ReleaseListener(int port) """
-		_linksockslib.linksocks_SocketManager_ReleaseListener(self.handle, port, goRun)
-	def Close(self, goRun=False):
-		"""Close() 
-		
-		Close closes all managed sockets immediately
-		"""
-		_linksockslib.linksocks_SocketManager_Close(self.handle, goRun)
+	@property
+	def Token(self):
+		return _linksockslib.linksocks_ReverseTokenOptions_Token_Get(self.handle)
+	@Token.setter
+	def Token(self, value):
+		if isinstance(value, go.GoClass):
+			_linksockslib.linksocks_ReverseTokenOptions_Token_Set(self.handle, value.handle)
+		else:
+			_linksockslib.linksocks_ReverseTokenOptions_Token_Set(self.handle, value)
+	@property
+	def Port(self):
+		return _linksockslib.linksocks_ReverseTokenOptions_Port_Get(self.handle)
+	@Port.setter
+	def Port(self, value):
+		if isinstance(value, go.GoClass):
+			_linksockslib.linksocks_ReverseTokenOptions_Port_Set(self.handle, value.handle)
+		else:
+			_linksockslib.linksocks_ReverseTokenOptions_Port_Set(self.handle, value)
+	@property
+	def Username(self):
+		return _linksockslib.linksocks_ReverseTokenOptions_Username_Get(self.handle)
+	@Username.setter
+	def Username(self, value):
+		if isinstance(value, go.GoClass):
+			_linksockslib.linksocks_ReverseTokenOptions_Username_Set(self.handle, value.handle)
+		else:
+			_linksockslib.linksocks_ReverseTokenOptions_Username_Set(self.handle, value)
+	@property
+	def Password(self):
+		return _linksockslib.linksocks_ReverseTokenOptions_Password_Get(self.handle)
+	@Password.setter
+	def Password(self, value):
+		if isinstance(value, go.GoClass):
+			_linksockslib.linksocks_ReverseTokenOptions_Password_Set(self.handle, value.handle)
+		else:
+			_linksockslib.linksocks_ReverseTokenOptions_Password_Set(self.handle, value)
+	@property
+	def AllowManageConnector(self):
+		return _linksockslib.linksocks_ReverseTokenOptions_AllowManageConnector_Get(self.handle)
+	@AllowManageConnector.setter
+	def AllowManageConnector(self, value):
+		if isinstance(value, go.GoClass):
+			_linksockslib.linksocks_ReverseTokenOptions_AllowManageConnector_Set(self.handle, value.handle)
+		else:
+			_linksockslib.linksocks_ReverseTokenOptions_AllowManageConnector_Set(self.handle, value)
 
-# Python type for struct linksocks.LinkSocksClient
-class LinkSocksClient(go.GoClass):
-	"""LinkSocksClient represents a SOCKS5 over WebSocket protocol client\n"""
+# Python type for struct linksocks.TokenStatus
+class TokenStatus(go.GoClass):
+	"""TokenStatus represents the status of a token\n"""
 	def __init__(self, *args, **kwargs):
 		"""
 		handle=A Go-side object is always initialized with an explicit handle=arg
@@ -3837,17 +4124,25 @@ class LinkSocksClient(go.GoClass):
 			self.handle = args[0].handle
 			_linksockslib.IncRef(self.handle)
 		else:
-			self.handle = _linksockslib.linksocks_LinkSocksClient_CTor()
+			self.handle = _linksockslib.linksocks_TokenStatus_CTor()
 			_linksockslib.IncRef(self.handle)
+			if  0 < len(args):
+				self.Token = args[0]
+			if "Token" in kwargs:
+				self.Token = kwargs["Token"]
+			if  1 < len(args):
+				self.Type = args[1]
+			if "Type" in kwargs:
+				self.Type = kwargs["Type"]
 			if  2 < len(args):
-				self.IsConnected = args[2]
-			if "IsConnected" in kwargs:
-				self.IsConnected = kwargs["IsConnected"]
+				self.ClientsCount = args[2]
+			if "ClientsCount" in kwargs:
+				self.ClientsCount = kwargs["ClientsCount"]
 	def __del__(self):
 		_linksockslib.DecRef(self.handle)
 	def __str__(self):
 		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
-		sv = 'linksocks.LinkSocksClient{'
+		sv = 'linksocks.TokenStatus{'
 		first = True
 		for v in pr:
 			if callable(v[1]):
@@ -3860,62 +4155,42 @@ class LinkSocksClient(go.GoClass):
 		return sv + '}'
 	def __repr__(self):
 		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
-		sv = 'linksocks.LinkSocksClient ( '
+		sv = 'linksocks.TokenStatus ( '
 		for v in pr:
 			if not callable(v[1]):
 				sv += v[0] + '=' + str(v[1]) + ', '
 		return sv + ')'
 	@property
-	def IsConnected(self):
-		return _linksockslib.linksocks_LinkSocksClient_IsConnected_Get(self.handle)
-	@IsConnected.setter
-	def IsConnected(self, value):
+	def Token(self):
+		return _linksockslib.linksocks_TokenStatus_Token_Get(self.handle)
+	@Token.setter
+	def Token(self, value):
 		if isinstance(value, go.GoClass):
-			_linksockslib.linksocks_LinkSocksClient_IsConnected_Set(self.handle, value.handle)
+			_linksockslib.linksocks_TokenStatus_Token_Set(self.handle, value.handle)
 		else:
-			_linksockslib.linksocks_LinkSocksClient_IsConnected_Set(self.handle, value)
-	def WaitReady(self, ctx, timeout):
-		"""WaitReady(object ctx, long timeout) str
-		
-		WaitReady start the client and waits for the client to be ready with optional timeout
-		"""
-		return _linksockslib.linksocks_LinkSocksClient_WaitReady(self.handle, ctx.handle, timeout)
-	def Connect(self, ctx):
-		"""Connect(object ctx) str
-		
-		Connect starts the client operation
-		"""
-		return _linksockslib.linksocks_LinkSocksClient_Connect(self.handle, ctx.handle)
-	def Close(self, goRun=False):
-		"""Close() 
-		
-		Close gracefully shuts down the LinkSocksClient
-		"""
-		_linksockslib.linksocks_LinkSocksClient_Close(self.handle, goRun)
-	def AddConnector(self, connectorToken):
-		"""AddConnector(str connectorToken) str, str
-		
-		AddConnector sends a request to add a new connector token and waits for response.
-		This function is only available in reverse proxy mode.
-		"""
-		return _linksockslib.linksocks_LinkSocksClient_AddConnector(self.handle, connectorToken)
-	def RemoveConnector(self, connectorToken):
-		"""RemoveConnector(str connectorToken) str
-		
-		RemoveConnector sends a request to remove a connector token and waits for response.
-		This function is only available in reverse proxy mode.
-		"""
-		return _linksockslib.linksocks_LinkSocksClient_RemoveConnector(self.handle, connectorToken)
-	def GetPartnersCount(self):
-		"""GetPartnersCount() int
-		
-		GetPartnersCount returns the current number of partners
-		"""
-		return _linksockslib.linksocks_LinkSocksClient_GetPartnersCount(self.handle)
+			_linksockslib.linksocks_TokenStatus_Token_Set(self.handle, value)
+	@property
+	def Type(self):
+		return _linksockslib.linksocks_TokenStatus_Type_Get(self.handle)
+	@Type.setter
+	def Type(self, value):
+		if isinstance(value, go.GoClass):
+			_linksockslib.linksocks_TokenStatus_Type_Set(self.handle, value.handle)
+		else:
+			_linksockslib.linksocks_TokenStatus_Type_Set(self.handle, value)
+	@property
+	def ClientsCount(self):
+		return _linksockslib.linksocks_TokenStatus_ClientsCount_Get(self.handle)
+	@ClientsCount.setter
+	def ClientsCount(self, value):
+		if isinstance(value, go.GoClass):
+			_linksockslib.linksocks_TokenStatus_ClientsCount_Set(self.handle, value.handle)
+		else:
+			_linksockslib.linksocks_TokenStatus_ClientsCount_Set(self.handle, value)
 
-# Python type for struct linksocks.LogEntry
-class LogEntry(go.GoClass):
-	"""LogEntry represents a single log entry with metadata\n"""
+# Python type for struct linksocks.DisconnectMessage
+class DisconnectMessage(go.GoClass):
+	"""DisconnectMessage represents a connection termination message\n"""
 	def __init__(self, *args, **kwargs):
 		"""
 		handle=A Go-side object is always initialized with an explicit handle=arg
@@ -3929,25 +4204,21 @@ class LogEntry(go.GoClass):
 			self.handle = args[0].handle
 			_linksockslib.IncRef(self.handle)
 		else:
-			self.handle = _linksockslib.linksocks_LogEntry_CTor()
+			self.handle = _linksockslib.linksocks_DisconnectMessage_CTor()
 			_linksockslib.IncRef(self.handle)
 			if  0 < len(args):
-				self.LoggerID = args[0]
-			if "LoggerID" in kwargs:
-				self.LoggerID = kwargs["LoggerID"]
+				self.ChannelID = args[0]
+			if "ChannelID" in kwargs:
+				self.ChannelID = kwargs["ChannelID"]
 			if  1 < len(args):
-				self.Message = args[1]
-			if "Message" in kwargs:
-				self.Message = kwargs["Message"]
-			if  2 < len(args):
-				self.Time = args[2]
-			if "Time" in kwargs:
-				self.Time = kwargs["Time"]
+				self.Error = args[1]
+			if "Error" in kwargs:
+				self.Error = kwargs["Error"]
 	def __del__(self):
 		_linksockslib.DecRef(self.handle)
 	def __str__(self):
 		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
-		sv = 'linksocks.LogEntry{'
+		sv = 'linksocks.DisconnectMessage{'
 		first = True
 		for v in pr:
 			if callable(v[1]):
@@ -3960,42 +4231,30 @@ class LogEntry(go.GoClass):
 		return sv + '}'
 	def __repr__(self):
 		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
-		sv = 'linksocks.LogEntry ( '
+		sv = 'linksocks.DisconnectMessage ( '
 		for v in pr:
 			if not callable(v[1]):
 				sv += v[0] + '=' + str(v[1]) + ', '
 		return sv + ')'
 	@property
-	def LoggerID(self):
-		return _linksockslib.linksocks_LogEntry_LoggerID_Get(self.handle)
-	@LoggerID.setter
-	def LoggerID(self, value):
-		if isinstance(value, go.GoClass):
-			_linksockslib.linksocks_LogEntry_LoggerID_Set(self.handle, value.handle)
-		else:
-			_linksockslib.linksocks_LogEntry_LoggerID_Set(self.handle, value)
-	@property
-	def Message(self):
-		return _linksockslib.linksocks_LogEntry_Message_Get(self.handle)
-	@Message.setter
-	def Message(self, value):
-		if isinstance(value, go.GoClass):
-			_linksockslib.linksocks_LogEntry_Message_Set(self.handle, value.handle)
-		else:
-			_linksockslib.linksocks_LogEntry_Message_Set(self.handle, value)
+	def ChannelID(self):
+		return go.uuid_UUID(handle=_linksockslib.linksocks_DisconnectMessage_ChannelID_Get(self.handle))
 	@property
-	def Time(self):
-		return _linksockslib.linksocks_LogEntry_Time_Get(self.handle)
-	@Time.setter
-	def Time(self, value):
+	def Error(self):
+		return _linksockslib.linksocks_DisconnectMessage_Error_Get(self.handle)
+	@Error.setter
+	def Error(self, value):
 		if isinstance(value, go.GoClass):
-			_linksockslib.linksocks_LogEntry_Time_Set(self.handle, value.handle)
+			_linksockslib.linksocks_DisconnectMessage_Error_Set(self.handle, value.handle)
 		else:
-			_linksockslib.linksocks_LogEntry_Time_Set(self.handle, value)
+			_linksockslib.linksocks_DisconnectMessage_Error_Set(self.handle, value)
+	def GetType(self):
+		"""GetType() str"""
+		return _linksockslib.linksocks_DisconnectMessage_GetType(self.handle)
 
-# Python type for struct linksocks.LogMessage
-class LogMessage(go.GoClass):
-	"""LogMessage represents a log message from server to client\n"""
+# Python type for struct linksocks.ReverseTokenStatus
+class ReverseTokenStatus(TokenStatus):
+	"""ReverseTokenStatus represents the status of a reverse token\n"""
 	def __init__(self, *args, **kwargs):
 		"""
 		handle=A Go-side object is always initialized with an explicit handle=arg
@@ -4009,21 +4268,21 @@ class LogMessage(go.GoClass):
 			self.handle = args[0].handle
 			_linksockslib.IncRef(self.handle)
 		else:
-			self.handle = _linksockslib.linksocks_LogMessage_CTor()
+			self.handle = _linksockslib.linksocks_ReverseTokenStatus_CTor()
 			_linksockslib.IncRef(self.handle)
-			if  0 < len(args):
-				self.Level = args[0]
-			if "Level" in kwargs:
-				self.Level = kwargs["Level"]
 			if  1 < len(args):
-				self.Msg = args[1]
-			if "Msg" in kwargs:
-				self.Msg = kwargs["Msg"]
+				self.Port = args[1]
+			if "Port" in kwargs:
+				self.Port = kwargs["Port"]
+			if  2 < len(args):
+				self.ConnectorTokens = args[2]
+			if "ConnectorTokens" in kwargs:
+				self.ConnectorTokens = kwargs["ConnectorTokens"]
 	def __del__(self):
 		_linksockslib.DecRef(self.handle)
 	def __str__(self):
 		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
-		sv = 'linksocks.LogMessage{'
+		sv = 'linksocks.ReverseTokenStatus{'
 		first = True
 		for v in pr:
 			if callable(v[1]):
@@ -4036,36 +4295,33 @@ class LogMessage(go.GoClass):
 		return sv + '}'
 	def __repr__(self):
 		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
-		sv = 'linksocks.LogMessage ( '
+		sv = 'linksocks.ReverseTokenStatus ( '
 		for v in pr:
 			if not callable(v[1]):
 				sv += v[0] + '=' + str(v[1]) + ', '
 		return sv + ')'
 	@property
-	def Level(self):
-		return _linksockslib.linksocks_LogMessage_Level_Get(self.handle)
-	@Level.setter
-	def Level(self, value):
+	def Port(self):
+		return _linksockslib.linksocks_ReverseTokenStatus_Port_Get(self.handle)
+	@Port.setter
+	def Port(self, value):
 		if isinstance(value, go.GoClass):
-			_linksockslib.linksocks_LogMessage_Level_Set(self.handle, value.handle)
+			_linksockslib.linksocks_ReverseTokenStatus_Port_Set(self.handle, value.handle)
 		else:
-			_linksockslib.linksocks_LogMessage_Level_Set(self.handle, value)
+			_linksockslib.linksocks_ReverseTokenStatus_Port_Set(self.handle, value)
 	@property
-	def Msg(self):
-		return _linksockslib.linksocks_LogMessage_Msg_Get(self.handle)
-	@Msg.setter
-	def Msg(self, value):
+	def ConnectorTokens(self):
+		return go.Slice_string(handle=_linksockslib.linksocks_ReverseTokenStatus_ConnectorTokens_Get(self.handle))
+	@ConnectorTokens.setter
+	def ConnectorTokens(self, value):
 		if isinstance(value, go.GoClass):
-			_linksockslib.linksocks_LogMessage_Msg_Set(self.handle, value.handle)
+			_linksockslib.linksocks_ReverseTokenStatus_ConnectorTokens_Set(self.handle, value.handle)
 		else:
-			_linksockslib.linksocks_LogMessage_Msg_Set(self.handle, value)
-	def GetType(self):
-		"""GetType() str"""
-		return _linksockslib.linksocks_LogMessage_GetType(self.handle)
+			raise TypeError("supplied argument type {t} is not a go.GoClass".format(t=type(value)))
 
-# Python type for struct linksocks.Relay
-class Relay(go.GoClass):
-	"""Relay handles stream transport between SOCKS5 and WebSocket\n"""
+# Python type for struct linksocks.ServerOption
+class ServerOption(go.GoClass):
+	"""ServerOption represents configuration options for LinkSocksServer\n"""
 	def __init__(self, *args, **kwargs):
 		"""
 		handle=A Go-side object is always initialized with an explicit handle=arg
@@ -4079,13 +4335,69 @@ class Relay(go.GoClass):
 			self.handle = args[0].handle
 			_linksockslib.IncRef(self.handle)
 		else:
-			self.handle = _linksockslib.linksocks_Relay_CTor()
+			self.handle = _linksockslib.linksocks_ServerOption_CTor()
 			_linksockslib.IncRef(self.handle)
+			if  0 < len(args):
+				self.WSHost = args[0]
+			if "WSHost" in kwargs:
+				self.WSHost = kwargs["WSHost"]
+			if  1 < len(args):
+				self.WSPort = args[1]
+			if "WSPort" in kwargs:
+				self.WSPort = kwargs["WSPort"]
+			if  2 < len(args):
+				self.SocksHost = args[2]
+			if "SocksHost" in kwargs:
+				self.SocksHost = kwargs["SocksHost"]
+			if  3 < len(args):
+				self.PortPool = args[3]
+			if "PortPool" in kwargs:
+				self.PortPool = kwargs["PortPool"]
+			if  4 < len(args):
+				self.SocksWaitClient = args[4]
+			if "SocksWaitClient" in kwargs:
+				self.SocksWaitClient = kwargs["SocksWaitClient"]
+			if  5 < len(args):
+				self.Logger = args[5]
+			if "Logger" in kwargs:
+				self.Logger = kwargs["Logger"]
+			if  6 < len(args):
+				self.BufferSize = args[6]
+			if "BufferSize" in kwargs:
+				self.BufferSize = kwargs["BufferSize"]
+			if  7 < len(args):
+				self.APIKey = args[7]
+			if "APIKey" in kwargs:
+				self.APIKey = kwargs["APIKey"]
+			if  8 < len(args):
+				self.ChannelTimeout = args[8]
+			if "ChannelTimeout" in kwargs:
+				self.ChannelTimeout = kwargs["ChannelTimeout"]
+			if  9 < len(args):
+				self.ConnectTimeout = args[9]
+			if "ConnectTimeout" in kwargs:
+				self.ConnectTimeout = kwargs["ConnectTimeout"]
+			if  10 < len(args):
+				self.FastOpen = args[10]
+			if "FastOpen" in kwargs:
+				self.FastOpen = kwargs["FastOpen"]
+			if  11 < len(args):
+				self.UpstreamProxy = args[11]
+			if "UpstreamProxy" in kwargs:
+				self.UpstreamProxy = kwargs["UpstreamProxy"]
+			if  12 < len(args):
+				self.UpstreamUsername = args[12]
+			if "UpstreamUsername" in kwargs:
+				self.UpstreamUsername = kwargs["UpstreamUsername"]
+			if  13 < len(args):
+				self.UpstreamPassword = args[13]
+			if "UpstreamPassword" in kwargs:
+				self.UpstreamPassword = kwargs["UpstreamPassword"]
 	def __del__(self):
 		_linksockslib.DecRef(self.handle)
 	def __str__(self):
 		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
-		sv = 'linksocks.Relay{'
+		sv = 'linksocks.ServerOption{'
 		first = True
 		for v in pr:
 			if callable(v[1]):
@@ -4098,689 +4410,215 @@ class Relay(go.GoClass):
 		return sv + '}'
 	def __repr__(self):
 		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
-		sv = 'linksocks.Relay ( '
+		sv = 'linksocks.ServerOption ( '
 		for v in pr:
 			if not callable(v[1]):
 				sv += v[0] + '=' + str(v[1]) + ', '
 		return sv + ')'
-	def RefuseSocksRequest(self, conn, reason):
-		"""RefuseSocksRequest(object conn, int reason) str
-		
-		RefuseSocksRequest refuses a SOCKS5 client request with the specified reason
-		"""
-		return _linksockslib.linksocks_Relay_RefuseSocksRequest(self.handle, conn.handle, reason)
-	def HandleNetworkConnection(self, ctx, ws, request):
-		"""HandleNetworkConnection(object ctx, object ws, object request) str
-		
-		HandleNetworkConnection handles network connection based on protocol type
-		"""
-		return _linksockslib.linksocks_Relay_HandleNetworkConnection(self.handle, ctx.handle, ws.handle, request.handle)
-	def HandleTCPConnection(self, ctx, ws, request):
-		"""HandleTCPConnection(object ctx, object ws, object request) str
-		
-		HandleTCPConnection handles TCP network connection
-		"""
-		return _linksockslib.linksocks_Relay_HandleTCPConnection(self.handle, ctx.handle, ws.handle, request.handle)
-	def HandleUDPConnection(self, ctx, ws, request):
-		"""HandleUDPConnection(object ctx, object ws, object request) str
-		
-		HandleUDPConnection handles UDP network connection
-		"""
-		return _linksockslib.linksocks_Relay_HandleUDPConnection(self.handle, ctx.handle, ws.handle, request.handle)
-	def HandleSocksRequest(self, ctx, ws, socksConn, socksUsername, socksPassword):
-		"""HandleSocksRequest(object ctx, object ws, object socksConn, str socksUsername, str socksPassword) str
-		
-		HandleSocksRequest handles incoming SOCKS5 client request
-		"""
-		return _linksockslib.linksocks_Relay_HandleSocksRequest(self.handle, ctx.handle, ws.handle, socksConn.handle, socksUsername, socksPassword)
-	def HandleRemoteTCPForward(self, ctx, ws, remoteConn, channelID):
-		"""HandleRemoteTCPForward(object ctx, object ws, object remoteConn, []int channelID) str
-		
-		HandleRemoteTCPForward handles remote TCP forwarding
-		"""
-		return _linksockslib.linksocks_Relay_HandleRemoteTCPForward(self.handle, ctx.handle, ws.handle, remoteConn.handle, channelID.handle)
-	def HandleRemoteUDPForward(self, ctx, ws, udpConn, channelID):
-		"""HandleRemoteUDPForward(object ctx, object ws, object udpConn, []int channelID) str
-		
-		HandleRemoteUDPForward handles remote UDP forwarding
-		"""
-		return _linksockslib.linksocks_Relay_HandleRemoteUDPForward(self.handle, ctx.handle, ws.handle, udpConn.handle, channelID.handle)
-	def HandleSocksTCPForward(self, ctx, ws, socksConn, channelID):
-		"""HandleSocksTCPForward(object ctx, object ws, object socksConn, []int channelID) str
-		
-		HandleSocksTCPForward handles TCP forwarding between SOCKS client and WebSocket
-		"""
-		return _linksockslib.linksocks_Relay_HandleSocksTCPForward(self.handle, ctx.handle, ws.handle, socksConn.handle, channelID.handle)
-	def HandleSocksUDPForward(self, ctx, ws, udpConn, socksConn, channelID):
-		"""HandleSocksUDPForward(object ctx, object ws, object udpConn, object socksConn, []int channelID) str
-		
-		HandleSocksUDPForward handles SOCKS5 UDP forwarding
-		"""
-		return _linksockslib.linksocks_Relay_HandleSocksUDPForward(self.handle, ctx.handle, ws.handle, udpConn.handle, socksConn.handle, channelID.handle)
-	def Close(self, goRun=False):
-		"""Close() 
-		
-		Close gracefully shuts down the Relay
-		"""
-		_linksockslib.linksocks_Relay_Close(self.handle, goRun)
-	def SetConnectionSuccess(self, channelID, goRun=False):
-		"""SetConnectionSuccess([]int channelID) 
-		
-		SetConnectionSuccess sets the connection success status for a channel
-		"""
-		_linksockslib.linksocks_Relay_SetConnectionSuccess(self.handle, channelID.handle, goRun)
-
-# Python type for struct linksocks.ReverseTokenOptions
-class ReverseTokenOptions(go.GoClass):
-	"""ReverseTokenOptions represents configuration options for reverse token\n"""
-	def __init__(self, *args, **kwargs):
-		"""
-		handle=A Go-side object is always initialized with an explicit handle=arg
-		otherwise parameters can be unnamed in order of field names or named fields
-		in which case a new Go object is constructed first
-		"""
-		if len(kwargs) == 1 and 'handle' in kwargs:
-			self.handle = kwargs['handle']
-			_linksockslib.IncRef(self.handle)
-		elif len(args) == 1 and isinstance(args[0], go.GoClass):
-			self.handle = args[0].handle
-			_linksockslib.IncRef(self.handle)
+	@property
+	def WSHost(self):
+		return _linksockslib.linksocks_ServerOption_WSHost_Get(self.handle)
+	@WSHost.setter
+	def WSHost(self, value):
+		if isinstance(value, go.GoClass):
+			_linksockslib.linksocks_ServerOption_WSHost_Set(self.handle, value.handle)
 		else:
-			self.handle = _linksockslib.linksocks_ReverseTokenOptions_CTor()
-			_linksockslib.IncRef(self.handle)
-			if  0 < len(args):
-				self.Token = args[0]
-			if "Token" in kwargs:
-				self.Token = kwargs["Token"]
-			if  1 < len(args):
-				self.Port = args[1]
-			if "Port" in kwargs:
-				self.Port = kwargs["Port"]
-			if  2 < len(args):
-				self.Username = args[2]
-			if "Username" in kwargs:
-				self.Username = kwargs["Username"]
-			if  3 < len(args):
-				self.Password = args[3]
-			if "Password" in kwargs:
-				self.Password = kwargs["Password"]
-			if  4 < len(args):
-				self.AllowManageConnector = args[4]
-			if "AllowManageConnector" in kwargs:
-				self.AllowManageConnector = kwargs["AllowManageConnector"]
-	def __del__(self):
-		_linksockslib.DecRef(self.handle)
-	def __str__(self):
-		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
-		sv = 'linksocks.ReverseTokenOptions{'
-		first = True
-		for v in pr:
-			if callable(v[1]):
-				continue
-			if first:
-				first = False
-			else:
-				sv += ', '
-			sv += v[0] + '=' + str(v[1])
-		return sv + '}'
-	def __repr__(self):
-		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
-		sv = 'linksocks.ReverseTokenOptions ( '
-		for v in pr:
-			if not callable(v[1]):
-				sv += v[0] + '=' + str(v[1]) + ', '
-		return sv + ')'
+			_linksockslib.linksocks_ServerOption_WSHost_Set(self.handle, value)
 	@property
-	def Token(self):
-		return _linksockslib.linksocks_ReverseTokenOptions_Token_Get(self.handle)
-	@Token.setter
-	def Token(self, value):
+	def WSPort(self):
+		return _linksockslib.linksocks_ServerOption_WSPort_Get(self.handle)
+	@WSPort.setter
+	def WSPort(self, value):
 		if isinstance(value, go.GoClass):
-			_linksockslib.linksocks_ReverseTokenOptions_Token_Set(self.handle, value.handle)
+			_linksockslib.linksocks_ServerOption_WSPort_Set(self.handle, value.handle)
 		else:
-			_linksockslib.linksocks_ReverseTokenOptions_Token_Set(self.handle, value)
+			_linksockslib.linksocks_ServerOption_WSPort_Set(self.handle, value)
 	@property
-	def Port(self):
-		return _linksockslib.linksocks_ReverseTokenOptions_Port_Get(self.handle)
-	@Port.setter
-	def Port(self, value):
+	def SocksHost(self):
+		return _linksockslib.linksocks_ServerOption_SocksHost_Get(self.handle)
+	@SocksHost.setter
+	def SocksHost(self, value):
 		if isinstance(value, go.GoClass):
-			_linksockslib.linksocks_ReverseTokenOptions_Port_Set(self.handle, value.handle)
+			_linksockslib.linksocks_ServerOption_SocksHost_Set(self.handle, value.handle)
 		else:
-			_linksockslib.linksocks_ReverseTokenOptions_Port_Set(self.handle, value)
+			_linksockslib.linksocks_ServerOption_SocksHost_Set(self.handle, value)
 	@property
-	def Username(self):
-		return _linksockslib.linksocks_ReverseTokenOptions_Username_Get(self.handle)
-	@Username.setter
-	def Username(self, value):
+	def PortPool(self):
+		return PortPool(handle=_linksockslib.linksocks_ServerOption_PortPool_Get(self.handle))
+	@PortPool.setter
+	def PortPool(self, value):
 		if isinstance(value, go.GoClass):
-			_linksockslib.linksocks_ReverseTokenOptions_Username_Set(self.handle, value.handle)
+			_linksockslib.linksocks_ServerOption_PortPool_Set(self.handle, value.handle)
 		else:
-			_linksockslib.linksocks_ReverseTokenOptions_Username_Set(self.handle, value)
+			raise TypeError("supplied argument type {t} is not a go.GoClass".format(t=type(value)))
 	@property
-	def Password(self):
-		return _linksockslib.linksocks_ReverseTokenOptions_Password_Get(self.handle)
-	@Password.setter
-	def Password(self, value):
+	def SocksWaitClient(self):
+		return _linksockslib.linksocks_ServerOption_SocksWaitClient_Get(self.handle)
+	@SocksWaitClient.setter
+	def SocksWaitClient(self, value):
 		if isinstance(value, go.GoClass):
-			_linksockslib.linksocks_ReverseTokenOptions_Password_Set(self.handle, value.handle)
+			_linksockslib.linksocks_ServerOption_SocksWaitClient_Set(self.handle, value.handle)
 		else:
-			_linksockslib.linksocks_ReverseTokenOptions_Password_Set(self.handle, value)
+			_linksockslib.linksocks_ServerOption_SocksWaitClient_Set(self.handle, value)
 	@property
-	def AllowManageConnector(self):
-		return _linksockslib.linksocks_ReverseTokenOptions_AllowManageConnector_Get(self.handle)
-	@AllowManageConnector.setter
-	def AllowManageConnector(self, value):
+	def Logger(self):
+		return go.zerolog_Logger(handle=_linksockslib.linksocks_ServerOption_Logger_Get(self.handle))
+	@Logger.setter
+	def Logger(self, value):
 		if isinstance(value, go.GoClass):
-			_linksockslib.linksocks_ReverseTokenOptions_AllowManageConnector_Set(self.handle, value.handle)
+			_linksockslib.linksocks_ServerOption_Logger_Set(self.handle, value.handle)
 		else:
-			_linksockslib.linksocks_ReverseTokenOptions_AllowManageConnector_Set(self.handle, value)
-
-# Python type for struct linksocks.AuthMessage
-class AuthMessage(go.GoClass):
-	"""AuthMessage represents an authentication request\n"""
-	def __init__(self, *args, **kwargs):
-		"""
-		handle=A Go-side object is always initialized with an explicit handle=arg
-		otherwise parameters can be unnamed in order of field names or named fields
-		in which case a new Go object is constructed first
-		"""
-		if len(kwargs) == 1 and 'handle' in kwargs:
-			self.handle = kwargs['handle']
-			_linksockslib.IncRef(self.handle)
-		elif len(args) == 1 and isinstance(args[0], go.GoClass):
-			self.handle = args[0].handle
-			_linksockslib.IncRef(self.handle)
+			raise TypeError("supplied argument type {t} is not a go.GoClass".format(t=type(value)))
+	@property
+	def BufferSize(self):
+		return _linksockslib.linksocks_ServerOption_BufferSize_Get(self.handle)
+	@BufferSize.setter
+	def BufferSize(self, value):
+		if isinstance(value, go.GoClass):
+			_linksockslib.linksocks_ServerOption_BufferSize_Set(self.handle, value.handle)
 		else:
-			self.handle = _linksockslib.linksocks_AuthMessage_CTor()
-			_linksockslib.IncRef(self.handle)
-			if  0 < len(args):
-				self.Token = args[0]
-			if "Token" in kwargs:
-				self.Token = kwargs["Token"]
-			if  1 < len(args):
-				self.Reverse = args[1]
-			if "Reverse" in kwargs:
-				self.Reverse = kwargs["Reverse"]
-			if  2 < len(args):
-				self.Instance = args[2]
-			if "Instance" in kwargs:
-				self.Instance = kwargs["Instance"]
-	def __del__(self):
-		_linksockslib.DecRef(self.handle)
-	def __str__(self):
-		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
-		sv = 'linksocks.AuthMessage{'
-		first = True
-		for v in pr:
-			if callable(v[1]):
-				continue
-			if first:
-				first = False
-			else:
-				sv += ', '
-			sv += v[0] + '=' + str(v[1])
-		return sv + '}'
-	def __repr__(self):
-		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
-		sv = 'linksocks.AuthMessage ( '
-		for v in pr:
-			if not callable(v[1]):
-				sv += v[0] + '=' + str(v[1]) + ', '
-		return sv + ')'
+			_linksockslib.linksocks_ServerOption_BufferSize_Set(self.handle, value)
 	@property
-	def Token(self):
-		return _linksockslib.linksocks_AuthMessage_Token_Get(self.handle)
-	@Token.setter
-	def Token(self, value):
+	def APIKey(self):
+		return _linksockslib.linksocks_ServerOption_APIKey_Get(self.handle)
+	@APIKey.setter
+	def APIKey(self, value):
 		if isinstance(value, go.GoClass):
-			_linksockslib.linksocks_AuthMessage_Token_Set(self.handle, value.handle)
+			_linksockslib.linksocks_ServerOption_APIKey_Set(self.handle, value.handle)
 		else:
-			_linksockslib.linksocks_AuthMessage_Token_Set(self.handle, value)
+			_linksockslib.linksocks_ServerOption_APIKey_Set(self.handle, value)
 	@property
-	def Reverse(self):
-		return _linksockslib.linksocks_AuthMessage_Reverse_Get(self.handle)
-	@Reverse.setter
-	def Reverse(self, value):
+	def ChannelTimeout(self):
+		return _linksockslib.linksocks_ServerOption_ChannelTimeout_Get(self.handle)
+	@ChannelTimeout.setter
+	def ChannelTimeout(self, value):
 		if isinstance(value, go.GoClass):
-			_linksockslib.linksocks_AuthMessage_Reverse_Set(self.handle, value.handle)
+			_linksockslib.linksocks_ServerOption_ChannelTimeout_Set(self.handle, value.handle)
 		else:
-			_linksockslib.linksocks_AuthMessage_Reverse_Set(self.handle, value)
+			_linksockslib.linksocks_ServerOption_ChannelTimeout_Set(self.handle, value)
 	@property
-	def Instance(self):
-		return go.uuid_UUID(handle=_linksockslib.linksocks_AuthMessage_Instance_Get(self.handle))
-	def GetType(self):
-		"""GetType() str"""
-		return _linksockslib.linksocks_AuthMessage_GetType(self.handle)
-
-# Python type for struct linksocks.CLI
-class CLI(go.GoClass):
-	"""CLI represents the command-line interface for LinkSocks\n"""
-	def __init__(self, *args, **kwargs):
-		"""
-		handle=A Go-side object is always initialized with an explicit handle=arg
-		otherwise parameters can be unnamed in order of field names or named fields
-		in which case a new Go object is constructed first
-		"""
-		if len(kwargs) == 1 and 'handle' in kwargs:
-			self.handle = kwargs['handle']
-			_linksockslib.IncRef(self.handle)
-		elif len(args) == 1 and isinstance(args[0], go.GoClass):
-			self.handle = args[0].handle
-			_linksockslib.IncRef(self.handle)
+	def ConnectTimeout(self):
+		return _linksockslib.linksocks_ServerOption_ConnectTimeout_Get(self.handle)
+	@ConnectTimeout.setter
+	def ConnectTimeout(self, value):
+		if isinstance(value, go.GoClass):
+			_linksockslib.linksocks_ServerOption_ConnectTimeout_Set(self.handle, value.handle)
 		else:
-			self.handle = _linksockslib.linksocks_CLI_CTor()
-			_linksockslib.IncRef(self.handle)
-	def __del__(self):
-		_linksockslib.DecRef(self.handle)
-	def __str__(self):
-		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
-		sv = 'linksocks.CLI{'
-		first = True
-		for v in pr:
-			if callable(v[1]):
-				continue
-			if first:
-				first = False
-			else:
-				sv += ', '
-			sv += v[0] + '=' + str(v[1])
-		return sv + '}'
-	def __repr__(self):
-		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
-		sv = 'linksocks.CLI ( '
-		for v in pr:
-			if not callable(v[1]):
-				sv += v[0] + '=' + str(v[1]) + ', '
-		return sv + ')'
-	def Execute(self):
-		"""Execute() str
-		
-		Execute runs the CLI application
-		"""
-		return _linksockslib.linksocks_CLI_Execute(self.handle)
-
-# Python type for struct linksocks.DataMessage
-class DataMessage(go.GoClass):
-	"""DataMessage represents a data transfer message\n"""
-	def __init__(self, *args, **kwargs):
-		"""
-		handle=A Go-side object is always initialized with an explicit handle=arg
-		otherwise parameters can be unnamed in order of field names or named fields
-		in which case a new Go object is constructed first
-		"""
-		if len(kwargs) == 1 and 'handle' in kwargs:
-			self.handle = kwargs['handle']
-			_linksockslib.IncRef(self.handle)
-		elif len(args) == 1 and isinstance(args[0], go.GoClass):
-			self.handle = args[0].handle
-			_linksockslib.IncRef(self.handle)
+			_linksockslib.linksocks_ServerOption_ConnectTimeout_Set(self.handle, value)
+	@property
+	def FastOpen(self):
+		return _linksockslib.linksocks_ServerOption_FastOpen_Get(self.handle)
+	@FastOpen.setter
+	def FastOpen(self, value):
+		if isinstance(value, go.GoClass):
+			_linksockslib.linksocks_ServerOption_FastOpen_Set(self.handle, value.handle)
 		else:
-			self.handle = _linksockslib.linksocks_DataMessage_CTor()
-			_linksockslib.IncRef(self.handle)
-			if  0 < len(args):
-				self.Protocol = args[0]
-			if "Protocol" in kwargs:
-				self.Protocol = kwargs["Protocol"]
-			if  1 < len(args):
-				self.ChannelID = args[1]
-			if "ChannelID" in kwargs:
-				self.ChannelID = kwargs["ChannelID"]
-			if  2 < len(args):
-				self.Data = args[2]
-			if "Data" in kwargs:
-				self.Data = kwargs["Data"]
-			if  3 < len(args):
-				self.Compression = args[3]
-			if "Compression" in kwargs:
-				self.Compression = kwargs["Compression"]
-			if  4 < len(args):
-				self.Address = args[4]
-			if "Address" in kwargs:
-				self.Address = kwargs["Address"]
-			if  5 < len(args):
-				self.Port = args[5]
-			if "Port" in kwargs:
-				self.Port = kwargs["Port"]
-			if  6 < len(args):
-				self.TargetAddr = args[6]
-			if "TargetAddr" in kwargs:
-				self.TargetAddr = kwargs["TargetAddr"]
-			if  7 < len(args):
-				self.TargetPort = args[7]
-			if "TargetPort" in kwargs:
-				self.TargetPort = kwargs["TargetPort"]
-	def __del__(self):
-		_linksockslib.DecRef(self.handle)
-	def __str__(self):
-		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
-		sv = 'linksocks.DataMessage{'
-		first = True
-		for v in pr:
-			if callable(v[1]):
-				continue
-			if first:
-				first = False
-			else:
-				sv += ', '
-			sv += v[0] + '=' + str(v[1])
-		return sv + '}'
-	def __repr__(self):
-		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
-		sv = 'linksocks.DataMessage ( '
-		for v in pr:
-			if not callable(v[1]):
-				sv += v[0] + '=' + str(v[1]) + ', '
-		return sv + ')'
-	@property
-	def Protocol(self):
-		return _linksockslib.linksocks_DataMessage_Protocol_Get(self.handle)
-	@Protocol.setter
-	def Protocol(self, value):
-		if isinstance(value, go.GoClass):
-			_linksockslib.linksocks_DataMessage_Protocol_Set(self.handle, value.handle)
-		else:
-			_linksockslib.linksocks_DataMessage_Protocol_Set(self.handle, value)
-	@property
-	def ChannelID(self):
-		return go.uuid_UUID(handle=_linksockslib.linksocks_DataMessage_ChannelID_Get(self.handle))
-	@property
-	def Data(self):
-		return go.Slice_byte(handle=_linksockslib.linksocks_DataMessage_Data_Get(self.handle))
-	@Data.setter
-	def Data(self, value):
-		if isinstance(value, go.GoClass):
-			_linksockslib.linksocks_DataMessage_Data_Set(self.handle, value.handle)
-		else:
-			raise TypeError("supplied argument type {t} is not a go.GoClass".format(t=type(value)))
-	@property
-	def Compression(self):
-		return _linksockslib.linksocks_DataMessage_Compression_Get(self.handle)
-	@Compression.setter
-	def Compression(self, value):
-		if isinstance(value, go.GoClass):
-			_linksockslib.linksocks_DataMessage_Compression_Set(self.handle, value.handle)
-		else:
-			_linksockslib.linksocks_DataMessage_Compression_Set(self.handle, value)
-	@property
-	def Address(self):
-		return _linksockslib.linksocks_DataMessage_Address_Get(self.handle)
-	@Address.setter
-	def Address(self, value):
-		if isinstance(value, go.GoClass):
-			_linksockslib.linksocks_DataMessage_Address_Set(self.handle, value.handle)
-		else:
-			_linksockslib.linksocks_DataMessage_Address_Set(self.handle, value)
+			_linksockslib.linksocks_ServerOption_FastOpen_Set(self.handle, value)
 	@property
-	def Port(self):
-		return _linksockslib.linksocks_DataMessage_Port_Get(self.handle)
-	@Port.setter
-	def Port(self, value):
+	def UpstreamProxy(self):
+		return _linksockslib.linksocks_ServerOption_UpstreamProxy_Get(self.handle)
+	@UpstreamProxy.setter
+	def UpstreamProxy(self, value):
 		if isinstance(value, go.GoClass):
-			_linksockslib.linksocks_DataMessage_Port_Set(self.handle, value.handle)
+			_linksockslib.linksocks_ServerOption_UpstreamProxy_Set(self.handle, value.handle)
 		else:
-			_linksockslib.linksocks_DataMessage_Port_Set(self.handle, value)
+			_linksockslib.linksocks_ServerOption_UpstreamProxy_Set(self.handle, value)
 	@property
-	def TargetAddr(self):
-		return _linksockslib.linksocks_DataMessage_TargetAddr_Get(self.handle)
-	@TargetAddr.setter
-	def TargetAddr(self, value):
+	def UpstreamUsername(self):
+		return _linksockslib.linksocks_ServerOption_UpstreamUsername_Get(self.handle)
+	@UpstreamUsername.setter
+	def UpstreamUsername(self, value):
 		if isinstance(value, go.GoClass):
-			_linksockslib.linksocks_DataMessage_TargetAddr_Set(self.handle, value.handle)
+			_linksockslib.linksocks_ServerOption_UpstreamUsername_Set(self.handle, value.handle)
 		else:
-			_linksockslib.linksocks_DataMessage_TargetAddr_Set(self.handle, value)
+			_linksockslib.linksocks_ServerOption_UpstreamUsername_Set(self.handle, value)
 	@property
-	def TargetPort(self):
-		return _linksockslib.linksocks_DataMessage_TargetPort_Get(self.handle)
-	@TargetPort.setter
-	def TargetPort(self, value):
+	def UpstreamPassword(self):
+		return _linksockslib.linksocks_ServerOption_UpstreamPassword_Get(self.handle)
+	@UpstreamPassword.setter
+	def UpstreamPassword(self, value):
 		if isinstance(value, go.GoClass):
-			_linksockslib.linksocks_DataMessage_TargetPort_Set(self.handle, value.handle)
-		else:
-			_linksockslib.linksocks_DataMessage_TargetPort_Set(self.handle, value)
-	def GetType(self):
-		"""GetType() str"""
-		return _linksockslib.linksocks_DataMessage_GetType(self.handle)
-
-# Python type for struct linksocks.DynamicForwarder
-class DynamicForwarder(go.GoClass):
-	"""DynamicForwarder handles dynamic batching and sending of network data\n"""
-	def __init__(self, *args, **kwargs):
-		"""
-		handle=A Go-side object is always initialized with an explicit handle=arg
-		otherwise parameters can be unnamed in order of field names or named fields
-		in which case a new Go object is constructed first
-		"""
-		if len(kwargs) == 1 and 'handle' in kwargs:
-			self.handle = kwargs['handle']
-			_linksockslib.IncRef(self.handle)
-		elif len(args) == 1 and isinstance(args[0], go.GoClass):
-			self.handle = args[0].handle
-			_linksockslib.IncRef(self.handle)
+			_linksockslib.linksocks_ServerOption_UpstreamPassword_Set(self.handle, value.handle)
 		else:
-			self.handle = _linksockslib.linksocks_DynamicForwarder_CTor()
-			_linksockslib.IncRef(self.handle)
-	def __del__(self):
-		_linksockslib.DecRef(self.handle)
-	def __str__(self):
-		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
-		sv = 'linksocks.DynamicForwarder{'
-		first = True
-		for v in pr:
-			if callable(v[1]):
-				continue
-			if first:
-				first = False
-			else:
-				sv += ', '
-			sv += v[0] + '=' + str(v[1])
-		return sv + '}'
-	def __repr__(self):
-		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
-		sv = 'linksocks.DynamicForwarder ( '
-		for v in pr:
-			if not callable(v[1]):
-				sv += v[0] + '=' + str(v[1]) + ', '
-		return sv + ')'
-	def ProcessReads(self, conn, goRun=False):
-		"""ProcessReads(object conn) 
+			_linksockslib.linksocks_ServerOption_UpstreamPassword_Set(self.handle, value)
+	def WithWSHost(self, host):
+		"""WithWSHost(str host) object
 		
-		ProcessReads handles reading from a network connection and forwarding to WebSocket with dynamic batching
+		WithWSHost sets the WebSocket host
 		"""
-		_linksockslib.linksocks_DynamicForwarder_ProcessReads(self.handle, conn.handle, goRun)
-	def ProcessReadsImmediate(self, conn, goRun=False):
-		"""ProcessReadsImmediate(object conn) 
+		return ServerOption(handle=_linksockslib.linksocks_ServerOption_WithWSHost(self.handle, host))
+	def WithWSPort(self, port):
+		"""WithWSPort(int port) object
 		
-		processReadsImmediate handles reading directly without batching
+		WithWSPort sets the WebSocket port
 		"""
-		_linksockslib.linksocks_DynamicForwarder_ProcessReadsImmediate(self.handle, conn.handle, goRun)
-	def ProcessUDPReads(self, conn, goRun=False):
-		"""ProcessUDPReads(object conn) 
+		return ServerOption(handle=_linksockslib.linksocks_ServerOption_WithWSPort(self.handle, port))
+	def WithSocksHost(self, host):
+		"""WithSocksHost(str host) object
 		
-		ProcessUDPReads handles reading from a UDP connection with appropriate metadata
-		"""
-		_linksockslib.linksocks_DynamicForwarder_ProcessUDPReads(self.handle, conn.handle, goRun)
-
-# Python type for struct linksocks.TokenStatus
-class TokenStatus(go.GoClass):
-	"""TokenStatus represents the status of a token\n"""
-	def __init__(self, *args, **kwargs):
-		"""
-		handle=A Go-side object is always initialized with an explicit handle=arg
-		otherwise parameters can be unnamed in order of field names or named fields
-		in which case a new Go object is constructed first
-		"""
-		if len(kwargs) == 1 and 'handle' in kwargs:
-			self.handle = kwargs['handle']
-			_linksockslib.IncRef(self.handle)
-		elif len(args) == 1 and isinstance(args[0], go.GoClass):
-			self.handle = args[0].handle
-			_linksockslib.IncRef(self.handle)
-		else:
-			self.handle = _linksockslib.linksocks_TokenStatus_CTor()
-			_linksockslib.IncRef(self.handle)
-			if  0 < len(args):
-				self.Token = args[0]
-			if "Token" in kwargs:
-				self.Token = kwargs["Token"]
-			if  1 < len(args):
-				self.Type = args[1]
-			if "Type" in kwargs:
-				self.Type = kwargs["Type"]
-			if  2 < len(args):
-				self.ClientsCount = args[2]
-			if "ClientsCount" in kwargs:
-				self.ClientsCount = kwargs["ClientsCount"]
-	def __del__(self):
-		_linksockslib.DecRef(self.handle)
-	def __str__(self):
-		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
-		sv = 'linksocks.TokenStatus{'
-		first = True
-		for v in pr:
-			if callable(v[1]):
-				continue
-			if first:
-				first = False
-			else:
-				sv += ', '
-			sv += v[0] + '=' + str(v[1])
-		return sv + '}'
-	def __repr__(self):
-		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
-		sv = 'linksocks.TokenStatus ( '
-		for v in pr:
-			if not callable(v[1]):
-				sv += v[0] + '=' + str(v[1]) + ', '
-		return sv + ')'
-	@property
-	def Token(self):
-		return _linksockslib.linksocks_TokenStatus_Token_Get(self.handle)
-	@Token.setter
-	def Token(self, value):
-		if isinstance(value, go.GoClass):
-			_linksockslib.linksocks_TokenStatus_Token_Set(self.handle, value.handle)
-		else:
-			_linksockslib.linksocks_TokenStatus_Token_Set(self.handle, value)
-	@property
-	def Type(self):
-		return _linksockslib.linksocks_TokenStatus_Type_Get(self.handle)
-	@Type.setter
-	def Type(self, value):
-		if isinstance(value, go.GoClass):
-			_linksockslib.linksocks_TokenStatus_Type_Set(self.handle, value.handle)
-		else:
-			_linksockslib.linksocks_TokenStatus_Type_Set(self.handle, value)
-	@property
-	def ClientsCount(self):
-		return _linksockslib.linksocks_TokenStatus_ClientsCount_Get(self.handle)
-	@ClientsCount.setter
-	def ClientsCount(self, value):
-		if isinstance(value, go.GoClass):
-			_linksockslib.linksocks_TokenStatus_ClientsCount_Set(self.handle, value.handle)
-		else:
-			_linksockslib.linksocks_TokenStatus_ClientsCount_Set(self.handle, value)
-
-# Python type for struct linksocks.LinkSocksServer
-class LinkSocksServer(go.GoClass):
-	"""LinkSocksServer represents a SOCKS5 over WebSocket protocol server\n"""
-	def __init__(self, *args, **kwargs):
-		"""
-		handle=A Go-side object is always initialized with an explicit handle=arg
-		otherwise parameters can be unnamed in order of field names or named fields
-		in which case a new Go object is constructed first
+		WithSocksHost sets the SOCKS host
 		"""
-		if len(kwargs) == 1 and 'handle' in kwargs:
-			self.handle = kwargs['handle']
-			_linksockslib.IncRef(self.handle)
-		elif len(args) == 1 and isinstance(args[0], go.GoClass):
-			self.handle = args[0].handle
-			_linksockslib.IncRef(self.handle)
-		else:
-			self.handle = _linksockslib.linksocks_LinkSocksServer_CTor()
-			_linksockslib.IncRef(self.handle)
-	def __del__(self):
-		_linksockslib.DecRef(self.handle)
-	def __str__(self):
-		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
-		sv = 'linksocks.LinkSocksServer{'
-		first = True
-		for v in pr:
-			if callable(v[1]):
-				continue
-			if first:
-				first = False
-			else:
-				sv += ', '
-			sv += v[0] + '=' + str(v[1])
-		return sv + '}'
-	def __repr__(self):
-		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
-		sv = 'linksocks.LinkSocksServer ( '
-		for v in pr:
-			if not callable(v[1]):
-				sv += v[0] + '=' + str(v[1]) + ', '
-		return sv + ')'
-	def AddReverseToken(self, opts):
-		"""AddReverseToken(object opts) object, str
+		return ServerOption(handle=_linksockslib.linksocks_ServerOption_WithSocksHost(self.handle, host))
+	def WithPortPool(self, pool):
+		"""WithPortPool(object pool) object
 		
-		AddReverseToken adds a new token for reverse socks and assigns a port
+		WithPortPool sets the port pool
 		"""
-		return ReverseTokenResult(handle=_linksockslib.linksocks_LinkSocksServer_AddReverseToken(self.handle, opts.handle))
-	def AddForwardToken(self, token):
-		"""AddForwardToken(str token) str, str
+		return ServerOption(handle=_linksockslib.linksocks_ServerOption_WithPortPool(self.handle, pool.handle))
+	def WithSocksWaitClient(self, wait):
+		"""WithSocksWaitClient(bool wait) object
 		
-		AddForwardToken adds a new token for forward socks proxy
+		WithSocksWaitClient sets whether to wait for client before starting SOCKS server
 		"""
-		return _linksockslib.linksocks_LinkSocksServer_AddForwardToken(self.handle, token)
-	def AddConnectorToken(self, connectorToken, reverseToken):
-		"""AddConnectorToken(str connectorToken, str reverseToken) str, str
+		return ServerOption(handle=_linksockslib.linksocks_ServerOption_WithSocksWaitClient(self.handle, wait))
+	def WithLogger(self, logger):
+		"""WithLogger(object logger) object
 		
-		AddConnectorToken adds a new connector token that forwards requests to a reverse token
+		WithLogger sets the logger
 		"""
-		return _linksockslib.linksocks_LinkSocksServer_AddConnectorToken(self.handle, connectorToken, reverseToken)
-	def RemoveToken(self, token):
-		"""RemoveToken(str token) bool
+		return ServerOption(handle=_linksockslib.linksocks_ServerOption_WithLogger(self.handle, logger.handle))
+	def WithBufferSize(self, size):
+		"""WithBufferSize(int size) object
 		
-		RemoveToken removes a token and disconnects all its clients
+		WithBufferSize sets the buffer size for data transfer
 		"""
-		return _linksockslib.linksocks_LinkSocksServer_RemoveToken(self.handle, token)
-	def Serve(self, ctx):
-		"""Serve(object ctx) str
+		return ServerOption(handle=_linksockslib.linksocks_ServerOption_WithBufferSize(self.handle, size))
+	def WithAPI(self, apiKey):
+		"""WithAPI(str apiKey) object
 		
-		Serve starts the WebSocket server and waits for clients
+		WithAPI sets apiKey to enable the HTTP API
 		"""
-		return _linksockslib.linksocks_LinkSocksServer_Serve(self.handle, ctx.handle)
-	def WaitReady(self, ctx, timeout):
-		"""WaitReady(object ctx, long timeout) str
+		return ServerOption(handle=_linksockslib.linksocks_ServerOption_WithAPI(self.handle, apiKey))
+	def WithChannelTimeout(self, timeout):
+		"""WithChannelTimeout(long timeout) object
 		
-		WaitReady starts the server and waits for the server to be ready with optional timeout
+		WithChannelTimeout sets the channel timeout duration
 		"""
-		return _linksockslib.linksocks_LinkSocksServer_WaitReady(self.handle, ctx.handle, timeout)
-	def Close(self, goRun=False):
-		"""Close() 
+		return ServerOption(handle=_linksockslib.linksocks_ServerOption_WithChannelTimeout(self.handle, timeout))
+	def WithConnectTimeout(self, timeout):
+		"""WithConnectTimeout(long timeout) object
 		
-		Close gracefully shuts down the LinkSocksServer
+		WithConnectTimeout sets the connect timeout duration
 		"""
-		_linksockslib.linksocks_LinkSocksServer_Close(self.handle, goRun)
-	def GetClientCount(self):
-		"""GetClientCount() int
+		return ServerOption(handle=_linksockslib.linksocks_ServerOption_WithConnectTimeout(self.handle, timeout))
+	def WithFastOpen(self, fastOpen):
+		"""WithFastOpen(bool fastOpen) object
 		
-		GetClientCount returns the total number of connected clients
+		WithFastOpen controls whether to wait for connect success response
 		"""
-		return _linksockslib.linksocks_LinkSocksServer_GetClientCount(self.handle)
-	def HasClients(self):
-		"""HasClients() bool
+		return ServerOption(handle=_linksockslib.linksocks_ServerOption_WithFastOpen(self.handle, fastOpen))
+	def WithUpstreamProxy(self, proxy):
+		"""WithUpstreamProxy(str proxy) object
 		
-		HasClients returns true if there are any connected clients
+		WithUpstreamProxy sets the upstream SOCKS5 proxy
 		"""
-		return _linksockslib.linksocks_LinkSocksServer_HasClients(self.handle)
-	def GetTokenClientCount(self, token):
-		"""GetTokenClientCount(str token) int
+		return ServerOption(handle=_linksockslib.linksocks_ServerOption_WithUpstreamProxy(self.handle, proxy))
+	def WithUpstreamAuth(self, username, password):
+		"""WithUpstreamAuth(str username, str password) object
 		
-		GetTokenClientCount counts clients connected for a given token
+		WithUpstreamAuth sets the upstream SOCKS5 proxy authentication
 		"""
-		return _linksockslib.linksocks_LinkSocksServer_GetTokenClientCount(self.handle, token)
+		return ServerOption(handle=_linksockslib.linksocks_ServerOption_WithUpstreamAuth(self.handle, username, password))
 
 # Python type for struct linksocks.TokenRequest
 class TokenRequest(go.GoClass):
@@ -4914,9 +4752,256 @@ class TokenRequest(go.GoClass):
 		else:
 			_linksockslib.linksocks_TokenRequest_AllowManageConnector_Set(self.handle, value)
 
-# Python type for struct linksocks.ReverseTokenStatus
-class ReverseTokenStatus(TokenStatus):
-	"""ReverseTokenStatus represents the status of a reverse token\n"""
+# Python type for struct linksocks.WSConn
+class WSConn(go.GoClass):
+	"""WSConn wraps a websocket.Conn with mutex protection\n"""
+	def __init__(self, *args, **kwargs):
+		"""
+		handle=A Go-side object is always initialized with an explicit handle=arg
+		otherwise parameters can be unnamed in order of field names or named fields
+		in which case a new Go object is constructed first
+		"""
+		if len(kwargs) == 1 and 'handle' in kwargs:
+			self.handle = kwargs['handle']
+			_linksockslib.IncRef(self.handle)
+		elif len(args) == 1 and isinstance(args[0], go.GoClass):
+			self.handle = args[0].handle
+			_linksockslib.IncRef(self.handle)
+		else:
+			self.handle = _linksockslib.linksocks_WSConn_CTor()
+			_linksockslib.IncRef(self.handle)
+	def __del__(self):
+		_linksockslib.DecRef(self.handle)
+	def __str__(self):
+		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
+		sv = 'linksocks.WSConn{'
+		first = True
+		for v in pr:
+			if callable(v[1]):
+				continue
+			if first:
+				first = False
+			else:
+				sv += ', '
+			sv += v[0] + '=' + str(v[1])
+		return sv + '}'
+	def __repr__(self):
+		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
+		sv = 'linksocks.WSConn ( '
+		for v in pr:
+			if not callable(v[1]):
+				sv += v[0] + '=' + str(v[1]) + ', '
+		return sv + ')'
+	def Label(self):
+		"""Label() str"""
+		return _linksockslib.linksocks_WSConn_Label(self.handle)
+	def GetClientIP(self):
+		"""GetClientIP() str
+		
+		GetClientIP returns the client IP address
+		"""
+		return _linksockslib.linksocks_WSConn_GetClientIP(self.handle)
+	def SetClientIPFromRequest(self, r, goRun=False):
+		"""SetClientIPFromRequest(object r) 
+		
+		SetClientIPFromRequest extracts and sets the client IP from HTTP request
+		"""
+		_linksockslib.linksocks_WSConn_SetClientIPFromRequest(self.handle, r.handle, goRun)
+	def SyncWriteBinary(self, data):
+		"""SyncWriteBinary([]int data) str
+		
+		SyncWriteBinary performs thread-safe binary writes to the websocket connection
+		"""
+		return _linksockslib.linksocks_WSConn_SyncWriteBinary(self.handle, data.handle)
+	def ReadMessage(self):
+		"""ReadMessage() object, str
+		
+		ReadMessage reads a BaseMessage from the websocket connection
+		"""
+		return BaseMessage(handle=_linksockslib.linksocks_WSConn_ReadMessage(self.handle))
+	def WriteMessage(self, msg):
+		"""WriteMessage(object msg) str
+		
+		WriteMessage writes a BaseMessage to the websocket connection
+		"""
+		return _linksockslib.linksocks_WSConn_WriteMessage(self.handle, msg.handle)
+	def SyncWriteControl(self, messageType, data, deadline):
+		"""SyncWriteControl(int messageType, []int data, object deadline) str
+		
+		SyncWriteControl performs thread-safe control message writes and tracks ping time
+		"""
+		return _linksockslib.linksocks_WSConn_SyncWriteControl(self.handle, messageType, data.handle, deadline.handle)
+	def Close(self):
+		"""Close() str
+		
+		Close closes the underlying websocket connection
+		"""
+		return _linksockslib.linksocks_WSConn_Close(self.handle)
+
+# Python type for struct linksocks.StatusResponse
+class StatusResponse(go.GoClass):
+	"""StatusResponse represents the server status\n"""
+	def __init__(self, *args, **kwargs):
+		"""
+		handle=A Go-side object is always initialized with an explicit handle=arg
+		otherwise parameters can be unnamed in order of field names or named fields
+		in which case a new Go object is constructed first
+		"""
+		if len(kwargs) == 1 and 'handle' in kwargs:
+			self.handle = kwargs['handle']
+			_linksockslib.IncRef(self.handle)
+		elif len(args) == 1 and isinstance(args[0], go.GoClass):
+			self.handle = args[0].handle
+			_linksockslib.IncRef(self.handle)
+		else:
+			self.handle = _linksockslib.linksocks_StatusResponse_CTor()
+			_linksockslib.IncRef(self.handle)
+			if  0 < len(args):
+				self.Version = args[0]
+			if "Version" in kwargs:
+				self.Version = kwargs["Version"]
+			if  1 < len(args):
+				self.Tokens = args[1]
+			if "Tokens" in kwargs:
+				self.Tokens = kwargs["Tokens"]
+	def __del__(self):
+		_linksockslib.DecRef(self.handle)
+	def __str__(self):
+		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
+		sv = 'linksocks.StatusResponse{'
+		first = True
+		for v in pr:
+			if callable(v[1]):
+				continue
+			if first:
+				first = False
+			else:
+				sv += ', '
+			sv += v[0] + '=' + str(v[1])
+		return sv + '}'
+	def __repr__(self):
+		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
+		sv = 'linksocks.StatusResponse ( '
+		for v in pr:
+			if not callable(v[1]):
+				sv += v[0] + '=' + str(v[1]) + ', '
+		return sv + ')'
+	@property
+	def Version(self):
+		return _linksockslib.linksocks_StatusResponse_Version_Get(self.handle)
+	@Version.setter
+	def Version(self, value):
+		if isinstance(value, go.GoClass):
+			_linksockslib.linksocks_StatusResponse_Version_Set(self.handle, value.handle)
+		else:
+			_linksockslib.linksocks_StatusResponse_Version_Set(self.handle, value)
+	@property
+	def Tokens(self):
+		return Slice_interface_(handle=_linksockslib.linksocks_StatusResponse_Tokens_Get(self.handle))
+	@Tokens.setter
+	def Tokens(self, value):
+		if isinstance(value, go.GoClass):
+			_linksockslib.linksocks_StatusResponse_Tokens_Set(self.handle, value.handle)
+		else:
+			raise TypeError("supplied argument type {t} is not a go.GoClass".format(t=type(value)))
+
+# Python type for struct linksocks.APIHandler
+class APIHandler(go.GoClass):
+	"""APIHandler handles HTTP API requests for LinkSocksServer\n"""
+	def __init__(self, *args, **kwargs):
+		"""
+		handle=A Go-side object is always initialized with an explicit handle=arg
+		otherwise parameters can be unnamed in order of field names or named fields
+		in which case a new Go object is constructed first
+		"""
+		if len(kwargs) == 1 and 'handle' in kwargs:
+			self.handle = kwargs['handle']
+			_linksockslib.IncRef(self.handle)
+		elif len(args) == 1 and isinstance(args[0], go.GoClass):
+			self.handle = args[0].handle
+			_linksockslib.IncRef(self.handle)
+		else:
+			self.handle = _linksockslib.linksocks_APIHandler_CTor()
+			_linksockslib.IncRef(self.handle)
+	def __del__(self):
+		_linksockslib.DecRef(self.handle)
+	def __str__(self):
+		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
+		sv = 'linksocks.APIHandler{'
+		first = True
+		for v in pr:
+			if callable(v[1]):
+				continue
+			if first:
+				first = False
+			else:
+				sv += ', '
+			sv += v[0] + '=' + str(v[1])
+		return sv + '}'
+	def __repr__(self):
+		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
+		sv = 'linksocks.APIHandler ( '
+		for v in pr:
+			if not callable(v[1]):
+				sv += v[0] + '=' + str(v[1]) + ', '
+		return sv + ')'
+	def RegisterHandlers(self, mux, goRun=False):
+		"""RegisterHandlers(object mux) 
+		
+		RegisterHandlers registers API endpoints with the provided mux
+		"""
+		_linksockslib.linksocks_APIHandler_RegisterHandlers(self.handle, mux.handle, goRun)
+
+# Python type for struct linksocks.CLI
+class CLI(go.GoClass):
+	"""CLI represents the command-line interface for LinkSocks\n"""
+	def __init__(self, *args, **kwargs):
+		"""
+		handle=A Go-side object is always initialized with an explicit handle=arg
+		otherwise parameters can be unnamed in order of field names or named fields
+		in which case a new Go object is constructed first
+		"""
+		if len(kwargs) == 1 and 'handle' in kwargs:
+			self.handle = kwargs['handle']
+			_linksockslib.IncRef(self.handle)
+		elif len(args) == 1 and isinstance(args[0], go.GoClass):
+			self.handle = args[0].handle
+			_linksockslib.IncRef(self.handle)
+		else:
+			self.handle = _linksockslib.linksocks_CLI_CTor()
+			_linksockslib.IncRef(self.handle)
+	def __del__(self):
+		_linksockslib.DecRef(self.handle)
+	def __str__(self):
+		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
+		sv = 'linksocks.CLI{'
+		first = True
+		for v in pr:
+			if callable(v[1]):
+				continue
+			if first:
+				first = False
+			else:
+				sv += ', '
+			sv += v[0] + '=' + str(v[1])
+		return sv + '}'
+	def __repr__(self):
+		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
+		sv = 'linksocks.CLI ( '
+		for v in pr:
+			if not callable(v[1]):
+				sv += v[0] + '=' + str(v[1]) + ', '
+		return sv + ')'
+	def Execute(self):
+		"""Execute() str
+		
+		Execute runs the CLI application
+		"""
+		return _linksockslib.linksocks_CLI_Execute(self.handle)
+
+# Python type for struct linksocks.ConnectorResponseMessage
+class ConnectorResponseMessage(go.GoClass):
+	"""ConnectorResponseMessage represents a connector management response\n"""
 	def __init__(self, *args, **kwargs):
 		"""
 		handle=A Go-side object is always initialized with an explicit handle=arg
@@ -4930,21 +5015,29 @@ class ReverseTokenStatus(TokenStatus):
 			self.handle = args[0].handle
 			_linksockslib.IncRef(self.handle)
 		else:
-			self.handle = _linksockslib.linksocks_ReverseTokenStatus_CTor()
+			self.handle = _linksockslib.linksocks_ConnectorResponseMessage_CTor()
 			_linksockslib.IncRef(self.handle)
+			if  0 < len(args):
+				self.Success = args[0]
+			if "Success" in kwargs:
+				self.Success = kwargs["Success"]
 			if  1 < len(args):
-				self.Port = args[1]
-			if "Port" in kwargs:
-				self.Port = kwargs["Port"]
+				self.Error = args[1]
+			if "Error" in kwargs:
+				self.Error = kwargs["Error"]
 			if  2 < len(args):
-				self.ConnectorTokens = args[2]
-			if "ConnectorTokens" in kwargs:
-				self.ConnectorTokens = kwargs["ConnectorTokens"]
+				self.ChannelID = args[2]
+			if "ChannelID" in kwargs:
+				self.ChannelID = kwargs["ChannelID"]
+			if  3 < len(args):
+				self.ConnectorToken = args[3]
+			if "ConnectorToken" in kwargs:
+				self.ConnectorToken = kwargs["ConnectorToken"]
 	def __del__(self):
 		_linksockslib.DecRef(self.handle)
 	def __str__(self):
 		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
-		sv = 'linksocks.ReverseTokenStatus{'
+		sv = 'linksocks.ConnectorResponseMessage{'
 		first = True
 		for v in pr:
 			if callable(v[1]):
@@ -4957,33 +5050,48 @@ class ReverseTokenStatus(TokenStatus):
 		return sv + '}'
 	def __repr__(self):
 		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
-		sv = 'linksocks.ReverseTokenStatus ( '
+		sv = 'linksocks.ConnectorResponseMessage ( '
 		for v in pr:
 			if not callable(v[1]):
 				sv += v[0] + '=' + str(v[1]) + ', '
 		return sv + ')'
 	@property
-	def Port(self):
-		return _linksockslib.linksocks_ReverseTokenStatus_Port_Get(self.handle)
-	@Port.setter
-	def Port(self, value):
+	def Success(self):
+		return _linksockslib.linksocks_ConnectorResponseMessage_Success_Get(self.handle)
+	@Success.setter
+	def Success(self, value):
 		if isinstance(value, go.GoClass):
-			_linksockslib.linksocks_ReverseTokenStatus_Port_Set(self.handle, value.handle)
+			_linksockslib.linksocks_ConnectorResponseMessage_Success_Set(self.handle, value.handle)
 		else:
-			_linksockslib.linksocks_ReverseTokenStatus_Port_Set(self.handle, value)
+			_linksockslib.linksocks_ConnectorResponseMessage_Success_Set(self.handle, value)
 	@property
-	def ConnectorTokens(self):
-		return go.Slice_string(handle=_linksockslib.linksocks_ReverseTokenStatus_ConnectorTokens_Get(self.handle))
-	@ConnectorTokens.setter
-	def ConnectorTokens(self, value):
+	def Error(self):
+		return _linksockslib.linksocks_ConnectorResponseMessage_Error_Get(self.handle)
+	@Error.setter
+	def Error(self, value):
 		if isinstance(value, go.GoClass):
-			_linksockslib.linksocks_ReverseTokenStatus_ConnectorTokens_Set(self.handle, value.handle)
+			_linksockslib.linksocks_ConnectorResponseMessage_Error_Set(self.handle, value.handle)
 		else:
-			raise TypeError("supplied argument type {t} is not a go.GoClass".format(t=type(value)))
+			_linksockslib.linksocks_ConnectorResponseMessage_Error_Set(self.handle, value)
+	@property
+	def ChannelID(self):
+		return go.uuid_UUID(handle=_linksockslib.linksocks_ConnectorResponseMessage_ChannelID_Get(self.handle))
+	@property
+	def ConnectorToken(self):
+		return _linksockslib.linksocks_ConnectorResponseMessage_ConnectorToken_Get(self.handle)
+	@ConnectorToken.setter
+	def ConnectorToken(self, value):
+		if isinstance(value, go.GoClass):
+			_linksockslib.linksocks_ConnectorResponseMessage_ConnectorToken_Set(self.handle, value.handle)
+		else:
+			_linksockslib.linksocks_ConnectorResponseMessage_ConnectorToken_Set(self.handle, value)
+	def GetType(self):
+		"""GetType() str"""
+		return _linksockslib.linksocks_ConnectorResponseMessage_GetType(self.handle)
 
-# Python type for struct linksocks.WSConn
-class WSConn(go.GoClass):
-	"""WSConn wraps a websocket.Conn with mutex protection\n"""
+# Python type for struct linksocks.ContextWithCancel
+class ContextWithCancel(go.GoClass):
+	"""ContextWithCancel wraps context and cancel function for Python bindings\n"""
 	def __init__(self, *args, **kwargs):
 		"""
 		handle=A Go-side object is always initialized with an explicit handle=arg
@@ -4997,13 +5105,13 @@ class WSConn(go.GoClass):
 			self.handle = args[0].handle
 			_linksockslib.IncRef(self.handle)
 		else:
-			self.handle = _linksockslib.linksocks_WSConn_CTor()
+			self.handle = _linksockslib.linksocks_ContextWithCancel_CTor()
 			_linksockslib.IncRef(self.handle)
 	def __del__(self):
 		_linksockslib.DecRef(self.handle)
 	def __str__(self):
 		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
-		sv = 'linksocks.WSConn{'
+		sv = 'linksocks.ContextWithCancel{'
 		first = True
 		for v in pr:
 			if callable(v[1]):
@@ -5016,60 +5124,27 @@ class WSConn(go.GoClass):
 		return sv + '}'
 	def __repr__(self):
 		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
-		sv = 'linksocks.WSConn ( '
+		sv = 'linksocks.ContextWithCancel ( '
 		for v in pr:
 			if not callable(v[1]):
 				sv += v[0] + '=' + str(v[1]) + ', '
 		return sv + ')'
-	def Label(self):
-		"""Label() str"""
-		return _linksockslib.linksocks_WSConn_Label(self.handle)
-	def GetClientIP(self):
-		"""GetClientIP() str
-		
-		GetClientIP returns the client IP address
-		"""
-		return _linksockslib.linksocks_WSConn_GetClientIP(self.handle)
-	def SetClientIPFromRequest(self, r, goRun=False):
-		"""SetClientIPFromRequest(object r) 
-		
-		SetClientIPFromRequest extracts and sets the client IP from HTTP request
-		"""
-		_linksockslib.linksocks_WSConn_SetClientIPFromRequest(self.handle, r.handle, goRun)
-	def SyncWriteBinary(self, data):
-		"""SyncWriteBinary([]int data) str
-		
-		SyncWriteBinary performs thread-safe binary writes to the websocket connection
-		"""
-		return _linksockslib.linksocks_WSConn_SyncWriteBinary(self.handle, data.handle)
-	def ReadMessage(self):
-		"""ReadMessage() object, str
-		
-		ReadMessage reads a BaseMessage from the websocket connection
-		"""
-		return BaseMessage(handle=_linksockslib.linksocks_WSConn_ReadMessage(self.handle))
-	def WriteMessage(self, msg):
-		"""WriteMessage(object msg) str
-		
-		WriteMessage writes a BaseMessage to the websocket connection
-		"""
-		return _linksockslib.linksocks_WSConn_WriteMessage(self.handle, msg.handle)
-	def SyncWriteControl(self, messageType, data, deadline):
-		"""SyncWriteControl(int messageType, []int data, object deadline) str
+	def Cancel(self, goRun=False):
+		"""Cancel() 
 		
-		SyncWriteControl performs thread-safe control message writes and tracks ping time
+		Cancel calls the cancel function to cancel the context
 		"""
-		return _linksockslib.linksocks_WSConn_SyncWriteControl(self.handle, messageType, data.handle, deadline.handle)
-	def Close(self):
-		"""Close() str
+		_linksockslib.linksocks_ContextWithCancel_Cancel(self.handle, goRun)
+	def Context(self):
+		"""Context() object
 		
-		Close closes the underlying websocket connection
+		Context returns the underlying context.Context
 		"""
-		return _linksockslib.linksocks_WSConn_Close(self.handle)
+		return go.context_Context(handle=_linksockslib.linksocks_ContextWithCancel_Context(self.handle))
 
-# Python type for struct linksocks.APIHandler
-class APIHandler(go.GoClass):
-	"""APIHandler handles HTTP API requests for LinkSocksServer\n"""
+# Python type for struct linksocks.PortPool
+class PortPool(go.GoClass):
+	"""PortPool is a thread-safe port pool for managing available network ports\n"""
 	def __init__(self, *args, **kwargs):
 		"""
 		handle=A Go-side object is always initialized with an explicit handle=arg
@@ -5083,13 +5158,13 @@ class APIHandler(go.GoClass):
 			self.handle = args[0].handle
 			_linksockslib.IncRef(self.handle)
 		else:
-			self.handle = _linksockslib.linksocks_APIHandler_CTor()
+			self.handle = _linksockslib.linksocks_PortPool_CTor()
 			_linksockslib.IncRef(self.handle)
 	def __del__(self):
 		_linksockslib.DecRef(self.handle)
 	def __str__(self):
 		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
-		sv = 'linksocks.APIHandler{'
+		sv = 'linksocks.PortPool{'
 		first = True
 		for v in pr:
 			if callable(v[1]):
@@ -5102,21 +5177,28 @@ class APIHandler(go.GoClass):
 		return sv + '}'
 	def __repr__(self):
 		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
-		sv = 'linksocks.APIHandler ( '
+		sv = 'linksocks.PortPool ( '
 		for v in pr:
 			if not callable(v[1]):
 				sv += v[0] + '=' + str(v[1]) + ', '
 		return sv + ')'
-	def RegisterHandlers(self, mux, goRun=False):
-		"""RegisterHandlers(object mux) 
+	def Get(self, requestedPort):
+		"""Get(int requestedPort) int
 		
-		RegisterHandlers registers API endpoints with the provided mux
+		Get retrieves an available port from the pool
+		If a specific port is requested, it will try to allocate that port
 		"""
-		_linksockslib.linksocks_APIHandler_RegisterHandlers(self.handle, mux.handle, goRun)
+		return _linksockslib.linksocks_PortPool_Get(self.handle, requestedPort)
+	def Put(self, port, goRun=False):
+		"""Put(int port) 
+		
+		Put returns a port back to the pool
+		"""
+		_linksockslib.linksocks_PortPool_Put(self.handle, port, goRun)
 
-# Python type for struct linksocks.ConnectMessage
-class ConnectMessage(go.GoClass):
-	"""ConnectMessage represents a TCP connection request\n"""
+# Python type for struct linksocks.ReverseTokenResult
+class ReverseTokenResult(go.GoClass):
+	"""ReverseTokenResult represents the result of adding a reverse token\n"""
 	def __init__(self, *args, **kwargs):
 		"""
 		handle=A Go-side object is always initialized with an explicit handle=arg
@@ -5130,29 +5212,21 @@ class ConnectMessage(go.GoClass):
 			self.handle = args[0].handle
 			_linksockslib.IncRef(self.handle)
 		else:
-			self.handle = _linksockslib.linksocks_ConnectMessage_CTor()
+			self.handle = _linksockslib.linksocks_ReverseTokenResult_CTor()
 			_linksockslib.IncRef(self.handle)
 			if  0 < len(args):
-				self.Protocol = args[0]
-			if "Protocol" in kwargs:
-				self.Protocol = kwargs["Protocol"]
+				self.Token = args[0]
+			if "Token" in kwargs:
+				self.Token = kwargs["Token"]
 			if  1 < len(args):
-				self.Address = args[1]
-			if "Address" in kwargs:
-				self.Address = kwargs["Address"]
-			if  2 < len(args):
-				self.Port = args[2]
+				self.Port = args[1]
 			if "Port" in kwargs:
 				self.Port = kwargs["Port"]
-			if  3 < len(args):
-				self.ChannelID = args[3]
-			if "ChannelID" in kwargs:
-				self.ChannelID = kwargs["ChannelID"]
 	def __del__(self):
 		_linksockslib.DecRef(self.handle)
 	def __str__(self):
 		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
-		sv = 'linksocks.ConnectMessage{'
+		sv = 'linksocks.ReverseTokenResult{'
 		first = True
 		for v in pr:
 			if callable(v[1]):
@@ -5165,48 +5239,86 @@ class ConnectMessage(go.GoClass):
 		return sv + '}'
 	def __repr__(self):
 		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
-		sv = 'linksocks.ConnectMessage ( '
+		sv = 'linksocks.ReverseTokenResult ( '
 		for v in pr:
 			if not callable(v[1]):
 				sv += v[0] + '=' + str(v[1]) + ', '
 		return sv + ')'
 	@property
-	def Protocol(self):
-		return _linksockslib.linksocks_ConnectMessage_Protocol_Get(self.handle)
-	@Protocol.setter
-	def Protocol(self, value):
-		if isinstance(value, go.GoClass):
-			_linksockslib.linksocks_ConnectMessage_Protocol_Set(self.handle, value.handle)
-		else:
-			_linksockslib.linksocks_ConnectMessage_Protocol_Set(self.handle, value)
-	@property
-	def Address(self):
-		return _linksockslib.linksocks_ConnectMessage_Address_Get(self.handle)
-	@Address.setter
-	def Address(self, value):
+	def Token(self):
+		return _linksockslib.linksocks_ReverseTokenResult_Token_Get(self.handle)
+	@Token.setter
+	def Token(self, value):
 		if isinstance(value, go.GoClass):
-			_linksockslib.linksocks_ConnectMessage_Address_Set(self.handle, value.handle)
+			_linksockslib.linksocks_ReverseTokenResult_Token_Set(self.handle, value.handle)
 		else:
-			_linksockslib.linksocks_ConnectMessage_Address_Set(self.handle, value)
+			_linksockslib.linksocks_ReverseTokenResult_Token_Set(self.handle, value)
 	@property
 	def Port(self):
-		return _linksockslib.linksocks_ConnectMessage_Port_Get(self.handle)
+		return _linksockslib.linksocks_ReverseTokenResult_Port_Get(self.handle)
 	@Port.setter
 	def Port(self, value):
 		if isinstance(value, go.GoClass):
-			_linksockslib.linksocks_ConnectMessage_Port_Set(self.handle, value.handle)
+			_linksockslib.linksocks_ReverseTokenResult_Port_Set(self.handle, value.handle)
 		else:
-			_linksockslib.linksocks_ConnectMessage_Port_Set(self.handle, value)
-	@property
-	def ChannelID(self):
-		return go.uuid_UUID(handle=_linksockslib.linksocks_ConnectMessage_ChannelID_Get(self.handle))
-	def GetType(self):
-		"""GetType() str"""
-		return _linksockslib.linksocks_ConnectMessage_GetType(self.handle)
+			_linksockslib.linksocks_ReverseTokenResult_Port_Set(self.handle, value)
+
+# Python type for struct linksocks.SocketManager
+class SocketManager(go.GoClass):
+	"""SocketManager manages socket lifecycle and reuse\n"""
+	def __init__(self, *args, **kwargs):
+		"""
+		handle=A Go-side object is always initialized with an explicit handle=arg
+		otherwise parameters can be unnamed in order of field names or named fields
+		in which case a new Go object is constructed first
+		"""
+		if len(kwargs) == 1 and 'handle' in kwargs:
+			self.handle = kwargs['handle']
+			_linksockslib.IncRef(self.handle)
+		elif len(args) == 1 and isinstance(args[0], go.GoClass):
+			self.handle = args[0].handle
+			_linksockslib.IncRef(self.handle)
+		else:
+			self.handle = _linksockslib.linksocks_SocketManager_CTor()
+			_linksockslib.IncRef(self.handle)
+	def __del__(self):
+		_linksockslib.DecRef(self.handle)
+	def __str__(self):
+		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
+		sv = 'linksocks.SocketManager{'
+		first = True
+		for v in pr:
+			if callable(v[1]):
+				continue
+			if first:
+				first = False
+			else:
+				sv += ', '
+			sv += v[0] + '=' + str(v[1])
+		return sv + '}'
+	def __repr__(self):
+		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
+		sv = 'linksocks.SocketManager ( '
+		for v in pr:
+			if not callable(v[1]):
+				sv += v[0] + '=' + str(v[1]) + ', '
+		return sv + ')'
+	def GetListener(self, port):
+		"""GetListener(int port) object, str"""
+		return go.net_Listener(handle=_linksockslib.linksocks_SocketManager_GetListener(self.handle, port))
+	def ReleaseListener(self, port, goRun=False):
+		"""ReleaseListener(int port) """
+		_linksockslib.linksocks_SocketManager_ReleaseListener(self.handle, port, goRun)
+	def Close(self, goRun=False):
+		"""Close() 
+		
+		Close closes all managed sockets immediately
+		"""
+		_linksockslib.linksocks_SocketManager_Close(self.handle, goRun)
 
-# Python type for struct linksocks.ServerOption
-class ServerOption(go.GoClass):
-	"""ServerOption represents configuration options for LinkSocksServer\n"""
+# Python type for struct linksocks.DataMessage
+class DataMessage(go.GoClass):
+	"""DataMessage represents a data transfer message\n"""
 	def __init__(self, *args, **kwargs):
 		"""
 		handle=A Go-side object is always initialized with an explicit handle=arg
@@ -5220,69 +5332,45 @@ class ServerOption(go.GoClass):
 			self.handle = args[0].handle
 			_linksockslib.IncRef(self.handle)
 		else:
-			self.handle = _linksockslib.linksocks_ServerOption_CTor()
+			self.handle = _linksockslib.linksocks_DataMessage_CTor()
 			_linksockslib.IncRef(self.handle)
 			if  0 < len(args):
-				self.WSHost = args[0]
-			if "WSHost" in kwargs:
-				self.WSHost = kwargs["WSHost"]
+				self.Protocol = args[0]
+			if "Protocol" in kwargs:
+				self.Protocol = kwargs["Protocol"]
 			if  1 < len(args):
-				self.WSPort = args[1]
-			if "WSPort" in kwargs:
-				self.WSPort = kwargs["WSPort"]
+				self.ChannelID = args[1]
+			if "ChannelID" in kwargs:
+				self.ChannelID = kwargs["ChannelID"]
 			if  2 < len(args):
-				self.SocksHost = args[2]
-			if "SocksHost" in kwargs:
-				self.SocksHost = kwargs["SocksHost"]
+				self.Data = args[2]
+			if "Data" in kwargs:
+				self.Data = kwargs["Data"]
 			if  3 < len(args):
-				self.PortPool = args[3]
-			if "PortPool" in kwargs:
-				self.PortPool = kwargs["PortPool"]
+				self.Compression = args[3]
+			if "Compression" in kwargs:
+				self.Compression = kwargs["Compression"]
 			if  4 < len(args):
-				self.SocksWaitClient = args[4]
-			if "SocksWaitClient" in kwargs:
-				self.SocksWaitClient = kwargs["SocksWaitClient"]
+				self.Address = args[4]
+			if "Address" in kwargs:
+				self.Address = kwargs["Address"]
 			if  5 < len(args):
-				self.Logger = args[5]
-			if "Logger" in kwargs:
-				self.Logger = kwargs["Logger"]
+				self.Port = args[5]
+			if "Port" in kwargs:
+				self.Port = kwargs["Port"]
 			if  6 < len(args):
-				self.BufferSize = args[6]
-			if "BufferSize" in kwargs:
-				self.BufferSize = kwargs["BufferSize"]
+				self.TargetAddr = args[6]
+			if "TargetAddr" in kwargs:
+				self.TargetAddr = kwargs["TargetAddr"]
 			if  7 < len(args):
-				self.APIKey = args[7]
-			if "APIKey" in kwargs:
-				self.APIKey = kwargs["APIKey"]
-			if  8 < len(args):
-				self.ChannelTimeout = args[8]
-			if "ChannelTimeout" in kwargs:
-				self.ChannelTimeout = kwargs["ChannelTimeout"]
-			if  9 < len(args):
-				self.ConnectTimeout = args[9]
-			if "ConnectTimeout" in kwargs:
-				self.ConnectTimeout = kwargs["ConnectTimeout"]
-			if  10 < len(args):
-				self.FastOpen = args[10]
-			if "FastOpen" in kwargs:
-				self.FastOpen = kwargs["FastOpen"]
-			if  11 < len(args):
-				self.UpstreamProxy = args[11]
-			if "UpstreamProxy" in kwargs:
-				self.UpstreamProxy = kwargs["UpstreamProxy"]
-			if  12 < len(args):
-				self.UpstreamUsername = args[12]
-			if "UpstreamUsername" in kwargs:
-				self.UpstreamUsername = kwargs["UpstreamUsername"]
-			if  13 < len(args):
-				self.UpstreamPassword = args[13]
-			if "UpstreamPassword" in kwargs:
-				self.UpstreamPassword = kwargs["UpstreamPassword"]
+				self.TargetPort = args[7]
+			if "TargetPort" in kwargs:
+				self.TargetPort = kwargs["TargetPort"]
 	def __del__(self):
 		_linksockslib.DecRef(self.handle)
 	def __str__(self):
 		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
-		sv = 'linksocks.ServerOption{'
+		sv = 'linksocks.DataMessage{'
 		first = True
 		for v in pr:
 			if callable(v[1]):
@@ -5295,219 +5383,84 @@ class ServerOption(go.GoClass):
 		return sv + '}'
 	def __repr__(self):
 		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
-		sv = 'linksocks.ServerOption ( '
+		sv = 'linksocks.DataMessage ( '
 		for v in pr:
 			if not callable(v[1]):
 				sv += v[0] + '=' + str(v[1]) + ', '
 		return sv + ')'
 	@property
-	def WSHost(self):
-		return _linksockslib.linksocks_ServerOption_WSHost_Get(self.handle)
-	@WSHost.setter
-	def WSHost(self, value):
-		if isinstance(value, go.GoClass):
-			_linksockslib.linksocks_ServerOption_WSHost_Set(self.handle, value.handle)
-		else:
-			_linksockslib.linksocks_ServerOption_WSHost_Set(self.handle, value)
-	@property
-	def WSPort(self):
-		return _linksockslib.linksocks_ServerOption_WSPort_Get(self.handle)
-	@WSPort.setter
-	def WSPort(self, value):
-		if isinstance(value, go.GoClass):
-			_linksockslib.linksocks_ServerOption_WSPort_Set(self.handle, value.handle)
-		else:
-			_linksockslib.linksocks_ServerOption_WSPort_Set(self.handle, value)
-	@property
-	def SocksHost(self):
-		return _linksockslib.linksocks_ServerOption_SocksHost_Get(self.handle)
-	@SocksHost.setter
-	def SocksHost(self, value):
-		if isinstance(value, go.GoClass):
-			_linksockslib.linksocks_ServerOption_SocksHost_Set(self.handle, value.handle)
-		else:
-			_linksockslib.linksocks_ServerOption_SocksHost_Set(self.handle, value)
-	@property
-	def PortPool(self):
-		return PortPool(handle=_linksockslib.linksocks_ServerOption_PortPool_Get(self.handle))
-	@PortPool.setter
-	def PortPool(self, value):
+	def Protocol(self):
+		return _linksockslib.linksocks_DataMessage_Protocol_Get(self.handle)
+	@Protocol.setter
+	def Protocol(self, value):
 		if isinstance(value, go.GoClass):
-			_linksockslib.linksocks_ServerOption_PortPool_Set(self.handle, value.handle)
+			_linksockslib.linksocks_DataMessage_Protocol_Set(self.handle, value.handle)
 		else:
-			raise TypeError("supplied argument type {t} is not a go.GoClass".format(t=type(value)))
+			_linksockslib.linksocks_DataMessage_Protocol_Set(self.handle, value)
 	@property
-	def SocksWaitClient(self):
-		return _linksockslib.linksocks_ServerOption_SocksWaitClient_Get(self.handle)
-	@SocksWaitClient.setter
-	def SocksWaitClient(self, value):
-		if isinstance(value, go.GoClass):
-			_linksockslib.linksocks_ServerOption_SocksWaitClient_Set(self.handle, value.handle)
-		else:
-			_linksockslib.linksocks_ServerOption_SocksWaitClient_Set(self.handle, value)
+	def ChannelID(self):
+		return go.uuid_UUID(handle=_linksockslib.linksocks_DataMessage_ChannelID_Get(self.handle))
 	@property
-	def Logger(self):
-		return go.zerolog_Logger(handle=_linksockslib.linksocks_ServerOption_Logger_Get(self.handle))
-	@Logger.setter
-	def Logger(self, value):
+	def Data(self):
+		return go.Slice_byte(handle=_linksockslib.linksocks_DataMessage_Data_Get(self.handle))
+	@Data.setter
+	def Data(self, value):
 		if isinstance(value, go.GoClass):
-			_linksockslib.linksocks_ServerOption_Logger_Set(self.handle, value.handle)
+			_linksockslib.linksocks_DataMessage_Data_Set(self.handle, value.handle)
 		else:
 			raise TypeError("supplied argument type {t} is not a go.GoClass".format(t=type(value)))
 	@property
-	def BufferSize(self):
-		return _linksockslib.linksocks_ServerOption_BufferSize_Get(self.handle)
-	@BufferSize.setter
-	def BufferSize(self, value):
-		if isinstance(value, go.GoClass):
-			_linksockslib.linksocks_ServerOption_BufferSize_Set(self.handle, value.handle)
-		else:
-			_linksockslib.linksocks_ServerOption_BufferSize_Set(self.handle, value)
-	@property
-	def APIKey(self):
-		return _linksockslib.linksocks_ServerOption_APIKey_Get(self.handle)
-	@APIKey.setter
-	def APIKey(self, value):
-		if isinstance(value, go.GoClass):
-			_linksockslib.linksocks_ServerOption_APIKey_Set(self.handle, value.handle)
-		else:
-			_linksockslib.linksocks_ServerOption_APIKey_Set(self.handle, value)
-	@property
-	def ChannelTimeout(self):
-		return _linksockslib.linksocks_ServerOption_ChannelTimeout_Get(self.handle)
-	@ChannelTimeout.setter
-	def ChannelTimeout(self, value):
-		if isinstance(value, go.GoClass):
-			_linksockslib.linksocks_ServerOption_ChannelTimeout_Set(self.handle, value.handle)
-		else:
-			_linksockslib.linksocks_ServerOption_ChannelTimeout_Set(self.handle, value)
-	@property
-	def ConnectTimeout(self):
-		return _linksockslib.linksocks_ServerOption_ConnectTimeout_Get(self.handle)
-	@ConnectTimeout.setter
-	def ConnectTimeout(self, value):
+	def Compression(self):
+		return _linksockslib.linksocks_DataMessage_Compression_Get(self.handle)
+	@Compression.setter
+	def Compression(self, value):
 		if isinstance(value, go.GoClass):
-			_linksockslib.linksocks_ServerOption_ConnectTimeout_Set(self.handle, value.handle)
+			_linksockslib.linksocks_DataMessage_Compression_Set(self.handle, value.handle)
 		else:
-			_linksockslib.linksocks_ServerOption_ConnectTimeout_Set(self.handle, value)
+			_linksockslib.linksocks_DataMessage_Compression_Set(self.handle, value)
 	@property
-	def FastOpen(self):
-		return _linksockslib.linksocks_ServerOption_FastOpen_Get(self.handle)
-	@FastOpen.setter
-	def FastOpen(self, value):
+	def Address(self):
+		return _linksockslib.linksocks_DataMessage_Address_Get(self.handle)
+	@Address.setter
+	def Address(self, value):
 		if isinstance(value, go.GoClass):
-			_linksockslib.linksocks_ServerOption_FastOpen_Set(self.handle, value.handle)
+			_linksockslib.linksocks_DataMessage_Address_Set(self.handle, value.handle)
 		else:
-			_linksockslib.linksocks_ServerOption_FastOpen_Set(self.handle, value)
+			_linksockslib.linksocks_DataMessage_Address_Set(self.handle, value)
 	@property
-	def UpstreamProxy(self):
-		return _linksockslib.linksocks_ServerOption_UpstreamProxy_Get(self.handle)
-	@UpstreamProxy.setter
-	def UpstreamProxy(self, value):
+	def Port(self):
+		return _linksockslib.linksocks_DataMessage_Port_Get(self.handle)
+	@Port.setter
+	def Port(self, value):
 		if isinstance(value, go.GoClass):
-			_linksockslib.linksocks_ServerOption_UpstreamProxy_Set(self.handle, value.handle)
+			_linksockslib.linksocks_DataMessage_Port_Set(self.handle, value.handle)
 		else:
-			_linksockslib.linksocks_ServerOption_UpstreamProxy_Set(self.handle, value)
+			_linksockslib.linksocks_DataMessage_Port_Set(self.handle, value)
 	@property
-	def UpstreamUsername(self):
-		return _linksockslib.linksocks_ServerOption_UpstreamUsername_Get(self.handle)
-	@UpstreamUsername.setter
-	def UpstreamUsername(self, value):
+	def TargetAddr(self):
+		return _linksockslib.linksocks_DataMessage_TargetAddr_Get(self.handle)
+	@TargetAddr.setter
+	def TargetAddr(self, value):
 		if isinstance(value, go.GoClass):
-			_linksockslib.linksocks_ServerOption_UpstreamUsername_Set(self.handle, value.handle)
+			_linksockslib.linksocks_DataMessage_TargetAddr_Set(self.handle, value.handle)
 		else:
-			_linksockslib.linksocks_ServerOption_UpstreamUsername_Set(self.handle, value)
+			_linksockslib.linksocks_DataMessage_TargetAddr_Set(self.handle, value)
 	@property
-	def UpstreamPassword(self):
-		return _linksockslib.linksocks_ServerOption_UpstreamPassword_Get(self.handle)
-	@UpstreamPassword.setter
-	def UpstreamPassword(self, value):
+	def TargetPort(self):
+		return _linksockslib.linksocks_DataMessage_TargetPort_Get(self.handle)
+	@TargetPort.setter
+	def TargetPort(self, value):
 		if isinstance(value, go.GoClass):
-			_linksockslib.linksocks_ServerOption_UpstreamPassword_Set(self.handle, value.handle)
+			_linksockslib.linksocks_DataMessage_TargetPort_Set(self.handle, value.handle)
 		else:
-			_linksockslib.linksocks_ServerOption_UpstreamPassword_Set(self.handle, value)
-	def WithWSHost(self, host):
-		"""WithWSHost(str host) object
-		
-		WithWSHost sets the WebSocket host
-		"""
-		return ServerOption(handle=_linksockslib.linksocks_ServerOption_WithWSHost(self.handle, host))
-	def WithWSPort(self, port):
-		"""WithWSPort(int port) object
-		
-		WithWSPort sets the WebSocket port
-		"""
-		return ServerOption(handle=_linksockslib.linksocks_ServerOption_WithWSPort(self.handle, port))
-	def WithSocksHost(self, host):
-		"""WithSocksHost(str host) object
-		
-		WithSocksHost sets the SOCKS host
-		"""
-		return ServerOption(handle=_linksockslib.linksocks_ServerOption_WithSocksHost(self.handle, host))
-	def WithPortPool(self, pool):
-		"""WithPortPool(object pool) object
-		
-		WithPortPool sets the port pool
-		"""
-		return ServerOption(handle=_linksockslib.linksocks_ServerOption_WithPortPool(self.handle, pool.handle))
-	def WithSocksWaitClient(self, wait):
-		"""WithSocksWaitClient(bool wait) object
-		
-		WithSocksWaitClient sets whether to wait for client before starting SOCKS server
-		"""
-		return ServerOption(handle=_linksockslib.linksocks_ServerOption_WithSocksWaitClient(self.handle, wait))
-	def WithLogger(self, logger):
-		"""WithLogger(object logger) object
-		
-		WithLogger sets the logger
-		"""
-		return ServerOption(handle=_linksockslib.linksocks_ServerOption_WithLogger(self.handle, logger.handle))
-	def WithBufferSize(self, size):
-		"""WithBufferSize(int size) object
-		
-		WithBufferSize sets the buffer size for data transfer
-		"""
-		return ServerOption(handle=_linksockslib.linksocks_ServerOption_WithBufferSize(self.handle, size))
-	def WithAPI(self, apiKey):
-		"""WithAPI(str apiKey) object
-		
-		WithAPI sets apiKey to enable the HTTP API
-		"""
-		return ServerOption(handle=_linksockslib.linksocks_ServerOption_WithAPI(self.handle, apiKey))
-	def WithChannelTimeout(self, timeout):
-		"""WithChannelTimeout(long timeout) object
-		
-		WithChannelTimeout sets the channel timeout duration
-		"""
-		return ServerOption(handle=_linksockslib.linksocks_ServerOption_WithChannelTimeout(self.handle, timeout))
-	def WithConnectTimeout(self, timeout):
-		"""WithConnectTimeout(long timeout) object
-		
-		WithConnectTimeout sets the connect timeout duration
-		"""
-		return ServerOption(handle=_linksockslib.linksocks_ServerOption_WithConnectTimeout(self.handle, timeout))
-	def WithFastOpen(self, fastOpen):
-		"""WithFastOpen(bool fastOpen) object
-		
-		WithFastOpen controls whether to wait for connect success response
-		"""
-		return ServerOption(handle=_linksockslib.linksocks_ServerOption_WithFastOpen(self.handle, fastOpen))
-	def WithUpstreamProxy(self, proxy):
-		"""WithUpstreamProxy(str proxy) object
-		
-		WithUpstreamProxy sets the upstream SOCKS5 proxy
-		"""
-		return ServerOption(handle=_linksockslib.linksocks_ServerOption_WithUpstreamProxy(self.handle, proxy))
-	def WithUpstreamAuth(self, username, password):
-		"""WithUpstreamAuth(str username, str password) object
-		
-		WithUpstreamAuth sets the upstream SOCKS5 proxy authentication
-		"""
-		return ServerOption(handle=_linksockslib.linksocks_ServerOption_WithUpstreamAuth(self.handle, username, password))
+			_linksockslib.linksocks_DataMessage_TargetPort_Set(self.handle, value)
+	def GetType(self):
+		"""GetType() str"""
+		return _linksockslib.linksocks_DataMessage_GetType(self.handle)
 
-# Python type for struct linksocks.StatusResponse
-class StatusResponse(go.GoClass):
-	"""StatusResponse represents the server status\n"""
+# Python type for struct linksocks.LogEntry
+class LogEntry(go.GoClass):
+	"""LogEntry represents a single log entry with metadata\n"""
 	def __init__(self, *args, **kwargs):
 		"""
 		handle=A Go-side object is always initialized with an explicit handle=arg
@@ -5521,21 +5474,25 @@ class StatusResponse(go.GoClass):
 			self.handle = args[0].handle
 			_linksockslib.IncRef(self.handle)
 		else:
-			self.handle = _linksockslib.linksocks_StatusResponse_CTor()
+			self.handle = _linksockslib.linksocks_LogEntry_CTor()
 			_linksockslib.IncRef(self.handle)
 			if  0 < len(args):
-				self.Version = args[0]
-			if "Version" in kwargs:
-				self.Version = kwargs["Version"]
+				self.LoggerID = args[0]
+			if "LoggerID" in kwargs:
+				self.LoggerID = kwargs["LoggerID"]
 			if  1 < len(args):
-				self.Tokens = args[1]
-			if "Tokens" in kwargs:
-				self.Tokens = kwargs["Tokens"]
+				self.Message = args[1]
+			if "Message" in kwargs:
+				self.Message = kwargs["Message"]
+			if  2 < len(args):
+				self.Time = args[2]
+			if "Time" in kwargs:
+				self.Time = kwargs["Time"]
 	def __del__(self):
 		_linksockslib.DecRef(self.handle)
 	def __str__(self):
 		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
-		sv = 'linksocks.StatusResponse{'
+		sv = 'linksocks.LogEntry{'
 		first = True
 		for v in pr:
 			if callable(v[1]):
@@ -5548,33 +5505,42 @@ class StatusResponse(go.GoClass):
 		return sv + '}'
 	def __repr__(self):
 		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
-		sv = 'linksocks.StatusResponse ( '
+		sv = 'linksocks.LogEntry ( '
 		for v in pr:
 			if not callable(v[1]):
 				sv += v[0] + '=' + str(v[1]) + ', '
 		return sv + ')'
 	@property
-	def Version(self):
-		return _linksockslib.linksocks_StatusResponse_Version_Get(self.handle)
-	@Version.setter
-	def Version(self, value):
+	def LoggerID(self):
+		return _linksockslib.linksocks_LogEntry_LoggerID_Get(self.handle)
+	@LoggerID.setter
+	def LoggerID(self, value):
 		if isinstance(value, go.GoClass):
-			_linksockslib.linksocks_StatusResponse_Version_Set(self.handle, value.handle)
+			_linksockslib.linksocks_LogEntry_LoggerID_Set(self.handle, value.handle)
 		else:
-			_linksockslib.linksocks_StatusResponse_Version_Set(self.handle, value)
+			_linksockslib.linksocks_LogEntry_LoggerID_Set(self.handle, value)
 	@property
-	def Tokens(self):
-		return Slice_interface_(handle=_linksockslib.linksocks_StatusResponse_Tokens_Get(self.handle))
-	@Tokens.setter
-	def Tokens(self, value):
+	def Message(self):
+		return _linksockslib.linksocks_LogEntry_Message_Get(self.handle)
+	@Message.setter
+	def Message(self, value):
 		if isinstance(value, go.GoClass):
-			_linksockslib.linksocks_StatusResponse_Tokens_Set(self.handle, value.handle)
+			_linksockslib.linksocks_LogEntry_Message_Set(self.handle, value.handle)
 		else:
-			raise TypeError("supplied argument type {t} is not a go.GoClass".format(t=type(value)))
+			_linksockslib.linksocks_LogEntry_Message_Set(self.handle, value)
+	@property
+	def Time(self):
+		return _linksockslib.linksocks_LogEntry_Time_Get(self.handle)
+	@Time.setter
+	def Time(self, value):
+		if isinstance(value, go.GoClass):
+			_linksockslib.linksocks_LogEntry_Time_Set(self.handle, value.handle)
+		else:
+			_linksockslib.linksocks_LogEntry_Time_Set(self.handle, value)
 
-# Python type for struct linksocks.TokenResponse
-class TokenResponse(go.GoClass):
-	"""TokenResponse represents the response for token operations\n"""
+# Python type for struct linksocks.PartnersMessage
+class PartnersMessage(go.GoClass):
+	"""PartnersMessage represents a partners count update message\n"""
 	def __init__(self, *args, **kwargs):
 		"""
 		handle=A Go-side object is always initialized with an explicit handle=arg
@@ -5588,29 +5554,17 @@ class TokenResponse(go.GoClass):
 			self.handle = args[0].handle
 			_linksockslib.IncRef(self.handle)
 		else:
-			self.handle = _linksockslib.linksocks_TokenResponse_CTor()
+			self.handle = _linksockslib.linksocks_PartnersMessage_CTor()
 			_linksockslib.IncRef(self.handle)
 			if  0 < len(args):
-				self.Success = args[0]
-			if "Success" in kwargs:
-				self.Success = kwargs["Success"]
-			if  1 < len(args):
-				self.Token = args[1]
-			if "Token" in kwargs:
-				self.Token = kwargs["Token"]
-			if  2 < len(args):
-				self.Port = args[2]
-			if "Port" in kwargs:
-				self.Port = kwargs["Port"]
-			if  3 < len(args):
-				self.Error = args[3]
-			if "Error" in kwargs:
-				self.Error = kwargs["Error"]
+				self.Count = args[0]
+			if "Count" in kwargs:
+				self.Count = kwargs["Count"]
 	def __del__(self):
 		_linksockslib.DecRef(self.handle)
 	def __str__(self):
 		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
-		sv = 'linksocks.TokenResponse{'
+		sv = 'linksocks.PartnersMessage{'
 		first = True
 		for v in pr:
 			if callable(v[1]):
@@ -5623,51 +5577,97 @@ class TokenResponse(go.GoClass):
 		return sv + '}'
 	def __repr__(self):
 		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
-		sv = 'linksocks.TokenResponse ( '
+		sv = 'linksocks.PartnersMessage ( '
 		for v in pr:
 			if not callable(v[1]):
 				sv += v[0] + '=' + str(v[1]) + ', '
 		return sv + ')'
 	@property
-	def Success(self):
-		return _linksockslib.linksocks_TokenResponse_Success_Get(self.handle)
-	@Success.setter
-	def Success(self, value):
+	def Count(self):
+		return _linksockslib.linksocks_PartnersMessage_Count_Get(self.handle)
+	@Count.setter
+	def Count(self, value):
 		if isinstance(value, go.GoClass):
-			_linksockslib.linksocks_TokenResponse_Success_Set(self.handle, value.handle)
+			_linksockslib.linksocks_PartnersMessage_Count_Set(self.handle, value.handle)
 		else:
-			_linksockslib.linksocks_TokenResponse_Success_Set(self.handle, value)
-	@property
-	def Token(self):
-		return _linksockslib.linksocks_TokenResponse_Token_Get(self.handle)
-	@Token.setter
-	def Token(self, value):
-		if isinstance(value, go.GoClass):
-			_linksockslib.linksocks_TokenResponse_Token_Set(self.handle, value.handle)
+			_linksockslib.linksocks_PartnersMessage_Count_Set(self.handle, value)
+	def GetType(self):
+		"""GetType() str"""
+		return _linksockslib.linksocks_PartnersMessage_GetType(self.handle)
+
+# Python type for struct linksocks.AuthResponseMessage
+class AuthResponseMessage(go.GoClass):
+	"""AuthResponseMessage represents an authentication response\n"""
+	def __init__(self, *args, **kwargs):
+		"""
+		handle=A Go-side object is always initialized with an explicit handle=arg
+		otherwise parameters can be unnamed in order of field names or named fields
+		in which case a new Go object is constructed first
+		"""
+		if len(kwargs) == 1 and 'handle' in kwargs:
+			self.handle = kwargs['handle']
+			_linksockslib.IncRef(self.handle)
+		elif len(args) == 1 and isinstance(args[0], go.GoClass):
+			self.handle = args[0].handle
+			_linksockslib.IncRef(self.handle)
 		else:
-			_linksockslib.linksocks_TokenResponse_Token_Set(self.handle, value)
+			self.handle = _linksockslib.linksocks_AuthResponseMessage_CTor()
+			_linksockslib.IncRef(self.handle)
+			if  0 < len(args):
+				self.Success = args[0]
+			if "Success" in kwargs:
+				self.Success = kwargs["Success"]
+			if  1 < len(args):
+				self.Error = args[1]
+			if "Error" in kwargs:
+				self.Error = kwargs["Error"]
+	def __del__(self):
+		_linksockslib.DecRef(self.handle)
+	def __str__(self):
+		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
+		sv = 'linksocks.AuthResponseMessage{'
+		first = True
+		for v in pr:
+			if callable(v[1]):
+				continue
+			if first:
+				first = False
+			else:
+				sv += ', '
+			sv += v[0] + '=' + str(v[1])
+		return sv + '}'
+	def __repr__(self):
+		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
+		sv = 'linksocks.AuthResponseMessage ( '
+		for v in pr:
+			if not callable(v[1]):
+				sv += v[0] + '=' + str(v[1]) + ', '
+		return sv + ')'
 	@property
-	def Port(self):
-		return _linksockslib.linksocks_TokenResponse_Port_Get(self.handle)
-	@Port.setter
-	def Port(self, value):
+	def Success(self):
+		return _linksockslib.linksocks_AuthResponseMessage_Success_Get(self.handle)
+	@Success.setter
+	def Success(self, value):
 		if isinstance(value, go.GoClass):
-			_linksockslib.linksocks_TokenResponse_Port_Set(self.handle, value.handle)
+			_linksockslib.linksocks_AuthResponseMessage_Success_Set(self.handle, value.handle)
 		else:
-			_linksockslib.linksocks_TokenResponse_Port_Set(self.handle, value)
+			_linksockslib.linksocks_AuthResponseMessage_Success_Set(self.handle, value)
 	@property
 	def Error(self):
-		return _linksockslib.linksocks_TokenResponse_Error_Get(self.handle)
+		return _linksockslib.linksocks_AuthResponseMessage_Error_Get(self.handle)
 	@Error.setter
 	def Error(self, value):
 		if isinstance(value, go.GoClass):
-			_linksockslib.linksocks_TokenResponse_Error_Set(self.handle, value.handle)
+			_linksockslib.linksocks_AuthResponseMessage_Error_Set(self.handle, value.handle)
 		else:
-			_linksockslib.linksocks_TokenResponse_Error_Set(self.handle, value)
+			_linksockslib.linksocks_AuthResponseMessage_Error_Set(self.handle, value)
+	def GetType(self):
+		"""GetType() str"""
+		return _linksockslib.linksocks_AuthResponseMessage_GetType(self.handle)
 
-# Python type for struct linksocks.ConnectorMessage
-class ConnectorMessage(go.GoClass):
-	"""ConnectorMessage represents a connector management command from reverse client\n"""
+# Python type for struct linksocks.ConnectResponseMessage
+class ConnectResponseMessage(go.GoClass):
+	"""ConnectResponseMessage represents a connection response\n"""
 	def __init__(self, *args, **kwargs):
 		"""
 		handle=A Go-side object is always initialized with an explicit handle=arg
@@ -5681,25 +5681,25 @@ class ConnectorMessage(go.GoClass):
 			self.handle = args[0].handle
 			_linksockslib.IncRef(self.handle)
 		else:
-			self.handle = _linksockslib.linksocks_ConnectorMessage_CTor()
+			self.handle = _linksockslib.linksocks_ConnectResponseMessage_CTor()
 			_linksockslib.IncRef(self.handle)
 			if  0 < len(args):
-				self.ChannelID = args[0]
-			if "ChannelID" in kwargs:
-				self.ChannelID = kwargs["ChannelID"]
+				self.Success = args[0]
+			if "Success" in kwargs:
+				self.Success = kwargs["Success"]
 			if  1 < len(args):
-				self.ConnectorToken = args[1]
-			if "ConnectorToken" in kwargs:
-				self.ConnectorToken = kwargs["ConnectorToken"]
+				self.Error = args[1]
+			if "Error" in kwargs:
+				self.Error = kwargs["Error"]
 			if  2 < len(args):
-				self.Operation = args[2]
-			if "Operation" in kwargs:
-				self.Operation = kwargs["Operation"]
+				self.ChannelID = args[2]
+			if "ChannelID" in kwargs:
+				self.ChannelID = kwargs["ChannelID"]
 	def __del__(self):
 		_linksockslib.DecRef(self.handle)
 	def __str__(self):
 		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
-		sv = 'linksocks.ConnectorMessage{'
+		sv = 'linksocks.ConnectResponseMessage{'
 		first = True
 		for v in pr:
 			if callable(v[1]):
@@ -5712,35 +5712,35 @@ class ConnectorMessage(go.GoClass):
 		return sv + '}'
 	def __repr__(self):
 		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
-		sv = 'linksocks.ConnectorMessage ( '
+		sv = 'linksocks.ConnectResponseMessage ( '
 		for v in pr:
 			if not callable(v[1]):
 				sv += v[0] + '=' + str(v[1]) + ', '
 		return sv + ')'
 	@property
-	def ChannelID(self):
-		return go.uuid_UUID(handle=_linksockslib.linksocks_ConnectorMessage_ChannelID_Get(self.handle))
-	@property
-	def ConnectorToken(self):
-		return _linksockslib.linksocks_ConnectorMessage_ConnectorToken_Get(self.handle)
-	@ConnectorToken.setter
-	def ConnectorToken(self, value):
+	def Success(self):
+		return _linksockslib.linksocks_ConnectResponseMessage_Success_Get(self.handle)
+	@Success.setter
+	def Success(self, value):
 		if isinstance(value, go.GoClass):
-			_linksockslib.linksocks_ConnectorMessage_ConnectorToken_Set(self.handle, value.handle)
+			_linksockslib.linksocks_ConnectResponseMessage_Success_Set(self.handle, value.handle)
 		else:
-			_linksockslib.linksocks_ConnectorMessage_ConnectorToken_Set(self.handle, value)
+			_linksockslib.linksocks_ConnectResponseMessage_Success_Set(self.handle, value)
 	@property
-	def Operation(self):
-		return _linksockslib.linksocks_ConnectorMessage_Operation_Get(self.handle)
-	@Operation.setter
-	def Operation(self, value):
+	def Error(self):
+		return _linksockslib.linksocks_ConnectResponseMessage_Error_Get(self.handle)
+	@Error.setter
+	def Error(self, value):
 		if isinstance(value, go.GoClass):
-			_linksockslib.linksocks_ConnectorMessage_Operation_Set(self.handle, value.handle)
+			_linksockslib.linksocks_ConnectResponseMessage_Error_Set(self.handle, value.handle)
 		else:
-			_linksockslib.linksocks_ConnectorMessage_Operation_Set(self.handle, value)
+			_linksockslib.linksocks_ConnectResponseMessage_Error_Set(self.handle, value)
+	@property
+	def ChannelID(self):
+		return go.uuid_UUID(handle=_linksockslib.linksocks_ConnectResponseMessage_ChannelID_Get(self.handle))
 	def GetType(self):
 		"""GetType() str"""
-		return _linksockslib.linksocks_ConnectorMessage_GetType(self.handle)
+		return _linksockslib.linksocks_ConnectResponseMessage_GetType(self.handle)
 
 
 # ---- Slices ---
@@ -5750,24 +5750,24 @@ class ConnectorMessage(go.GoClass):
 
 
 # ---- Constructors ---
-def NewContextWithCancel():
-	"""NewContextWithCancel() object
+def NewLinkSocksClient(token, opt):
+	"""NewLinkSocksClient(str token, object opt) object
 	
-	NewContextWithCancel creates a new context from the global context
+	NewLinkSocksClient creates a new LinkSocksClient instance
 	"""
-	return ContextWithCancel(handle=_linksockslib.linksocks_NewContextWithCancel())
-def NewPortPoolFromRange(start, end):
-	"""NewPortPoolFromRange(int start, int end) object
+	return LinkSocksClient(handle=_linksockslib.linksocks_NewLinkSocksClient(token, opt.handle))
+def NewRelay(logger, option):
+	"""NewRelay(object logger, object option) object
 	
-	NewPortPoolFromRange creates a new port pool from a range of ports
+	NewRelay creates a new Relay instance
 	"""
-	return PortPool(handle=_linksockslib.linksocks_NewPortPoolFromRange(start, end))
-def NewPortPool(ports):
-	"""NewPortPool([]int ports) object
+	return Relay(handle=_linksockslib.linksocks_NewRelay(logger.handle, option.handle))
+def NewLinkSocksServer(opt):
+	"""NewLinkSocksServer(object opt) object
 	
-	NewPortPool creates a new port pool from a slice of ports
+	NewLinkSocksServer creates a new LinkSocksServer instance
 	"""
-	return PortPool(handle=_linksockslib.linksocks_NewPortPool(ports.handle))
+	return LinkSocksServer(handle=_linksockslib.linksocks_NewLinkSocksServer(opt.handle))
 def DefaultClientOption():
 	"""DefaultClientOption() object
 	
@@ -5780,39 +5780,18 @@ def NewDefaultRelayOption():
 	NewDefaultRelayOption creates a RelayOption with default values
 	"""
 	return RelayOption(handle=_linksockslib.linksocks_NewDefaultRelayOption())
-def NewSocketManager(host, log):
-	"""NewSocketManager(str host, object log) object"""
-	return SocketManager(handle=_linksockslib.linksocks_NewSocketManager(host, log.handle))
-def NewLinkSocksClient(token, opt):
-	"""NewLinkSocksClient(str token, object opt) object
-	
-	NewLinkSocksClient creates a new LinkSocksClient instance
-	"""
-	return LinkSocksClient(handle=_linksockslib.linksocks_NewLinkSocksClient(token, opt.handle))
-def NewRelay(logger, option):
-	"""NewRelay(object logger, object option) object
-	
-	NewRelay creates a new Relay instance
-	"""
-	return Relay(handle=_linksockslib.linksocks_NewRelay(logger.handle, option.handle))
 def DefaultReverseTokenOptions():
 	"""DefaultReverseTokenOptions() object
 	
 	DefaultReverseTokenOptions returns default options for reverse token
 	"""
 	return ReverseTokenOptions(handle=_linksockslib.linksocks_DefaultReverseTokenOptions())
-def NewCLI():
-	"""NewCLI() object
-	
-	NewCLI creates a new CLI instance
-	"""
-	return CLI(handle=_linksockslib.linksocks_NewCLI())
-def NewLinkSocksServer(opt):
-	"""NewLinkSocksServer(object opt) object
+def DefaultServerOption():
+	"""DefaultServerOption() object
 	
-	NewLinkSocksServer creates a new LinkSocksServer instance
+	DefaultServerOption returns default server options
 	"""
-	return LinkSocksServer(handle=_linksockslib.linksocks_NewLinkSocksServer(opt.handle))
+	return ServerOption(handle=_linksockslib.linksocks_DefaultServerOption())
 def NewWSConn(conn, label, logger):
 	"""NewWSConn(object conn, str label, object logger) object
 	
@@ -5825,81 +5804,84 @@ def NewAPIHandler(server, apiKey):
 	NewAPIHandler creates a new API handler for the given server
 	"""
 	return APIHandler(handle=_linksockslib.linksocks_NewAPIHandler(server.handle, apiKey))
-def DefaultServerOption():
-	"""DefaultServerOption() object
+def NewCLI():
+	"""NewCLI() object
 	
-	DefaultServerOption returns default server options
+	NewCLI creates a new CLI instance
 	"""
-	return ServerOption(handle=_linksockslib.linksocks_DefaultServerOption())
+	return CLI(handle=_linksockslib.linksocks_NewCLI())
+def NewContextWithCancel():
+	"""NewContextWithCancel() object
+	
+	NewContextWithCancel creates a new context from the global context
+	"""
+	return ContextWithCancel(handle=_linksockslib.linksocks_NewContextWithCancel())
+def NewPortPoolFromRange(start, end):
+	"""NewPortPoolFromRange(int start, int end) object
+	
+	NewPortPoolFromRange creates a new port pool from a range of ports
+	"""
+	return PortPool(handle=_linksockslib.linksocks_NewPortPoolFromRange(start, end))
+def NewPortPool(ports):
+	"""NewPortPool([]int ports) object
+	
+	NewPortPool creates a new port pool from a slice of ports
+	"""
+	return PortPool(handle=_linksockslib.linksocks_NewPortPool(ports.handle))
+def NewSocketManager(host, log):
+	"""NewSocketManager(str host, object log) object"""
+	return SocketManager(handle=_linksockslib.linksocks_NewSocketManager(host, log.handle))
 
 
 # ---- Functions ---
-def NewLoggerWithID(id):
-	"""NewLoggerWithID(str id) object
+def Background():
+	"""Background() object
 	
-	NewLoggerWithID creates a new zerolog.Logger that tags output with the given ID
+	Background returns a global context
 	"""
-	return go.zerolog_Logger(handle=_linksockslib.linksocks_NewLoggerWithID(id))
-def GetLogEntries():
-	"""GetLogEntries() []object"""
-	return Slice_linksocks_LogEntry(handle=_linksockslib.linksocks_GetLogEntries())
-def NewLogger(cb):
-	"""NewLogger(callable cb) object
+	return go.context_Context(handle=_linksockslib.linksocks_Background())
+def CancelLogWaiters(goRun=False):
+	"""CancelLogWaiters() 
 	
-	NewLogger creates a new zerolog.Logger with auto-generated ID
+	CancelLogWaiters cancels all waiting log listeners
 	"""
-	return go.zerolog_Logger(handle=_linksockslib.linksocks_NewLogger(cb))
-def ParseMessage(data):
-	"""ParseMessage([]int data) object, str"""
-	return BaseMessage(handle=_linksockslib.linksocks_ParseMessage(data.handle))
-def SetLoggerGlobalLevel(level, goRun=False):
-	"""SetLoggerGlobalLevel(int level) 
+	_linksockslib.linksocks_CancelLogWaiters(goRun)
+def NewContext():
+	"""NewContext() object
 	
-	SetLoggerGlobalLevel sets the global log level for all loggers
+	NewContext creates a new context from the global context
 	"""
-	_linksockslib.linksocks_SetLoggerGlobalLevel(level, goRun)
-def WaitForLogEntries(timeoutMs):
-	"""WaitForLogEntries(long timeoutMs) []object"""
-	return Slice_linksocks_LogEntry(handle=_linksockslib.linksocks_WaitForLogEntries(timeoutMs))
+	return go.context_Context(handle=_linksockslib.linksocks_NewContext())
 def PackMessage(msg):
 	"""PackMessage(object msg) []int, str
 	
 	PackMessage converts a message to binary format
 	"""
 	return go.Slice_byte(handle=_linksockslib.linksocks_PackMessage(msg.handle))
-def ParseDuration(s):
-	"""ParseDuration(str s) long, str
-	
-	ParseDuration parses a duration string.
-	A duration string is a possibly signed sequence of decimal numbers,
-	each with optional fraction and a unit suffix, such as "300ms", "-1.5h" or "2h45m".
-	Valid time units are "ns", "us" (or "µs"), "ms", "s", "m", "h".
-	"""
-	return _linksockslib.linksocks_ParseDuration(s)
 def DebugLog(logger, msg, goRun=False):
 	"""DebugLog(object logger, str msg) 
 	
 	DebugLog logs a debug message
 	"""
 	_linksockslib.linksocks_DebugLog(logger.handle, msg, goRun)
-def NewContext():
-	"""NewContext() object
+def NewLogger(cb):
+	"""NewLogger(callable cb) object
 	
-	NewContext creates a new context from the global context
+	NewLogger creates a new zerolog.Logger with auto-generated ID
 	"""
-	return go.context_Context(handle=_linksockslib.linksocks_NewContext())
+	return go.zerolog_Logger(handle=_linksockslib.linksocks_NewLogger(cb))
 def NewLoggerWithLevel(level, cb):
 	"""NewLoggerWithLevel(int level, callable cb) object
 	
 	NewLoggerWithLevel creates a new zerolog.Logger with auto-generated ID and specified level
 	"""
 	return go.zerolog_Logger(handle=_linksockslib.linksocks_NewLoggerWithLevel(level, cb))
-def CancelLogWaiters(goRun=False):
-	"""CancelLogWaiters() 
-	
-	CancelLogWaiters cancels all waiting log listeners
-	"""
-	_linksockslib.linksocks_CancelLogWaiters(goRun)
+def WaitForLogEntries(timeoutMs):
+	"""WaitForLogEntries(long timeoutMs) []object"""
+	return Slice_linksocks_LogEntry(handle=_linksockslib.linksocks_WaitForLogEntries(timeoutMs))
+def GetLogEntries():
+	"""GetLogEntries() []object"""
+	return Slice_linksocks_LogEntry(handle=_linksockslib.linksocks_GetLogEntries())
 def NewLoggerWithIDAndLevel(id, level):
 	"""NewLoggerWithIDAndLevel(str id, int level) object
 	
@@ -5912,11 +5894,29 @@ def CancelGlobalContext(goRun=False):
 	CancelGlobalContext cancels the global context
 	"""
 	_linksockslib.linksocks_CancelGlobalContext(goRun)
-def Background():
-	"""Background() object
+def ParseDuration(s):
+	"""ParseDuration(str s) long, str
 	
-	Background returns a global context
+	ParseDuration parses a duration string.
+	A duration string is a possibly signed sequence of decimal numbers,
+	each with optional fraction and a unit suffix, such as "300ms", "-1.5h" or "2h45m".
+	Valid time units are "ns", "us" (or "µs"), "ms", "s", "m", "h".
 	"""
-	return go.context_Context(handle=_linksockslib.linksocks_Background())
+	return _linksockslib.linksocks_ParseDuration(s)
+def SetLoggerGlobalLevel(level, goRun=False):
+	"""SetLoggerGlobalLevel(int level) 
+	
+	SetLoggerGlobalLevel sets the global log level for all loggers
+	"""
+	_linksockslib.linksocks_SetLoggerGlobalLevel(level, goRun)
+def NewLoggerWithID(id):
+	"""NewLoggerWithID(str id) object
+	
+	NewLoggerWithID creates a new zerolog.Logger that tags output with the given ID
+	"""
+	return go.zerolog_Logger(handle=_linksockslib.linksocks_NewLoggerWithID(id))
+def ParseMessage(data):
+	"""ParseMessage([]int data) object, str"""
+	return BaseMessage(handle=_linksockslib.linksocks_ParseMessage(data.handle))