objective-lol 0.0.1__cp311-cp311-macosx_11_0_arm64.whl → 0.0.2__cp311-cp311-macosx_11_0_arm64.whl

objective_lol/api.py

@@ -741,9 +741,9 @@ TimeoutErrorType = "timeout"
 
 # ---- Structs ---
 
-# Python type for struct api.ClassMethod
-class ClassMethod(go.GoClass):
-	""""""
+# Python type for struct api.SourceLocation
+class SourceLocation(go.GoClass):
+	"""SourceLocation represents a location in source code\n"""
 	def __init__(self, *args, **kwargs):
 		"""
 		handle=A Go-side object is always initialized with an explicit handle=arg
@@ -757,21 +757,25 @@ class ClassMethod(go.GoClass):
 			self.handle = args[0].handle
 			_api.IncRef(self.handle)
 		else:
-			self.handle = _api.api_ClassMethod_CTor()
+			self.handle = _api.api_SourceLocation_CTor()
 			_api.IncRef(self.handle)
 			if  0 < len(args):
-				self.Name = args[0]
-			if "Name" in kwargs:
-				self.Name = kwargs["Name"]
+				self.Filename = args[0]
+			if "Filename" in kwargs:
+				self.Filename = kwargs["Filename"]
 			if  1 < len(args):
-				self.Argc = args[1]
-			if "Argc" in kwargs:
-				self.Argc = kwargs["Argc"]
+				self.Line = args[1]
+			if "Line" in kwargs:
+				self.Line = kwargs["Line"]
+			if  2 < len(args):
+				self.Column = args[2]
+			if "Column" in kwargs:
+				self.Column = kwargs["Column"]
 	def __del__(self):
 		_api.DecRef(self.handle)
 	def __str__(self):
 		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
-		sv = 'api.ClassMethod{'
+		sv = 'api.SourceLocation{'
 		first = True
 		for v in pr:
 			if callable(v[1]):
@@ -784,33 +788,42 @@ class ClassMethod(go.GoClass):
 		return sv + '}'
 	def __repr__(self):
 		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
-		sv = 'api.ClassMethod ( '
+		sv = 'api.SourceLocation ( '
 		for v in pr:
 			if not callable(v[1]):
 				sv += v[0] + '=' + str(v[1]) + ', '
 		return sv + ')'
 	@property
-	def Name(self):
-		return _api.api_ClassMethod_Name_Get(self.handle)
-	@Name.setter
-	def Name(self, value):
+	def Filename(self):
+		return _api.api_SourceLocation_Filename_Get(self.handle)
+	@Filename.setter
+	def Filename(self, value):
 		if isinstance(value, go.GoClass):
-			_api.api_ClassMethod_Name_Set(self.handle, value.handle)
+			_api.api_SourceLocation_Filename_Set(self.handle, value.handle)
 		else:
-			_api.api_ClassMethod_Name_Set(self.handle, value)
+			_api.api_SourceLocation_Filename_Set(self.handle, value)
 	@property
-	def Argc(self):
-		return _api.api_ClassMethod_Argc_Get(self.handle)
-	@Argc.setter
-	def Argc(self, value):
+	def Line(self):
+		return _api.api_SourceLocation_Line_Get(self.handle)
+	@Line.setter
+	def Line(self, value):
 		if isinstance(value, go.GoClass):
-			_api.api_ClassMethod_Argc_Set(self.handle, value.handle)
+			_api.api_SourceLocation_Line_Set(self.handle, value.handle)
 		else:
-			_api.api_ClassMethod_Argc_Set(self.handle, value)
+			_api.api_SourceLocation_Line_Set(self.handle, value)
+	@property
+	def Column(self):
+		return _api.api_SourceLocation_Column_Get(self.handle)
+	@Column.setter
+	def Column(self, value):
+		if isinstance(value, go.GoClass):
+			_api.api_SourceLocation_Column_Set(self.handle, value.handle)
+		else:
+			_api.api_SourceLocation_Column_Set(self.handle, value)
 
-# Python type for struct api.ExecutionResult
-class ExecutionResult(go.GoClass):
-	"""ExecutionResult represents the result of executing Objective-LOL code\n"""
+# Python type for struct api.UnknownFunctionHandler
+class UnknownFunctionHandler(go.GoClass):
+	""""""
 	def __init__(self, *args, **kwargs):
 		"""
 		handle=A Go-side object is always initialized with an explicit handle=arg
@@ -824,25 +837,13 @@ class ExecutionResult(go.GoClass):
 			self.handle = args[0].handle
 			_api.IncRef(self.handle)
 		else:
-			self.handle = _api.api_ExecutionResult_CTor()
+			self.handle = _api.api_UnknownFunctionHandler_CTor()
 			_api.IncRef(self.handle)
-			if  0 < len(args):
-				self.Value = args[0]
-			if "Value" in kwargs:
-				self.Value = kwargs["Value"]
-			if  1 < len(args):
-				self.RawValue = args[1]
-			if "RawValue" in kwargs:
-				self.RawValue = kwargs["RawValue"]
-			if  2 < len(args):
-				self.Output = args[2]
-			if "Output" in kwargs:
-				self.Output = kwargs["Output"]
 	def __del__(self):
 		_api.DecRef(self.handle)
 	def __str__(self):
 		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
-		sv = 'api.ExecutionResult{'
+		sv = 'api.UnknownFunctionHandler{'
 		first = True
 		for v in pr:
 			if callable(v[1]):
@@ -855,48 +856,15 @@ class ExecutionResult(go.GoClass):
 		return sv + '}'
 	def __repr__(self):
 		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
-		sv = 'api.ExecutionResult ( '
+		sv = 'api.UnknownFunctionHandler ( '
 		for v in pr:
 			if not callable(v[1]):
 				sv += v[0] + '=' + str(v[1]) + ', '
 		return sv + ')'
-	@property
-	def Value(self):
-		"""Return value from the execution (e.g., from MAIN function)
-		"""
-		return GoValue(handle=_api.api_ExecutionResult_Value_Get(self.handle))
-	@Value.setter
-	def Value(self, value):
-		if isinstance(value, go.GoClass):
-			_api.api_ExecutionResult_Value_Set(self.handle, value.handle)
-		else:
-			raise TypeError("supplied argument type {t} is not a go.GoClass".format(t=type(value)))
-	@property
-	def RawValue(self):
-		"""Raw Objective-LOL value (for advanced use)
-		"""
-		return go.environment_Value(handle=_api.api_ExecutionResult_RawValue_Get(self.handle))
-	@RawValue.setter
-	def RawValue(self, value):
-		if isinstance(value, go.GoClass):
-			_api.api_ExecutionResult_RawValue_Set(self.handle, value.handle)
-		else:
-			raise TypeError("supplied argument type {t} is not a go.GoClass".format(t=type(value)))
-	@property
-	def Output(self):
-		"""Output captured during execution (if configured)
-		"""
-		return _api.api_ExecutionResult_Output_Get(self.handle)
-	@Output.setter
-	def Output(self, value):
-		if isinstance(value, go.GoClass):
-			_api.api_ExecutionResult_Output_Set(self.handle, value.handle)
-		else:
-			_api.api_ExecutionResult_Output_Set(self.handle, value)
 
-# Python type for struct api.UnknownFunctionHandler
-class UnknownFunctionHandler(go.GoClass):
-	""""""
+# Python type for struct api.VMCompatibilityShim
+class VMCompatibilityShim(go.GoClass):
+	"""VMCompatibilityShim is a shim to provide compatibility for external\nlanguages that cannot interact with the standard VM interface through\nGo types. Message passing is done through JSON strings.\n"""
 	def __init__(self, *args, **kwargs):
 		"""
 		handle=A Go-side object is always initialized with an explicit handle=arg
@@ -910,13 +878,13 @@ class UnknownFunctionHandler(go.GoClass):
 			self.handle = args[0].handle
 			_api.IncRef(self.handle)
 		else:
-			self.handle = _api.api_UnknownFunctionHandler_CTor()
+			self.handle = _api.api_VMCompatibilityShim_CTor()
 			_api.IncRef(self.handle)
 	def __del__(self):
 		_api.DecRef(self.handle)
 	def __str__(self):
 		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
-		sv = 'api.UnknownFunctionHandler{'
+		sv = 'api.VMCompatibilityShim{'
 		first = True
 		for v in pr:
 			if callable(v[1]):
@@ -929,11 +897,51 @@ class UnknownFunctionHandler(go.GoClass):
 		return sv + '}'
 	def __repr__(self):
 		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
-		sv = 'api.UnknownFunctionHandler ( '
+		sv = 'api.VMCompatibilityShim ( '
 		for v in pr:
 			if not callable(v[1]):
 				sv += v[0] + '=' + str(v[1]) + ', '
 		return sv + ')'
+	def DefineFunction(self, id, name, argc, function):
+		"""DefineFunction(str id, str name, int argc, callable function) str
+		
+		DefineFunction defines a global function with maximum compatibility,
+		wrapping arguments and return values as JSON strings.
+		An optional id cookie is passed back to the function to identify it.
+		jsonArgs is a JSON array string of the arguments.
+		The function should return a JSON object string with "result" and "error" fields.
+		"""
+		return _api.api_VMCompatibilityShim_DefineFunction(self.handle, id, name, argc, function)
+	def BuildNewClassVariableWithGetter(self, variable, getterID, getter):
+		"""BuildNewClassVariableWithGetter(object variable, str getterID, callable getter) object"""
+		return ClassVariable(handle=_api.api_VMCompatibilityShim_BuildNewClassVariableWithGetter(self.handle, variable.handle, getterID, getter))
+	def BuildNewClassVariableWithSetter(self, variable, setterID, setter):
+		"""BuildNewClassVariableWithSetter(object variable, str setterID, callable setter) object"""
+		return ClassVariable(handle=_api.api_VMCompatibilityShim_BuildNewClassVariableWithSetter(self.handle, variable.handle, setterID, setter))
+	def BuildNewClassMethod(self, method, id, function):
+		"""BuildNewClassMethod(object method, str id, callable function) object"""
+		return ClassMethod(handle=_api.api_VMCompatibilityShim_BuildNewClassMethod(self.handle, method.handle, id, function))
+	def BuildNewUnknownFunctionHandler(self, id, function):
+		"""BuildNewUnknownFunctionHandler(str id, callable function) object"""
+		return UnknownFunctionHandler(handle=_api.api_VMCompatibilityShim_BuildNewUnknownFunctionHandler(self.handle, id, function))
+	def IsClassDefined(self, name):
+		"""IsClassDefined(str name) bool"""
+		return _api.api_VMCompatibilityShim_IsClassDefined(self.handle, name)
+	def LookupObject(self, id):
+		"""LookupObject(str id) object, str"""
+		return GoValue(handle=_api.api_VMCompatibilityShim_LookupObject(self.handle, id))
+	def GetObjectMRO(self, id):
+		"""GetObjectMRO(str id) []str, str"""
+		return go.Slice_string(handle=_api.api_VMCompatibilityShim_GetObjectMRO(self.handle, id))
+	def GetObjectImmediateFunctions(self, id):
+		"""GetObjectImmediateFunctions(str id) []str, str"""
+		return go.Slice_string(handle=_api.api_VMCompatibilityShim_GetObjectImmediateFunctions(self.handle, id))
+	def GetObjectImmediateVariables(self, id):
+		"""GetObjectImmediateVariables(str id) []str, str"""
+		return go.Slice_string(handle=_api.api_VMCompatibilityShim_GetObjectImmediateVariables(self.handle, id))
+	def AddVariableToObject(self, id, variable):
+		"""AddVariableToObject(str id, object variable) str"""
+		return _api.api_VMCompatibilityShim_AddVariableToObject(self.handle, id, variable.handle)
 
 # Python type for struct api.VMConfig
 class VMConfig(go.GoClass):
@@ -1038,9 +1046,9 @@ class VMConfig(go.GoClass):
 		"""
 		return _api.api_VMConfig_Validate(self.handle)
 
-# Python type for struct api.ClassDefinition
-class ClassDefinition(go.GoClass):
-	""""""
+# Python type for struct api.VM
+class VM(go.GoClass):
+	"""VM represents an Objective-LOL virtual machine instance\n"""
 	def __init__(self, *args, **kwargs):
 		"""
 		handle=A Go-side object is always initialized with an explicit handle=arg
@@ -1054,41 +1062,13 @@ class ClassDefinition(go.GoClass):
 			self.handle = args[0].handle
 			_api.IncRef(self.handle)
 		else:
-			self.handle = _api.api_ClassDefinition_CTor()
+			self.handle = _api.api_VM_CTor()
 			_api.IncRef(self.handle)
-			if  0 < len(args):
-				self.Name = args[0]
-			if "Name" in kwargs:
-				self.Name = kwargs["Name"]
-			if  1 < len(args):
-				self.PublicVariables = args[1]
-			if "PublicVariables" in kwargs:
-				self.PublicVariables = kwargs["PublicVariables"]
-			if  2 < len(args):
-				self.PrivateVariables = args[2]
-			if "PrivateVariables" in kwargs:
-				self.PrivateVariables = kwargs["PrivateVariables"]
-			if  3 < len(args):
-				self.SharedVariables = args[3]
-			if "SharedVariables" in kwargs:
-				self.SharedVariables = kwargs["SharedVariables"]
-			if  4 < len(args):
-				self.PublicMethods = args[4]
-			if "PublicMethods" in kwargs:
-				self.PublicMethods = kwargs["PublicMethods"]
-			if  5 < len(args):
-				self.PrivateMethods = args[5]
-			if "PrivateMethods" in kwargs:
-				self.PrivateMethods = kwargs["PrivateMethods"]
-			if  6 < len(args):
-				self.UnknownFunctionHandler = args[6]
-			if "UnknownFunctionHandler" in kwargs:
-				self.UnknownFunctionHandler = kwargs["UnknownFunctionHandler"]
 	def __del__(self):
 		_api.DecRef(self.handle)
 	def __str__(self):
 		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
-		sv = 'api.ClassDefinition{'
+		sv = 'api.VM{'
 		first = True
 		for v in pr:
 			if callable(v[1]):
@@ -1101,262 +1081,7 @@ class ClassDefinition(go.GoClass):
 		return sv + '}'
 	def __repr__(self):
 		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
-		sv = 'api.ClassDefinition ( '
-		for v in pr:
-			if not callable(v[1]):
-				sv += v[0] + '=' + str(v[1]) + ', '
-		return sv + ')'
-	@property
-	def Name(self):
-		return _api.api_ClassDefinition_Name_Get(self.handle)
-	@Name.setter
-	def Name(self, value):
-		if isinstance(value, go.GoClass):
-			_api.api_ClassDefinition_Name_Set(self.handle, value.handle)
-		else:
-			_api.api_ClassDefinition_Name_Set(self.handle, value)
-	@property
-	def PublicVariables(self):
-		return Map_string_Ptr_api_ClassVariable(handle=_api.api_ClassDefinition_PublicVariables_Get(self.handle))
-	@PublicVariables.setter
-	def PublicVariables(self, value):
-		if isinstance(value, go.GoClass):
-			_api.api_ClassDefinition_PublicVariables_Set(self.handle, value.handle)
-		else:
-			raise TypeError("supplied argument type {t} is not a go.GoClass".format(t=type(value)))
-	@property
-	def PrivateVariables(self):
-		return Map_string_Ptr_api_ClassVariable(handle=_api.api_ClassDefinition_PrivateVariables_Get(self.handle))
-	@PrivateVariables.setter
-	def PrivateVariables(self, value):
-		if isinstance(value, go.GoClass):
-			_api.api_ClassDefinition_PrivateVariables_Set(self.handle, value.handle)
-		else:
-			raise TypeError("supplied argument type {t} is not a go.GoClass".format(t=type(value)))
-	@property
-	def SharedVariables(self):
-		return Map_string_Ptr_api_ClassVariable(handle=_api.api_ClassDefinition_SharedVariables_Get(self.handle))
-	@SharedVariables.setter
-	def SharedVariables(self, value):
-		if isinstance(value, go.GoClass):
-			_api.api_ClassDefinition_SharedVariables_Set(self.handle, value.handle)
-		else:
-			raise TypeError("supplied argument type {t} is not a go.GoClass".format(t=type(value)))
-	@property
-	def PublicMethods(self):
-		return Map_string_Ptr_api_ClassMethod(handle=_api.api_ClassDefinition_PublicMethods_Get(self.handle))
-	@PublicMethods.setter
-	def PublicMethods(self, value):
-		if isinstance(value, go.GoClass):
-			_api.api_ClassDefinition_PublicMethods_Set(self.handle, value.handle)
-		else:
-			raise TypeError("supplied argument type {t} is not a go.GoClass".format(t=type(value)))
-	@property
-	def PrivateMethods(self):
-		return Map_string_Ptr_api_ClassMethod(handle=_api.api_ClassDefinition_PrivateMethods_Get(self.handle))
-	@PrivateMethods.setter
-	def PrivateMethods(self, value):
-		if isinstance(value, go.GoClass):
-			_api.api_ClassDefinition_PrivateMethods_Set(self.handle, value.handle)
-		else:
-			raise TypeError("supplied argument type {t} is not a go.GoClass".format(t=type(value)))
-	@property
-	def UnknownFunctionHandler(self):
-		return UnknownFunctionHandler(handle=_api.api_ClassDefinition_UnknownFunctionHandler_Get(self.handle))
-	@UnknownFunctionHandler.setter
-	def UnknownFunctionHandler(self, value):
-		if isinstance(value, go.GoClass):
-			_api.api_ClassDefinition_UnknownFunctionHandler_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 api.GoValue
-class GoValue(go.GoClass):
-	""""""
-	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']
-			_api.IncRef(self.handle)
-		elif len(args) == 1 and isinstance(args[0], go.GoClass):
-			self.handle = args[0].handle
-			_api.IncRef(self.handle)
-		else:
-			self.handle = _api.api_GoValue_CTor()
-			_api.IncRef(self.handle)
-	def __del__(self):
-		_api.DecRef(self.handle)
-	def __str__(self):
-		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
-		sv = 'api.GoValue{'
-		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 = 'api.GoValue ( '
-		for v in pr:
-			if not callable(v[1]):
-				sv += v[0] + '=' + str(v[1]) + ', '
-		return sv + ')'
-	def ID(self):
-		"""ID() str"""
-		return _api.api_GoValue_ID(self.handle)
-	def MarshalJSON(self):
-		"""MarshalJSON() []int, str"""
-		return go.Slice_byte(handle=_api.api_GoValue_MarshalJSON(self.handle))
-	def Type(self):
-		"""Type() str"""
-		return _api.api_GoValue_Type(self.handle)
-	def Int(self):
-		"""Int() long, str"""
-		return _api.api_GoValue_Int(self.handle)
-	def Float(self):
-		"""Float() float, str"""
-		return _api.api_GoValue_Float(self.handle)
-	def String(self):
-		"""String() str, str"""
-		return _api.api_GoValue_String(self.handle)
-	def Bool(self):
-		"""Bool() bool, str"""
-		return _api.api_GoValue_Bool(self.handle)
-	def Slice(self):
-		"""Slice() []object, str"""
-		return Slice_api_GoValue(handle=_api.api_GoValue_Slice(self.handle))
-	def Map(self):
-		"""Map() object, str"""
-		return Map_string_api_GoValue(handle=_api.api_GoValue_Map(self.handle))
-	def Object(self):
-		"""Object() object, str"""
-		return go.Ptr_environment_ObjectInstance(handle=_api.api_GoValue_Object(self.handle))
-
-# Python type for struct api.SourceLocation
-class SourceLocation(go.GoClass):
-	"""SourceLocation represents a location in source code\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']
-			_api.IncRef(self.handle)
-		elif len(args) == 1 and isinstance(args[0], go.GoClass):
-			self.handle = args[0].handle
-			_api.IncRef(self.handle)
-		else:
-			self.handle = _api.api_SourceLocation_CTor()
-			_api.IncRef(self.handle)
-			if  0 < len(args):
-				self.Filename = args[0]
-			if "Filename" in kwargs:
-				self.Filename = kwargs["Filename"]
-			if  1 < len(args):
-				self.Line = args[1]
-			if "Line" in kwargs:
-				self.Line = kwargs["Line"]
-			if  2 < len(args):
-				self.Column = args[2]
-			if "Column" in kwargs:
-				self.Column = kwargs["Column"]
-	def __del__(self):
-		_api.DecRef(self.handle)
-	def __str__(self):
-		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
-		sv = 'api.SourceLocation{'
-		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 = 'api.SourceLocation ( '
-		for v in pr:
-			if not callable(v[1]):
-				sv += v[0] + '=' + str(v[1]) + ', '
-		return sv + ')'
-	@property
-	def Filename(self):
-		return _api.api_SourceLocation_Filename_Get(self.handle)
-	@Filename.setter
-	def Filename(self, value):
-		if isinstance(value, go.GoClass):
-			_api.api_SourceLocation_Filename_Set(self.handle, value.handle)
-		else:
-			_api.api_SourceLocation_Filename_Set(self.handle, value)
-	@property
-	def Line(self):
-		return _api.api_SourceLocation_Line_Get(self.handle)
-	@Line.setter
-	def Line(self, value):
-		if isinstance(value, go.GoClass):
-			_api.api_SourceLocation_Line_Set(self.handle, value.handle)
-		else:
-			_api.api_SourceLocation_Line_Set(self.handle, value)
-	@property
-	def Column(self):
-		return _api.api_SourceLocation_Column_Get(self.handle)
-	@Column.setter
-	def Column(self, value):
-		if isinstance(value, go.GoClass):
-			_api.api_SourceLocation_Column_Set(self.handle, value.handle)
-		else:
-			_api.api_SourceLocation_Column_Set(self.handle, value)
-
-# Python type for struct api.VM
-class VM(go.GoClass):
-	"""VM represents an Objective-LOL virtual machine instance\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']
-			_api.IncRef(self.handle)
-		elif len(args) == 1 and isinstance(args[0], go.GoClass):
-			self.handle = args[0].handle
-			_api.IncRef(self.handle)
-		else:
-			self.handle = _api.api_VM_CTor()
-			_api.IncRef(self.handle)
-	def __del__(self):
-		_api.DecRef(self.handle)
-	def __str__(self):
-		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
-		sv = 'api.VM{'
-		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 = 'api.VM ( '
+		sv = 'api.VM ( '
 		for v in pr:
 			if not callable(v[1]):
 				sv += v[0] + '=' + str(v[1]) + ', '
@@ -1416,87 +1141,6 @@ class VM(go.GoClass):
 		"""DefineClass(object classDef) str"""
 		return _api.api_VM_DefineClass(self.handle, classDef.handle)
 
-# Python type for struct api.VMCompatibilityShim
-class VMCompatibilityShim(go.GoClass):
-	"""VMCompatibilityShim is a shim to provide compatibility for external\nlanguages that cannot interact with the standard VM interface through\nGo types. Message passing is done through JSON strings.\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']
-			_api.IncRef(self.handle)
-		elif len(args) == 1 and isinstance(args[0], go.GoClass):
-			self.handle = args[0].handle
-			_api.IncRef(self.handle)
-		else:
-			self.handle = _api.api_VMCompatibilityShim_CTor()
-			_api.IncRef(self.handle)
-	def __del__(self):
-		_api.DecRef(self.handle)
-	def __str__(self):
-		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
-		sv = 'api.VMCompatibilityShim{'
-		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 = 'api.VMCompatibilityShim ( '
-		for v in pr:
-			if not callable(v[1]):
-				sv += v[0] + '=' + str(v[1]) + ', '
-		return sv + ')'
-	def DefineFunction(self, id, name, argc, function):
-		"""DefineFunction(str id, str name, int argc, callable function) str
-		
-		DefineFunction defines a global function with maximum compatibility,
-		wrapping arguments and return values as JSON strings.
-		An optional id cookie is passed back to the function to identify it.
-		jsonArgs is a JSON array string of the arguments.
-		The function should return a JSON object string with "result" and "error" fields.
-		"""
-		return _api.api_VMCompatibilityShim_DefineFunction(self.handle, id, name, argc, function)
-	def BuildNewClassVariableWithGetter(self, variable, getterID, getter):
-		"""BuildNewClassVariableWithGetter(object variable, str getterID, callable getter) object"""
-		return ClassVariable(handle=_api.api_VMCompatibilityShim_BuildNewClassVariableWithGetter(self.handle, variable.handle, getterID, getter))
-	def BuildNewClassVariableWithSetter(self, variable, setterID, setter):
-		"""BuildNewClassVariableWithSetter(object variable, str setterID, callable setter) object"""
-		return ClassVariable(handle=_api.api_VMCompatibilityShim_BuildNewClassVariableWithSetter(self.handle, variable.handle, setterID, setter))
-	def BuildNewClassMethod(self, method, id, function):
-		"""BuildNewClassMethod(object method, str id, callable function) object"""
-		return ClassMethod(handle=_api.api_VMCompatibilityShim_BuildNewClassMethod(self.handle, method.handle, id, function))
-	def BuildNewUnknownFunctionHandler(self, id, function):
-		"""BuildNewUnknownFunctionHandler(str id, callable function) object"""
-		return UnknownFunctionHandler(handle=_api.api_VMCompatibilityShim_BuildNewUnknownFunctionHandler(self.handle, id, function))
-	def IsClassDefined(self, name):
-		"""IsClassDefined(str name) bool"""
-		return _api.api_VMCompatibilityShim_IsClassDefined(self.handle, name)
-	def LookupObject(self, id):
-		"""LookupObject(str id) object, str"""
-		return GoValue(handle=_api.api_VMCompatibilityShim_LookupObject(self.handle, id))
-	def GetObjectMRO(self, id):
-		"""GetObjectMRO(str id) []str, str"""
-		return go.Slice_string(handle=_api.api_VMCompatibilityShim_GetObjectMRO(self.handle, id))
-	def GetObjectImmediateFunctions(self, id):
-		"""GetObjectImmediateFunctions(str id) []str, str"""
-		return go.Slice_string(handle=_api.api_VMCompatibilityShim_GetObjectImmediateFunctions(self.handle, id))
-	def GetObjectImmediateVariables(self, id):
-		"""GetObjectImmediateVariables(str id) []str, str"""
-		return go.Slice_string(handle=_api.api_VMCompatibilityShim_GetObjectImmediateVariables(self.handle, id))
-	def AddVariableToObject(self, id, variable):
-		"""AddVariableToObject(str id, object variable) str"""
-		return _api.api_VMCompatibilityShim_AddVariableToObject(self.handle, id, variable.handle)
-
 # Python type for struct api.VMError
 class VMError(go.GoClass):
 	"""VMError represents errors that can occur in the VM API\n"""
@@ -1626,6 +1270,205 @@ class VMError(go.GoClass):
 		"""
 		return _api.api_VMError_IsConfigError(self.handle)
 
+# Python type for struct api.ClassDefinition
+class ClassDefinition(go.GoClass):
+	""""""
+	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']
+			_api.IncRef(self.handle)
+		elif len(args) == 1 and isinstance(args[0], go.GoClass):
+			self.handle = args[0].handle
+			_api.IncRef(self.handle)
+		else:
+			self.handle = _api.api_ClassDefinition_CTor()
+			_api.IncRef(self.handle)
+			if  0 < len(args):
+				self.Name = args[0]
+			if "Name" in kwargs:
+				self.Name = kwargs["Name"]
+			if  1 < len(args):
+				self.PublicVariables = args[1]
+			if "PublicVariables" in kwargs:
+				self.PublicVariables = kwargs["PublicVariables"]
+			if  2 < len(args):
+				self.PrivateVariables = args[2]
+			if "PrivateVariables" in kwargs:
+				self.PrivateVariables = kwargs["PrivateVariables"]
+			if  3 < len(args):
+				self.SharedVariables = args[3]
+			if "SharedVariables" in kwargs:
+				self.SharedVariables = kwargs["SharedVariables"]
+			if  4 < len(args):
+				self.PublicMethods = args[4]
+			if "PublicMethods" in kwargs:
+				self.PublicMethods = kwargs["PublicMethods"]
+			if  5 < len(args):
+				self.PrivateMethods = args[5]
+			if "PrivateMethods" in kwargs:
+				self.PrivateMethods = kwargs["PrivateMethods"]
+			if  6 < len(args):
+				self.UnknownFunctionHandler = args[6]
+			if "UnknownFunctionHandler" in kwargs:
+				self.UnknownFunctionHandler = kwargs["UnknownFunctionHandler"]
+	def __del__(self):
+		_api.DecRef(self.handle)
+	def __str__(self):
+		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
+		sv = 'api.ClassDefinition{'
+		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 = 'api.ClassDefinition ( '
+		for v in pr:
+			if not callable(v[1]):
+				sv += v[0] + '=' + str(v[1]) + ', '
+		return sv + ')'
+	@property
+	def Name(self):
+		return _api.api_ClassDefinition_Name_Get(self.handle)
+	@Name.setter
+	def Name(self, value):
+		if isinstance(value, go.GoClass):
+			_api.api_ClassDefinition_Name_Set(self.handle, value.handle)
+		else:
+			_api.api_ClassDefinition_Name_Set(self.handle, value)
+	@property
+	def PublicVariables(self):
+		return Map_string_Ptr_api_ClassVariable(handle=_api.api_ClassDefinition_PublicVariables_Get(self.handle))
+	@PublicVariables.setter
+	def PublicVariables(self, value):
+		if isinstance(value, go.GoClass):
+			_api.api_ClassDefinition_PublicVariables_Set(self.handle, value.handle)
+		else:
+			raise TypeError("supplied argument type {t} is not a go.GoClass".format(t=type(value)))
+	@property
+	def PrivateVariables(self):
+		return Map_string_Ptr_api_ClassVariable(handle=_api.api_ClassDefinition_PrivateVariables_Get(self.handle))
+	@PrivateVariables.setter
+	def PrivateVariables(self, value):
+		if isinstance(value, go.GoClass):
+			_api.api_ClassDefinition_PrivateVariables_Set(self.handle, value.handle)
+		else:
+			raise TypeError("supplied argument type {t} is not a go.GoClass".format(t=type(value)))
+	@property
+	def SharedVariables(self):
+		return Map_string_Ptr_api_ClassVariable(handle=_api.api_ClassDefinition_SharedVariables_Get(self.handle))
+	@SharedVariables.setter
+	def SharedVariables(self, value):
+		if isinstance(value, go.GoClass):
+			_api.api_ClassDefinition_SharedVariables_Set(self.handle, value.handle)
+		else:
+			raise TypeError("supplied argument type {t} is not a go.GoClass".format(t=type(value)))
+	@property
+	def PublicMethods(self):
+		return Map_string_Ptr_api_ClassMethod(handle=_api.api_ClassDefinition_PublicMethods_Get(self.handle))
+	@PublicMethods.setter
+	def PublicMethods(self, value):
+		if isinstance(value, go.GoClass):
+			_api.api_ClassDefinition_PublicMethods_Set(self.handle, value.handle)
+		else:
+			raise TypeError("supplied argument type {t} is not a go.GoClass".format(t=type(value)))
+	@property
+	def PrivateMethods(self):
+		return Map_string_Ptr_api_ClassMethod(handle=_api.api_ClassDefinition_PrivateMethods_Get(self.handle))
+	@PrivateMethods.setter
+	def PrivateMethods(self, value):
+		if isinstance(value, go.GoClass):
+			_api.api_ClassDefinition_PrivateMethods_Set(self.handle, value.handle)
+		else:
+			raise TypeError("supplied argument type {t} is not a go.GoClass".format(t=type(value)))
+	@property
+	def UnknownFunctionHandler(self):
+		return UnknownFunctionHandler(handle=_api.api_ClassDefinition_UnknownFunctionHandler_Get(self.handle))
+	@UnknownFunctionHandler.setter
+	def UnknownFunctionHandler(self, value):
+		if isinstance(value, go.GoClass):
+			_api.api_ClassDefinition_UnknownFunctionHandler_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 api.ClassMethod
+class ClassMethod(go.GoClass):
+	""""""
+	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']
+			_api.IncRef(self.handle)
+		elif len(args) == 1 and isinstance(args[0], go.GoClass):
+			self.handle = args[0].handle
+			_api.IncRef(self.handle)
+		else:
+			self.handle = _api.api_ClassMethod_CTor()
+			_api.IncRef(self.handle)
+			if  0 < len(args):
+				self.Name = args[0]
+			if "Name" in kwargs:
+				self.Name = kwargs["Name"]
+			if  1 < len(args):
+				self.Argc = args[1]
+			if "Argc" in kwargs:
+				self.Argc = kwargs["Argc"]
+	def __del__(self):
+		_api.DecRef(self.handle)
+	def __str__(self):
+		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
+		sv = 'api.ClassMethod{'
+		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 = 'api.ClassMethod ( '
+		for v in pr:
+			if not callable(v[1]):
+				sv += v[0] + '=' + str(v[1]) + ', '
+		return sv + ')'
+	@property
+	def Name(self):
+		return _api.api_ClassMethod_Name_Get(self.handle)
+	@Name.setter
+	def Name(self, value):
+		if isinstance(value, go.GoClass):
+			_api.api_ClassMethod_Name_Set(self.handle, value.handle)
+		else:
+			_api.api_ClassMethod_Name_Set(self.handle, value)
+	@property
+	def Argc(self):
+		return _api.api_ClassMethod_Argc_Get(self.handle)
+	@Argc.setter
+	def Argc(self, value):
+		if isinstance(value, go.GoClass):
+			_api.api_ClassMethod_Argc_Set(self.handle, value.handle)
+		else:
+			_api.api_ClassMethod_Argc_Set(self.handle, value)
+
 # Python type for struct api.ClassVariable
 class ClassVariable(go.GoClass):
 	""""""
@@ -1706,6 +1549,163 @@ class ClassVariable(go.GoClass):
 		else:
 			_api.api_ClassVariable_Locked_Set(self.handle, value)
 
+# Python type for struct api.ExecutionResult
+class ExecutionResult(go.GoClass):
+	"""ExecutionResult represents the result of executing Objective-LOL code\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']
+			_api.IncRef(self.handle)
+		elif len(args) == 1 and isinstance(args[0], go.GoClass):
+			self.handle = args[0].handle
+			_api.IncRef(self.handle)
+		else:
+			self.handle = _api.api_ExecutionResult_CTor()
+			_api.IncRef(self.handle)
+			if  0 < len(args):
+				self.Value = args[0]
+			if "Value" in kwargs:
+				self.Value = kwargs["Value"]
+			if  1 < len(args):
+				self.RawValue = args[1]
+			if "RawValue" in kwargs:
+				self.RawValue = kwargs["RawValue"]
+			if  2 < len(args):
+				self.Output = args[2]
+			if "Output" in kwargs:
+				self.Output = kwargs["Output"]
+	def __del__(self):
+		_api.DecRef(self.handle)
+	def __str__(self):
+		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
+		sv = 'api.ExecutionResult{'
+		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 = 'api.ExecutionResult ( '
+		for v in pr:
+			if not callable(v[1]):
+				sv += v[0] + '=' + str(v[1]) + ', '
+		return sv + ')'
+	@property
+	def Value(self):
+		"""Return value from the execution (e.g., from MAIN function)
+		"""
+		return GoValue(handle=_api.api_ExecutionResult_Value_Get(self.handle))
+	@Value.setter
+	def Value(self, value):
+		if isinstance(value, go.GoClass):
+			_api.api_ExecutionResult_Value_Set(self.handle, value.handle)
+		else:
+			raise TypeError("supplied argument type {t} is not a go.GoClass".format(t=type(value)))
+	@property
+	def RawValue(self):
+		"""Raw Objective-LOL value (for advanced use)
+		"""
+		return go.environment_Value(handle=_api.api_ExecutionResult_RawValue_Get(self.handle))
+	@RawValue.setter
+	def RawValue(self, value):
+		if isinstance(value, go.GoClass):
+			_api.api_ExecutionResult_RawValue_Set(self.handle, value.handle)
+		else:
+			raise TypeError("supplied argument type {t} is not a go.GoClass".format(t=type(value)))
+	@property
+	def Output(self):
+		"""Output captured during execution (if configured)
+		"""
+		return _api.api_ExecutionResult_Output_Get(self.handle)
+	@Output.setter
+	def Output(self, value):
+		if isinstance(value, go.GoClass):
+			_api.api_ExecutionResult_Output_Set(self.handle, value.handle)
+		else:
+			_api.api_ExecutionResult_Output_Set(self.handle, value)
+
+# Python type for struct api.GoValue
+class GoValue(go.GoClass):
+	""""""
+	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']
+			_api.IncRef(self.handle)
+		elif len(args) == 1 and isinstance(args[0], go.GoClass):
+			self.handle = args[0].handle
+			_api.IncRef(self.handle)
+		else:
+			self.handle = _api.api_GoValue_CTor()
+			_api.IncRef(self.handle)
+	def __del__(self):
+		_api.DecRef(self.handle)
+	def __str__(self):
+		pr = [(p, getattr(self, p)) for p in dir(self) if not p.startswith('__')]
+		sv = 'api.GoValue{'
+		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 = 'api.GoValue ( '
+		for v in pr:
+			if not callable(v[1]):
+				sv += v[0] + '=' + str(v[1]) + ', '
+		return sv + ')'
+	def ID(self):
+		"""ID() str"""
+		return _api.api_GoValue_ID(self.handle)
+	def MarshalJSON(self):
+		"""MarshalJSON() []int, str"""
+		return go.Slice_byte(handle=_api.api_GoValue_MarshalJSON(self.handle))
+	def Type(self):
+		"""Type() str"""
+		return _api.api_GoValue_Type(self.handle)
+	def Int(self):
+		"""Int() long, str"""
+		return _api.api_GoValue_Int(self.handle)
+	def Float(self):
+		"""Float() float, str"""
+		return _api.api_GoValue_Float(self.handle)
+	def String(self):
+		"""String() str, str"""
+		return _api.api_GoValue_String(self.handle)
+	def Bool(self):
+		"""Bool() bool, str"""
+		return _api.api_GoValue_Bool(self.handle)
+	def Slice(self):
+		"""Slice() []object, str"""
+		return Slice_api_GoValue(handle=_api.api_GoValue_Slice(self.handle))
+	def Map(self):
+		"""Map() object, str"""
+		return Map_string_api_GoValue(handle=_api.api_GoValue_Map(self.handle))
+	def Object(self):
+		"""Object() object, str"""
+		return go.Ptr_environment_ObjectInstance(handle=_api.api_GoValue_Object(self.handle))
+
 
 # ---- Slices ---
 
@@ -1720,39 +1720,24 @@ def DefaultConfig():
 	DefaultConfig returns a default configuration
 	"""
 	return VMConfig(handle=_api.api_DefaultConfig())
-def NewClassDefinition():
-	"""NewClassDefinition() object"""
-	return ClassDefinition(handle=_api.api_NewClassDefinition())
-def WrapInt(value):
-	"""WrapInt(long value) object"""
-	return GoValue(handle=_api.api_WrapInt(value))
-def WrapObject(value):
-	"""WrapObject(object value) object"""
-	return GoValue(handle=_api.api_WrapObject(value.handle))
-def WrapBool(value):
-	"""WrapBool(bool value) object"""
-	return GoValue(handle=_api.api_WrapBool(value))
-def WrapAny(value):
-	"""WrapAny(str value) object"""
-	return GoValue(handle=_api.api_WrapAny(value))
-def ToGoValue(val):
-	"""ToGoValue(object val) object, str
-	
-	ToGoValue converts an Objective-LOL value to a Go value
-	"""
-	return GoValue(handle=_api.api_ToGoValue(val.handle))
-def WrapFloat(value):
-	"""WrapFloat(float value) object"""
-	return GoValue(handle=_api.api_WrapFloat(value))
-def WrapString(value):
-	"""WrapString(str value) object"""
-	return GoValue(handle=_api.api_WrapString(value))
 def NewVM(config):
 	"""NewVM(object config) object, str
 	
 	NewVM creates a new VM instance with the given config
 	"""
 	return VM(handle=_api.api_NewVM(config.handle))
+def NewConversionError(message, wrapped):
+	"""NewConversionError(str message, str wrapped) object
+	
+	NewConversionError creates a new type conversion error
+	"""
+	return VMError(handle=_api.api_NewConversionError(message, wrapped))
+def NewTimeoutError(duration):
+	"""NewTimeoutError(long duration) object
+	
+	NewTimeoutError creates a new timeout error
+	"""
+	return VMError(handle=_api.api_NewTimeoutError(duration))
 def NewCompileError(message, source):
 	"""NewCompileError(str message, object source) object
 	
@@ -1771,33 +1756,48 @@ def NewRuntimeError(message, source):
 	NewRuntimeError creates a new runtime error
 	"""
 	return VMError(handle=_api.api_NewRuntimeError(message, source.handle))
-def NewConversionError(message, wrapped):
-	"""NewConversionError(str message, str wrapped) object
-	
-	NewConversionError creates a new type conversion error
-	"""
-	return VMError(handle=_api.api_NewConversionError(message, wrapped))
-def NewTimeoutError(duration):
-	"""NewTimeoutError(long duration) object
+def NewClassDefinition():
+	"""NewClassDefinition() object"""
+	return ClassDefinition(handle=_api.api_NewClassDefinition())
+def WrapAny(value):
+	"""WrapAny(str value) object"""
+	return GoValue(handle=_api.api_WrapAny(value))
+def WrapFloat(value):
+	"""WrapFloat(float value) object"""
+	return GoValue(handle=_api.api_WrapFloat(value))
+def WrapString(value):
+	"""WrapString(str value) object"""
+	return GoValue(handle=_api.api_WrapString(value))
+def WrapBool(value):
+	"""WrapBool(bool value) object"""
+	return GoValue(handle=_api.api_WrapBool(value))
+def WrapInt(value):
+	"""WrapInt(long value) object"""
+	return GoValue(handle=_api.api_WrapInt(value))
+def ToGoValue(val):
+	"""ToGoValue(object val) object, str
 	
-	NewTimeoutError creates a new timeout error
+	ToGoValue converts an Objective-LOL value to a Go value
 	"""
-	return VMError(handle=_api.api_NewTimeoutError(duration))
+	return GoValue(handle=_api.api_ToGoValue(val.handle))
+def WrapObject(value):
+	"""WrapObject(object value) object"""
+	return GoValue(handle=_api.api_WrapObject(value.handle))
 
 
 # ---- Functions ---
-def FromGoValue(val):
-	"""FromGoValue(object val) object, str
-	
-	FromGoValue converts a Go value to an Objective-LOL value
-	"""
-	return go.environment_Value(handle=_api.api_FromGoValue(val.handle))
 def ConvertArguments(args):
 	"""ConvertArguments([]object args) []object, str
 	
 	ConvertArguments converts a slice of Go values to Objective-LOL values
 	"""
 	return Slice_environment_Value(handle=_api.api_ConvertArguments(args.handle))
+def FromGoValue(val):
+	"""FromGoValue(object val) object, str
+	
+	FromGoValue converts a Go value to an Objective-LOL value
+	"""
+	return go.environment_Value(handle=_api.api_FromGoValue(val.handle))
 def LookupObject(id):
 	"""LookupObject(str id) object, str"""
 	return go.Ptr_environment_ObjectInstance(handle=_api.api_LookupObject(id))