@scrypted/arlo 0.11.24 → 0.11.26

package/venv/lib/python3.10/site-packages/scrypted_arlo_go/scrypted_arlo_go.go

@@ -0,0 +1,3612 @@
+/*
+cgo stubs for package scrypted_arlo_go.
+File is generated by gopy. Do not edit.
+gopy build -no-make -dynamic-link=True -symbols=False -output /project/scrypted_arlo_go/build/lib.linux-x86_64-cpython-310/scrypted_arlo_go -vm /opt/python/cp310-cp310/bin/python scrypted_arlo_go
+*/
+
+package main
+
+/*
+
+#cgo CFLAGS: -I/opt/_internal/cpython-3.10.13/include/python3.10 -Wno-error -Wno-implicit-function-declaration -Wno-int-conversion
+#cgo LDFLAGS: -pthread -shared
+
+// #define Py_LIMITED_API // need full API for PyRun*
+#include <Python.h>
+typedef uint8_t bool;
+// static inline is trick for avoiding need for extra .c file
+// the following are used for build value -- switch on reflect.Kind
+// or the types equivalent
+static inline PyObject* gopy_build_bool(uint8_t val) {
+	return Py_BuildValue("b", val);
+}
+static inline PyObject* gopy_build_int64(int64_t val) {
+	return Py_BuildValue("k", val);
+}
+static inline PyObject* gopy_build_uint64(uint64_t val) {
+	return Py_BuildValue("K", val);
+}
+static inline PyObject* gopy_build_float64(double val) {
+	return Py_BuildValue("d", val);
+}
+static inline PyObject* gopy_build_string(const char* val) {
+	return Py_BuildValue("s", val);
+}
+static inline void gopy_decref(PyObject* obj) { // macro
+	Py_XDECREF(obj);
+}
+static inline void gopy_incref(PyObject* obj) { // macro
+	Py_XINCREF(obj);
+}
+static inline int gopy_method_check(PyObject* obj) { // macro
+	return PyMethod_Check(obj);
+}
+static inline void gopy_err_handle() {
+	if(PyErr_Occurred() != NULL) {
+		PyErr_Print();
+	}
+}
+
+*/
+import "C"
+import (
+	"errors"
+	"reflect"
+	"unsafe"
+
+	"github.com/go-python/gopy/gopyh" // handler
+
+	"net/url"
+	"scrypted_arlo_go"
+
+	sdp "github.com/pion/sdp/v3"
+	webrtc "github.com/pion/webrtc/v3"
+)
+
+// main doesn't do anything in lib / pkg mode, but is essential for exe mode
+func main() {
+
+}
+
+// initialization functions -- can be called from python after library is loaded
+// GoPyInitRunFile runs a separate python file -- call in GoPyInit if it
+// steals the main thread e.g., for GUI event loop, as in GoGi startup.
+
+//export GoPyInit
+func GoPyInit() {
+
+}
+
+// type for the handle -- int64 for speed (can switch to string)
+type GoHandle int64
+type CGoHandle C.longlong
+
+// DecRef decrements the reference count for the specified handle
+// and deletes it it goes to zero.
+//
+//export DecRef
+func DecRef(handle CGoHandle) {
+	gopyh.DecRef(gopyh.CGoHandle(handle))
+}
+
+// IncRef increments the reference count for the specified handle.
+//
+//export IncRef
+func IncRef(handle CGoHandle) {
+	gopyh.IncRef(gopyh.CGoHandle(handle))
+}
+
+// NumHandles returns the number of handles currently in use.
+//
+//export NumHandles
+func NumHandles() int {
+	return gopyh.NumHandles()
+}
+
+// boolGoToPy converts a Go bool to python-compatible C.char
+func boolGoToPy(b bool) C.char {
+	if b {
+		return 1
+	}
+	return 0
+}
+
+// boolPyToGo converts a python-compatible C.Char to Go bool
+func boolPyToGo(b C.char) bool {
+	if b != 0 {
+		return true
+	}
+	return false
+}
+
+func complex64GoToPy(c complex64) *C.PyObject {
+	return C.PyComplex_FromDoubles(C.double(real(c)), C.double(imag(c)))
+}
+
+func complex64PyToGo(o *C.PyObject) complex64 {
+	v := C.PyComplex_AsCComplex(o)
+	return complex(float32(v.real), float32(v.imag))
+}
+
+func complex128GoToPy(c complex128) *C.PyObject {
+	return C.PyComplex_FromDoubles(C.double(real(c)), C.double(imag(c)))
+}
+
+func complex128PyToGo(o *C.PyObject) complex128 {
+	v := C.PyComplex_AsCComplex(o)
+	return complex(float64(v.real), float64(v.imag))
+}
+
+// errorGoToPy converts a Go error to python-compatible C.CString
+func errorGoToPy(e error) *C.char {
+	if e != nil {
+		return C.CString(e.Error())
+	}
+	return C.CString("")
+}
+
+// --- generated code for package: scrypted_arlo_go below: ---
+
+// ---- External Types Outside of Targeted Packages ---
+
+// Converters for pointer handles for type: *sdp.Address
+func ptrFromHandle_Ptr_sdp_Address(h CGoHandle) *sdp.Address {
+	p := gopyh.VarFromHandle((gopyh.CGoHandle)(h), "*sdp.Address")
+	if p == nil {
+		return nil
+	}
+	return gopyh.Embed(p, reflect.TypeOf(sdp.Address{})).(*sdp.Address)
+}
+func handleFromPtr_Ptr_sdp_Address(p interface{}) CGoHandle {
+	return CGoHandle(gopyh.Register("*sdp.Address", p))
+}
+
+// Converters for pointer handles for type: *sdp.ConnectionInformation
+func ptrFromHandle_Ptr_sdp_ConnectionInformation(h CGoHandle) *sdp.ConnectionInformation {
+	p := gopyh.VarFromHandle((gopyh.CGoHandle)(h), "*sdp.ConnectionInformation")
+	if p == nil {
+		return nil
+	}
+	return gopyh.Embed(p, reflect.TypeOf(sdp.ConnectionInformation{})).(*sdp.ConnectionInformation)
+}
+func handleFromPtr_Ptr_sdp_ConnectionInformation(p interface{}) CGoHandle {
+	return CGoHandle(gopyh.Register("*sdp.ConnectionInformation", p))
+}
+
+// Converters for pointer handles for type: *sdp.EmailAddress
+func ptrFromHandle_Ptr_sdp_EmailAddress(h CGoHandle) *sdp.EmailAddress {
+	p := gopyh.VarFromHandle((gopyh.CGoHandle)(h), "*sdp.EmailAddress")
+	if p == nil {
+		return nil
+	}
+	return p.(*sdp.EmailAddress)
+}
+func handleFromPtr_Ptr_sdp_EmailAddress(p interface{}) CGoHandle {
+	return CGoHandle(gopyh.Register("*sdp.EmailAddress", p))
+}
+
+// Converters for pointer handles for type: *sdp.EncryptionKey
+func ptrFromHandle_Ptr_sdp_EncryptionKey(h CGoHandle) *sdp.EncryptionKey {
+	p := gopyh.VarFromHandle((gopyh.CGoHandle)(h), "*sdp.EncryptionKey")
+	if p == nil {
+		return nil
+	}
+	return p.(*sdp.EncryptionKey)
+}
+func handleFromPtr_Ptr_sdp_EncryptionKey(p interface{}) CGoHandle {
+	return CGoHandle(gopyh.Register("*sdp.EncryptionKey", p))
+}
+
+// Converters for pointer handles for type: *sdp.Information
+func ptrFromHandle_Ptr_sdp_Information(h CGoHandle) *sdp.Information {
+	p := gopyh.VarFromHandle((gopyh.CGoHandle)(h), "*sdp.Information")
+	if p == nil {
+		return nil
+	}
+	return p.(*sdp.Information)
+}
+func handleFromPtr_Ptr_sdp_Information(p interface{}) CGoHandle {
+	return CGoHandle(gopyh.Register("*sdp.Information", p))
+}
+
+// Converters for pointer handles for type: *sdp.MediaDescription
+func ptrFromHandle_Ptr_sdp_MediaDescription(h CGoHandle) *sdp.MediaDescription {
+	p := gopyh.VarFromHandle((gopyh.CGoHandle)(h), "*sdp.MediaDescription")
+	if p == nil {
+		return nil
+	}
+	return gopyh.Embed(p, reflect.TypeOf(sdp.MediaDescription{})).(*sdp.MediaDescription)
+}
+func handleFromPtr_Ptr_sdp_MediaDescription(p interface{}) CGoHandle {
+	return CGoHandle(gopyh.Register("*sdp.MediaDescription", p))
+}
+
+// Converters for pointer handles for type: *sdp.PhoneNumber
+func ptrFromHandle_Ptr_sdp_PhoneNumber(h CGoHandle) *sdp.PhoneNumber {
+	p := gopyh.VarFromHandle((gopyh.CGoHandle)(h), "*sdp.PhoneNumber")
+	if p == nil {
+		return nil
+	}
+	return p.(*sdp.PhoneNumber)
+}
+func handleFromPtr_Ptr_sdp_PhoneNumber(p interface{}) CGoHandle {
+	return CGoHandle(gopyh.Register("*sdp.PhoneNumber", p))
+}
+
+// Converters for pointer handles for type: *sdp.SessionDescription
+func ptrFromHandle_Ptr_sdp_SessionDescription(h CGoHandle) *sdp.SessionDescription {
+	p := gopyh.VarFromHandle((gopyh.CGoHandle)(h), "*sdp.SessionDescription")
+	if p == nil {
+		return nil
+	}
+	return gopyh.Embed(p, reflect.TypeOf(sdp.SessionDescription{})).(*sdp.SessionDescription)
+}
+func handleFromPtr_Ptr_sdp_SessionDescription(p interface{}) CGoHandle {
+	return CGoHandle(gopyh.Register("*sdp.SessionDescription", p))
+}
+
+// Converters for pointer handles for type: *webrtc.ICECandidate
+func ptrFromHandle_Ptr_webrtc_ICECandidate(h CGoHandle) *webrtc.ICECandidate {
+	p := gopyh.VarFromHandle((gopyh.CGoHandle)(h), "*webrtc.ICECandidate")
+	if p == nil {
+		return nil
+	}
+	return gopyh.Embed(p, reflect.TypeOf(webrtc.ICECandidate{})).(*webrtc.ICECandidate)
+}
+func handleFromPtr_Ptr_webrtc_ICECandidate(p interface{}) CGoHandle {
+	return CGoHandle(gopyh.Register("*webrtc.ICECandidate", p))
+}
+
+// Converters for pointer handles for type: *webrtc.ICECandidateInit
+func ptrFromHandle_Ptr_webrtc_ICECandidateInit(h CGoHandle) *webrtc.ICECandidateInit {
+	p := gopyh.VarFromHandle((gopyh.CGoHandle)(h), "*webrtc.ICECandidateInit")
+	if p == nil {
+		return nil
+	}
+	return gopyh.Embed(p, reflect.TypeOf(webrtc.ICECandidateInit{})).(*webrtc.ICECandidateInit)
+}
+func handleFromPtr_Ptr_webrtc_ICECandidateInit(p interface{}) CGoHandle {
+	return CGoHandle(gopyh.Register("*webrtc.ICECandidateInit", p))
+}
+
+// Converters for pointer handles for type: *webrtc.ICEServer
+func ptrFromHandle_Ptr_webrtc_ICEServer(h CGoHandle) *webrtc.ICEServer {
+	p := gopyh.VarFromHandle((gopyh.CGoHandle)(h), "*webrtc.ICEServer")
+	if p == nil {
+		return nil
+	}
+	return gopyh.Embed(p, reflect.TypeOf(webrtc.ICEServer{})).(*webrtc.ICEServer)
+}
+func handleFromPtr_Ptr_webrtc_ICEServer(p interface{}) CGoHandle {
+	return CGoHandle(gopyh.Register("*webrtc.ICEServer", p))
+}
+
+// Converters for pointer handles for type: *webrtc.SessionDescription
+func ptrFromHandle_Ptr_webrtc_SessionDescription(h CGoHandle) *webrtc.SessionDescription {
+	p := gopyh.VarFromHandle((gopyh.CGoHandle)(h), "*webrtc.SessionDescription")
+	if p == nil {
+		return nil
+	}
+	return gopyh.Embed(p, reflect.TypeOf(webrtc.SessionDescription{})).(*webrtc.SessionDescription)
+}
+func handleFromPtr_Ptr_webrtc_SessionDescription(p interface{}) CGoHandle {
+	return CGoHandle(gopyh.Register("*webrtc.SessionDescription", p))
+}
+
+// Converters for pointer handles for type: *url.URL
+func ptrFromHandle_Ptr_url_URL(h CGoHandle) *url.URL {
+	p := gopyh.VarFromHandle((gopyh.CGoHandle)(h), "*url.URL")
+	if p == nil {
+		return nil
+	}
+	return gopyh.Embed(p, reflect.TypeOf(url.URL{})).(*url.URL)
+}
+func handleFromPtr_Ptr_url_URL(p interface{}) CGoHandle {
+	return CGoHandle(gopyh.Register("*url.URL", p))
+}
+
+// Converters for pointer handles for type: *url.Userinfo
+func ptrFromHandle_Ptr_url_Userinfo(h CGoHandle) *url.Userinfo {
+	p := gopyh.VarFromHandle((gopyh.CGoHandle)(h), "*url.Userinfo")
+	if p == nil {
+		return nil
+	}
+	return gopyh.Embed(p, reflect.TypeOf(url.Userinfo{})).(*url.Userinfo)
+}
+func handleFromPtr_Ptr_url_Userinfo(p interface{}) CGoHandle {
+	return CGoHandle(gopyh.Register("*url.Userinfo", p))
+}
+
+// Converters for non-pointer handles for type: sdp.Address
+func ptrFromHandle_sdp_Address(h CGoHandle) *sdp.Address {
+	p := gopyh.VarFromHandle((gopyh.CGoHandle)(h), "sdp.Address")
+	if p == nil {
+		return nil
+	}
+	return gopyh.Embed(p, reflect.TypeOf(sdp.Address{})).(*sdp.Address)
+}
+func handleFromPtr_sdp_Address(p interface{}) CGoHandle {
+	return CGoHandle(gopyh.Register("sdp.Address", p))
+}
+
+// Converters for non-pointer handles for type: sdp.Attribute
+func ptrFromHandle_sdp_Attribute(h CGoHandle) *sdp.Attribute {
+	p := gopyh.VarFromHandle((gopyh.CGoHandle)(h), "sdp.Attribute")
+	if p == nil {
+		return nil
+	}
+	return gopyh.Embed(p, reflect.TypeOf(sdp.Attribute{})).(*sdp.Attribute)
+}
+func handleFromPtr_sdp_Attribute(p interface{}) CGoHandle {
+	return CGoHandle(gopyh.Register("sdp.Attribute", p))
+}
+
+// Converters for non-pointer handles for type: sdp.Bandwidth
+func ptrFromHandle_sdp_Bandwidth(h CGoHandle) *sdp.Bandwidth {
+	p := gopyh.VarFromHandle((gopyh.CGoHandle)(h), "sdp.Bandwidth")
+	if p == nil {
+		return nil
+	}
+	return gopyh.Embed(p, reflect.TypeOf(sdp.Bandwidth{})).(*sdp.Bandwidth)
+}
+func handleFromPtr_sdp_Bandwidth(p interface{}) CGoHandle {
+	return CGoHandle(gopyh.Register("sdp.Bandwidth", p))
+}
+
+// Converters for non-pointer handles for type: sdp.Codec
+func ptrFromHandle_sdp_Codec(h CGoHandle) *sdp.Codec {
+	p := gopyh.VarFromHandle((gopyh.CGoHandle)(h), "sdp.Codec")
+	if p == nil {
+		return nil
+	}
+	return gopyh.Embed(p, reflect.TypeOf(sdp.Codec{})).(*sdp.Codec)
+}
+func handleFromPtr_sdp_Codec(p interface{}) CGoHandle {
+	return CGoHandle(gopyh.Register("sdp.Codec", p))
+}
+
+// Converters for non-pointer handles for type: sdp.ConnectionInformation
+func ptrFromHandle_sdp_ConnectionInformation(h CGoHandle) *sdp.ConnectionInformation {
+	p := gopyh.VarFromHandle((gopyh.CGoHandle)(h), "sdp.ConnectionInformation")
+	if p == nil {
+		return nil
+	}
+	return gopyh.Embed(p, reflect.TypeOf(sdp.ConnectionInformation{})).(*sdp.ConnectionInformation)
+}
+func handleFromPtr_sdp_ConnectionInformation(p interface{}) CGoHandle {
+	return CGoHandle(gopyh.Register("sdp.ConnectionInformation", p))
+}
+
+// Converters for non-pointer handles for type: sdp.ExtMap
+func ptrFromHandle_sdp_ExtMap(h CGoHandle) *sdp.ExtMap {
+	p := gopyh.VarFromHandle((gopyh.CGoHandle)(h), "sdp.ExtMap")
+	if p == nil {
+		return nil
+	}
+	return gopyh.Embed(p, reflect.TypeOf(sdp.ExtMap{})).(*sdp.ExtMap)
+}
+func handleFromPtr_sdp_ExtMap(p interface{}) CGoHandle {
+	return CGoHandle(gopyh.Register("sdp.ExtMap", p))
+}
+
+// Converters for non-pointer handles for type: sdp.MediaDescription
+func ptrFromHandle_sdp_MediaDescription(h CGoHandle) *sdp.MediaDescription {
+	p := gopyh.VarFromHandle((gopyh.CGoHandle)(h), "sdp.MediaDescription")
+	if p == nil {
+		return nil
+	}
+	return gopyh.Embed(p, reflect.TypeOf(sdp.MediaDescription{})).(*sdp.MediaDescription)
+}
+func handleFromPtr_sdp_MediaDescription(p interface{}) CGoHandle {
+	return CGoHandle(gopyh.Register("sdp.MediaDescription", p))
+}
+
+// Converters for non-pointer handles for type: sdp.MediaName
+func ptrFromHandle_sdp_MediaName(h CGoHandle) *sdp.MediaName {
+	p := gopyh.VarFromHandle((gopyh.CGoHandle)(h), "sdp.MediaName")
+	if p == nil {
+		return nil
+	}
+	return gopyh.Embed(p, reflect.TypeOf(sdp.MediaName{})).(*sdp.MediaName)
+}
+func handleFromPtr_sdp_MediaName(p interface{}) CGoHandle {
+	return CGoHandle(gopyh.Register("sdp.MediaName", p))
+}
+
+// Converters for non-pointer handles for type: sdp.Origin
+func ptrFromHandle_sdp_Origin(h CGoHandle) *sdp.Origin {
+	p := gopyh.VarFromHandle((gopyh.CGoHandle)(h), "sdp.Origin")
+	if p == nil {
+		return nil
+	}
+	return gopyh.Embed(p, reflect.TypeOf(sdp.Origin{})).(*sdp.Origin)
+}
+func handleFromPtr_sdp_Origin(p interface{}) CGoHandle {
+	return CGoHandle(gopyh.Register("sdp.Origin", p))
+}
+
+// Converters for non-pointer handles for type: sdp.RangedPort
+func ptrFromHandle_sdp_RangedPort(h CGoHandle) *sdp.RangedPort {
+	p := gopyh.VarFromHandle((gopyh.CGoHandle)(h), "sdp.RangedPort")
+	if p == nil {
+		return nil
+	}
+	return gopyh.Embed(p, reflect.TypeOf(sdp.RangedPort{})).(*sdp.RangedPort)
+}
+func handleFromPtr_sdp_RangedPort(p interface{}) CGoHandle {
+	return CGoHandle(gopyh.Register("sdp.RangedPort", p))
+}
+
+// Converters for non-pointer handles for type: sdp.RepeatTime
+func ptrFromHandle_sdp_RepeatTime(h CGoHandle) *sdp.RepeatTime {
+	p := gopyh.VarFromHandle((gopyh.CGoHandle)(h), "sdp.RepeatTime")
+	if p == nil {
+		return nil
+	}
+	return gopyh.Embed(p, reflect.TypeOf(sdp.RepeatTime{})).(*sdp.RepeatTime)
+}
+func handleFromPtr_sdp_RepeatTime(p interface{}) CGoHandle {
+	return CGoHandle(gopyh.Register("sdp.RepeatTime", p))
+}
+
+// Converters for non-pointer handles for type: sdp.SessionDescription
+func ptrFromHandle_sdp_SessionDescription(h CGoHandle) *sdp.SessionDescription {
+	p := gopyh.VarFromHandle((gopyh.CGoHandle)(h), "sdp.SessionDescription")
+	if p == nil {
+		return nil
+	}
+	return gopyh.Embed(p, reflect.TypeOf(sdp.SessionDescription{})).(*sdp.SessionDescription)
+}
+func handleFromPtr_sdp_SessionDescription(p interface{}) CGoHandle {
+	return CGoHandle(gopyh.Register("sdp.SessionDescription", p))
+}
+
+// Converters for non-pointer handles for type: sdp.TimeDescription
+func ptrFromHandle_sdp_TimeDescription(h CGoHandle) *sdp.TimeDescription {
+	p := gopyh.VarFromHandle((gopyh.CGoHandle)(h), "sdp.TimeDescription")
+	if p == nil {
+		return nil
+	}
+	return gopyh.Embed(p, reflect.TypeOf(sdp.TimeDescription{})).(*sdp.TimeDescription)
+}
+func handleFromPtr_sdp_TimeDescription(p interface{}) CGoHandle {
+	return CGoHandle(gopyh.Register("sdp.TimeDescription", p))
+}
+
+// Converters for non-pointer handles for type: sdp.TimeZone
+func ptrFromHandle_sdp_TimeZone(h CGoHandle) *sdp.TimeZone {
+	p := gopyh.VarFromHandle((gopyh.CGoHandle)(h), "sdp.TimeZone")
+	if p == nil {
+		return nil
+	}
+	return gopyh.Embed(p, reflect.TypeOf(sdp.TimeZone{})).(*sdp.TimeZone)
+}
+func handleFromPtr_sdp_TimeZone(p interface{}) CGoHandle {
+	return CGoHandle(gopyh.Register("sdp.TimeZone", p))
+}
+
+// Converters for non-pointer handles for type: sdp.Timing
+func ptrFromHandle_sdp_Timing(h CGoHandle) *sdp.Timing {
+	p := gopyh.VarFromHandle((gopyh.CGoHandle)(h), "sdp.Timing")
+	if p == nil {
+		return nil
+	}
+	return gopyh.Embed(p, reflect.TypeOf(sdp.Timing{})).(*sdp.Timing)
+}
+func handleFromPtr_sdp_Timing(p interface{}) CGoHandle {
+	return CGoHandle(gopyh.Register("sdp.Timing", p))
+}
+
+// Converters for non-pointer handles for type: webrtc.ICECandidate
+func ptrFromHandle_webrtc_ICECandidate(h CGoHandle) *webrtc.ICECandidate {
+	p := gopyh.VarFromHandle((gopyh.CGoHandle)(h), "webrtc.ICECandidate")
+	if p == nil {
+		return nil
+	}
+	return gopyh.Embed(p, reflect.TypeOf(webrtc.ICECandidate{})).(*webrtc.ICECandidate)
+}
+func handleFromPtr_webrtc_ICECandidate(p interface{}) CGoHandle {
+	return CGoHandle(gopyh.Register("webrtc.ICECandidate", p))
+}
+
+// Converters for non-pointer handles for type: webrtc.ICECandidateInit
+func ptrFromHandle_webrtc_ICECandidateInit(h CGoHandle) *webrtc.ICECandidateInit {
+	p := gopyh.VarFromHandle((gopyh.CGoHandle)(h), "webrtc.ICECandidateInit")
+	if p == nil {
+		return nil
+	}
+	return gopyh.Embed(p, reflect.TypeOf(webrtc.ICECandidateInit{})).(*webrtc.ICECandidateInit)
+}
+func handleFromPtr_webrtc_ICECandidateInit(p interface{}) CGoHandle {
+	return CGoHandle(gopyh.Register("webrtc.ICECandidateInit", p))
+}
+
+// Converters for non-pointer handles for type: webrtc.ICEServer
+func ptrFromHandle_webrtc_ICEServer(h CGoHandle) *webrtc.ICEServer {
+	p := gopyh.VarFromHandle((gopyh.CGoHandle)(h), "webrtc.ICEServer")
+	if p == nil {
+		return nil
+	}
+	return gopyh.Embed(p, reflect.TypeOf(webrtc.ICEServer{})).(*webrtc.ICEServer)
+}
+func handleFromPtr_webrtc_ICEServer(p interface{}) CGoHandle {
+	return CGoHandle(gopyh.Register("webrtc.ICEServer", p))
+}
+
+// Converters for non-pointer handles for type: webrtc.SessionDescription
+func ptrFromHandle_webrtc_SessionDescription(h CGoHandle) *webrtc.SessionDescription {
+	p := gopyh.VarFromHandle((gopyh.CGoHandle)(h), "webrtc.SessionDescription")
+	if p == nil {
+		return nil
+	}
+	return gopyh.Embed(p, reflect.TypeOf(webrtc.SessionDescription{})).(*webrtc.SessionDescription)
+}
+func handleFromPtr_webrtc_SessionDescription(p interface{}) CGoHandle {
+	return CGoHandle(gopyh.Register("webrtc.SessionDescription", p))
+}
+
+// Converters for non-pointer handles for type: url.URL
+func ptrFromHandle_url_URL(h CGoHandle) *url.URL {
+	p := gopyh.VarFromHandle((gopyh.CGoHandle)(h), "url.URL")
+	if p == nil {
+		return nil
+	}
+	return gopyh.Embed(p, reflect.TypeOf(url.URL{})).(*url.URL)
+}
+func handleFromPtr_url_URL(p interface{}) CGoHandle {
+	return CGoHandle(gopyh.Register("url.URL", p))
+}
+
+// Converters for non-pointer handles for type: url.Userinfo
+func ptrFromHandle_url_Userinfo(h CGoHandle) *url.Userinfo {
+	p := gopyh.VarFromHandle((gopyh.CGoHandle)(h), "url.Userinfo")
+	if p == nil {
+		return nil
+	}
+	return gopyh.Embed(p, reflect.TypeOf(url.Userinfo{})).(*url.Userinfo)
+}
+func handleFromPtr_url_Userinfo(p interface{}) CGoHandle {
+	return CGoHandle(gopyh.Register("url.Userinfo", p))
+}
+
+// Converters for implicit pointer handles for type: url.Values
+func ptrFromHandle_url_Values(h CGoHandle) *url.Values {
+	p := gopyh.VarFromHandle((gopyh.CGoHandle)(h), "url.Values")
+	if p == nil {
+		return nil
+	}
+	return p.(*url.Values)
+}
+func deptrFromHandle_url_Values(h CGoHandle) url.Values {
+	p := ptrFromHandle_url_Values(h)
+	if p == nil {
+		return nil
+	}
+	return *p
+}
+func handleFromPtr_url_Values(p interface{}) CGoHandle {
+	return CGoHandle(gopyh.Register("url.Values", p))
+}
+
+// --- wrapping map: url.Values ---
+//
+//export url_Values_CTor
+func url_Values_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_url_Values(&url.Values{}))
+}
+
+//export url_Values_len
+func url_Values_len(handle CGoHandle) int {
+	return len(deptrFromHandle_url_Values(handle))
+}
+
+//export url_Values_elem
+func url_Values_elem(handle CGoHandle, _ky *C.char) CGoHandle {
+	s := deptrFromHandle_url_Values(handle)
+	v, ok := s[C.GoString(_ky)]
+	if !ok {
+		C.PyErr_SetString(C.PyExc_KeyError, C.CString("key not in map"))
+	}
+	return handleFromPtr_Slice_string(v)
+}
+
+//export url_Values_contains
+func url_Values_contains(handle CGoHandle, _ky *C.char) C.char {
+	s := deptrFromHandle_url_Values(handle)
+	_, ok := s[C.GoString(_ky)]
+	return boolGoToPy(ok)
+}
+
+//export url_Values_set
+func url_Values_set(handle CGoHandle, _ky *C.char, _vl CGoHandle) {
+	s := deptrFromHandle_url_Values(handle)
+	s[C.GoString(_ky)] = deptrFromHandle_Slice_string(_vl)
+}
+
+//export url_Values_delete
+func url_Values_delete(handle CGoHandle, _ky *C.char) {
+	s := deptrFromHandle_url_Values(handle)
+	delete(s, C.GoString(_ky))
+}
+
+//export url_Values_keys
+func url_Values_keys(handle CGoHandle) CGoHandle {
+	s := deptrFromHandle_url_Values(handle)
+	kys := make([]string, 0, len(s))
+	for k := range s {
+		kys = append(kys, k)
+	}
+	return handleFromPtr_Slice_string(&kys)
+}
+
+// ---- Package: go ---
+
+// ---- Types ---
+
+// Converters for implicit pointer handles for type: []bool
+func ptrFromHandle_Slice_bool(h CGoHandle) *[]bool {
+	p := gopyh.VarFromHandle((gopyh.CGoHandle)(h), "[]bool")
+	if p == nil {
+		return nil
+	}
+	return p.(*[]bool)
+}
+func deptrFromHandle_Slice_bool(h CGoHandle) []bool {
+	p := ptrFromHandle_Slice_bool(h)
+	if p == nil {
+		return nil
+	}
+	return *p
+}
+func handleFromPtr_Slice_bool(p interface{}) CGoHandle {
+	return CGoHandle(gopyh.Register("[]bool", p))
+}
+
+// --- wrapping slice: []bool ---
+//
+//export Slice_bool_CTor
+func Slice_bool_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_Slice_bool(&[]bool{}))
+}
+
+//export Slice_bool_len
+func Slice_bool_len(handle CGoHandle) int {
+	return len(deptrFromHandle_Slice_bool(handle))
+}
+
+//export Slice_bool_elem
+func Slice_bool_elem(handle CGoHandle, _idx int) C.char {
+	s := deptrFromHandle_Slice_bool(handle)
+	return boolGoToPy(s[_idx])
+}
+
+//export Slice_bool_subslice
+func Slice_bool_subslice(handle CGoHandle, _st, _ed int) CGoHandle {
+	s := deptrFromHandle_Slice_bool(handle)
+	ss := s[_st:_ed]
+	return CGoHandle(handleFromPtr_Slice_bool(&ss))
+}
+
+//export Slice_bool_set
+func Slice_bool_set(handle CGoHandle, _idx int, _vl C.char) {
+	s := deptrFromHandle_Slice_bool(handle)
+	s[_idx] = boolPyToGo(_vl)
+}
+
+//export Slice_bool_append
+func Slice_bool_append(handle CGoHandle, _vl C.char) {
+	s := ptrFromHandle_Slice_bool(handle)
+	*s = append(*s, boolPyToGo(_vl))
+}
+
+// Converters for implicit pointer handles for type: []byte
+func ptrFromHandle_Slice_byte(h CGoHandle) *[]byte {
+	p := gopyh.VarFromHandle((gopyh.CGoHandle)(h), "[]byte")
+	if p == nil {
+		return nil
+	}
+	return p.(*[]byte)
+}
+func deptrFromHandle_Slice_byte(h CGoHandle) []byte {
+	p := ptrFromHandle_Slice_byte(h)
+	if p == nil {
+		return nil
+	}
+	return *p
+}
+func handleFromPtr_Slice_byte(p interface{}) CGoHandle {
+	return CGoHandle(gopyh.Register("[]byte", p))
+}
+
+// --- wrapping slice: []byte ---
+//
+//export Slice_byte_CTor
+func Slice_byte_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_Slice_byte(&[]byte{}))
+}
+
+//export Slice_byte_len
+func Slice_byte_len(handle CGoHandle) int {
+	return len(deptrFromHandle_Slice_byte(handle))
+}
+
+//export Slice_byte_elem
+func Slice_byte_elem(handle CGoHandle, _idx int) C.char {
+	s := deptrFromHandle_Slice_byte(handle)
+	return C.char(s[_idx])
+}
+
+//export Slice_byte_subslice
+func Slice_byte_subslice(handle CGoHandle, _st, _ed int) CGoHandle {
+	s := deptrFromHandle_Slice_byte(handle)
+	ss := s[_st:_ed]
+	return CGoHandle(handleFromPtr_Slice_byte(&ss))
+}
+
+//export Slice_byte_set
+func Slice_byte_set(handle CGoHandle, _idx int, _vl C.char) {
+	s := deptrFromHandle_Slice_byte(handle)
+	s[_idx] = byte(_vl)
+}
+
+//export Slice_byte_append
+func Slice_byte_append(handle CGoHandle, _vl C.char) {
+	s := ptrFromHandle_Slice_byte(handle)
+	*s = append(*s, byte(_vl))
+}
+
+// Converters for implicit pointer handles for type: []error
+func ptrFromHandle_Slice_error(h CGoHandle) *[]error {
+	p := gopyh.VarFromHandle((gopyh.CGoHandle)(h), "[]error")
+	if p == nil {
+		return nil
+	}
+	return p.(*[]error)
+}
+func deptrFromHandle_Slice_error(h CGoHandle) []error {
+	p := ptrFromHandle_Slice_error(h)
+	if p == nil {
+		return nil
+	}
+	return *p
+}
+func handleFromPtr_Slice_error(p interface{}) CGoHandle {
+	return CGoHandle(gopyh.Register("[]error", p))
+}
+
+// --- wrapping slice: []error ---
+//
+//export Slice_error_CTor
+func Slice_error_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_Slice_error(&[]error{}))
+}
+
+//export Slice_error_len
+func Slice_error_len(handle CGoHandle) int {
+	return len(deptrFromHandle_Slice_error(handle))
+}
+
+//export Slice_error_elem
+func Slice_error_elem(handle CGoHandle, _idx int) *C.char {
+	s := deptrFromHandle_Slice_error(handle)
+	return errorGoToPy(s[_idx])
+}
+
+//export Slice_error_subslice
+func Slice_error_subslice(handle CGoHandle, _st, _ed int) CGoHandle {
+	s := deptrFromHandle_Slice_error(handle)
+	ss := s[_st:_ed]
+	return CGoHandle(handleFromPtr_Slice_error(&ss))
+}
+
+//export Slice_error_set
+func Slice_error_set(handle CGoHandle, _idx int, _vl *C.char) {
+	s := deptrFromHandle_Slice_error(handle)
+	s[_idx] = errors.New(C.GoString(_vl))
+}
+
+//export Slice_error_append
+func Slice_error_append(handle CGoHandle, _vl *C.char) {
+	s := ptrFromHandle_Slice_error(handle)
+	*s = append(*s, errors.New(C.GoString(_vl)))
+}
+
+// Converters for implicit pointer handles for type: []float32
+func ptrFromHandle_Slice_float32(h CGoHandle) *[]float32 {
+	p := gopyh.VarFromHandle((gopyh.CGoHandle)(h), "[]float32")
+	if p == nil {
+		return nil
+	}
+	return p.(*[]float32)
+}
+func deptrFromHandle_Slice_float32(h CGoHandle) []float32 {
+	p := ptrFromHandle_Slice_float32(h)
+	if p == nil {
+		return nil
+	}
+	return *p
+}
+func handleFromPtr_Slice_float32(p interface{}) CGoHandle {
+	return CGoHandle(gopyh.Register("[]float32", p))
+}
+
+// --- wrapping slice: []float32 ---
+//
+//export Slice_float32_CTor
+func Slice_float32_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_Slice_float32(&[]float32{}))
+}
+
+//export Slice_float32_len
+func Slice_float32_len(handle CGoHandle) int {
+	return len(deptrFromHandle_Slice_float32(handle))
+}
+
+//export Slice_float32_elem
+func Slice_float32_elem(handle CGoHandle, _idx int) C.float {
+	s := deptrFromHandle_Slice_float32(handle)
+	return C.float(s[_idx])
+}
+
+//export Slice_float32_subslice
+func Slice_float32_subslice(handle CGoHandle, _st, _ed int) CGoHandle {
+	s := deptrFromHandle_Slice_float32(handle)
+	ss := s[_st:_ed]
+	return CGoHandle(handleFromPtr_Slice_float32(&ss))
+}
+
+//export Slice_float32_set
+func Slice_float32_set(handle CGoHandle, _idx int, _vl C.float) {
+	s := deptrFromHandle_Slice_float32(handle)
+	s[_idx] = float32(_vl)
+}
+
+//export Slice_float32_append
+func Slice_float32_append(handle CGoHandle, _vl C.float) {
+	s := ptrFromHandle_Slice_float32(handle)
+	*s = append(*s, float32(_vl))
+}
+
+// Converters for implicit pointer handles for type: []float64
+func ptrFromHandle_Slice_float64(h CGoHandle) *[]float64 {
+	p := gopyh.VarFromHandle((gopyh.CGoHandle)(h), "[]float64")
+	if p == nil {
+		return nil
+	}
+	return p.(*[]float64)
+}
+func deptrFromHandle_Slice_float64(h CGoHandle) []float64 {
+	p := ptrFromHandle_Slice_float64(h)
+	if p == nil {
+		return nil
+	}
+	return *p
+}
+func handleFromPtr_Slice_float64(p interface{}) CGoHandle {
+	return CGoHandle(gopyh.Register("[]float64", p))
+}
+
+// --- wrapping slice: []float64 ---
+//
+//export Slice_float64_CTor
+func Slice_float64_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_Slice_float64(&[]float64{}))
+}
+
+//export Slice_float64_len
+func Slice_float64_len(handle CGoHandle) int {
+	return len(deptrFromHandle_Slice_float64(handle))
+}
+
+//export Slice_float64_elem
+func Slice_float64_elem(handle CGoHandle, _idx int) C.double {
+	s := deptrFromHandle_Slice_float64(handle)
+	return C.double(s[_idx])
+}
+
+//export Slice_float64_subslice
+func Slice_float64_subslice(handle CGoHandle, _st, _ed int) CGoHandle {
+	s := deptrFromHandle_Slice_float64(handle)
+	ss := s[_st:_ed]
+	return CGoHandle(handleFromPtr_Slice_float64(&ss))
+}
+
+//export Slice_float64_set
+func Slice_float64_set(handle CGoHandle, _idx int, _vl C.double) {
+	s := deptrFromHandle_Slice_float64(handle)
+	s[_idx] = float64(_vl)
+}
+
+//export Slice_float64_append
+func Slice_float64_append(handle CGoHandle, _vl C.double) {
+	s := ptrFromHandle_Slice_float64(handle)
+	*s = append(*s, float64(_vl))
+}
+
+// Converters for implicit pointer handles for type: []int
+func ptrFromHandle_Slice_int(h CGoHandle) *[]int {
+	p := gopyh.VarFromHandle((gopyh.CGoHandle)(h), "[]int")
+	if p == nil {
+		return nil
+	}
+	return p.(*[]int)
+}
+func deptrFromHandle_Slice_int(h CGoHandle) []int {
+	p := ptrFromHandle_Slice_int(h)
+	if p == nil {
+		return nil
+	}
+	return *p
+}
+func handleFromPtr_Slice_int(p interface{}) CGoHandle {
+	return CGoHandle(gopyh.Register("[]int", p))
+}
+
+// --- wrapping slice: []int ---
+//
+//export Slice_int_CTor
+func Slice_int_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_Slice_int(&[]int{}))
+}
+
+//export Slice_int_len
+func Slice_int_len(handle CGoHandle) int {
+	return len(deptrFromHandle_Slice_int(handle))
+}
+
+//export Slice_int_elem
+func Slice_int_elem(handle CGoHandle, _idx int) C.longlong {
+	s := deptrFromHandle_Slice_int(handle)
+	return C.longlong(s[_idx])
+}
+
+//export Slice_int_subslice
+func Slice_int_subslice(handle CGoHandle, _st, _ed int) CGoHandle {
+	s := deptrFromHandle_Slice_int(handle)
+	ss := s[_st:_ed]
+	return CGoHandle(handleFromPtr_Slice_int(&ss))
+}
+
+//export Slice_int_set
+func Slice_int_set(handle CGoHandle, _idx int, _vl C.longlong) {
+	s := deptrFromHandle_Slice_int(handle)
+	s[_idx] = int(_vl)
+}
+
+//export Slice_int_append
+func Slice_int_append(handle CGoHandle, _vl C.longlong) {
+	s := ptrFromHandle_Slice_int(handle)
+	*s = append(*s, int(_vl))
+}
+
+// Converters for implicit pointer handles for type: []int16
+func ptrFromHandle_Slice_int16(h CGoHandle) *[]int16 {
+	p := gopyh.VarFromHandle((gopyh.CGoHandle)(h), "[]int16")
+	if p == nil {
+		return nil
+	}
+	return p.(*[]int16)
+}
+func deptrFromHandle_Slice_int16(h CGoHandle) []int16 {
+	p := ptrFromHandle_Slice_int16(h)
+	if p == nil {
+		return nil
+	}
+	return *p
+}
+func handleFromPtr_Slice_int16(p interface{}) CGoHandle {
+	return CGoHandle(gopyh.Register("[]int16", p))
+}
+
+// --- wrapping slice: []int16 ---
+//
+//export Slice_int16_CTor
+func Slice_int16_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_Slice_int16(&[]int16{}))
+}
+
+//export Slice_int16_len
+func Slice_int16_len(handle CGoHandle) int {
+	return len(deptrFromHandle_Slice_int16(handle))
+}
+
+//export Slice_int16_elem
+func Slice_int16_elem(handle CGoHandle, _idx int) C.short {
+	s := deptrFromHandle_Slice_int16(handle)
+	return C.short(s[_idx])
+}
+
+//export Slice_int16_subslice
+func Slice_int16_subslice(handle CGoHandle, _st, _ed int) CGoHandle {
+	s := deptrFromHandle_Slice_int16(handle)
+	ss := s[_st:_ed]
+	return CGoHandle(handleFromPtr_Slice_int16(&ss))
+}
+
+//export Slice_int16_set
+func Slice_int16_set(handle CGoHandle, _idx int, _vl C.short) {
+	s := deptrFromHandle_Slice_int16(handle)
+	s[_idx] = int16(_vl)
+}
+
+//export Slice_int16_append
+func Slice_int16_append(handle CGoHandle, _vl C.short) {
+	s := ptrFromHandle_Slice_int16(handle)
+	*s = append(*s, int16(_vl))
+}
+
+// Converters for implicit pointer handles for type: []int32
+func ptrFromHandle_Slice_int32(h CGoHandle) *[]int32 {
+	p := gopyh.VarFromHandle((gopyh.CGoHandle)(h), "[]int32")
+	if p == nil {
+		return nil
+	}
+	return p.(*[]int32)
+}
+func deptrFromHandle_Slice_int32(h CGoHandle) []int32 {
+	p := ptrFromHandle_Slice_int32(h)
+	if p == nil {
+		return nil
+	}
+	return *p
+}
+func handleFromPtr_Slice_int32(p interface{}) CGoHandle {
+	return CGoHandle(gopyh.Register("[]int32", p))
+}
+
+// --- wrapping slice: []int32 ---
+//
+//export Slice_int32_CTor
+func Slice_int32_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_Slice_int32(&[]int32{}))
+}
+
+//export Slice_int32_len
+func Slice_int32_len(handle CGoHandle) int {
+	return len(deptrFromHandle_Slice_int32(handle))
+}
+
+//export Slice_int32_elem
+func Slice_int32_elem(handle CGoHandle, _idx int) C.long {
+	s := deptrFromHandle_Slice_int32(handle)
+	return C.long(s[_idx])
+}
+
+//export Slice_int32_subslice
+func Slice_int32_subslice(handle CGoHandle, _st, _ed int) CGoHandle {
+	s := deptrFromHandle_Slice_int32(handle)
+	ss := s[_st:_ed]
+	return CGoHandle(handleFromPtr_Slice_int32(&ss))
+}
+
+//export Slice_int32_set
+func Slice_int32_set(handle CGoHandle, _idx int, _vl C.long) {
+	s := deptrFromHandle_Slice_int32(handle)
+	s[_idx] = int32(_vl)
+}
+
+//export Slice_int32_append
+func Slice_int32_append(handle CGoHandle, _vl C.long) {
+	s := ptrFromHandle_Slice_int32(handle)
+	*s = append(*s, int32(_vl))
+}
+
+// Converters for implicit pointer handles for type: []int64
+func ptrFromHandle_Slice_int64(h CGoHandle) *[]int64 {
+	p := gopyh.VarFromHandle((gopyh.CGoHandle)(h), "[]int64")
+	if p == nil {
+		return nil
+	}
+	return p.(*[]int64)
+}
+func deptrFromHandle_Slice_int64(h CGoHandle) []int64 {
+	p := ptrFromHandle_Slice_int64(h)
+	if p == nil {
+		return nil
+	}
+	return *p
+}
+func handleFromPtr_Slice_int64(p interface{}) CGoHandle {
+	return CGoHandle(gopyh.Register("[]int64", p))
+}
+
+// --- wrapping slice: []int64 ---
+//
+//export Slice_int64_CTor
+func Slice_int64_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_Slice_int64(&[]int64{}))
+}
+
+//export Slice_int64_len
+func Slice_int64_len(handle CGoHandle) int {
+	return len(deptrFromHandle_Slice_int64(handle))
+}
+
+//export Slice_int64_elem
+func Slice_int64_elem(handle CGoHandle, _idx int) C.longlong {
+	s := deptrFromHandle_Slice_int64(handle)
+	return C.longlong(s[_idx])
+}
+
+//export Slice_int64_subslice
+func Slice_int64_subslice(handle CGoHandle, _st, _ed int) CGoHandle {
+	s := deptrFromHandle_Slice_int64(handle)
+	ss := s[_st:_ed]
+	return CGoHandle(handleFromPtr_Slice_int64(&ss))
+}
+
+//export Slice_int64_set
+func Slice_int64_set(handle CGoHandle, _idx int, _vl C.longlong) {
+	s := deptrFromHandle_Slice_int64(handle)
+	s[_idx] = int64(_vl)
+}
+
+//export Slice_int64_append
+func Slice_int64_append(handle CGoHandle, _vl C.longlong) {
+	s := ptrFromHandle_Slice_int64(handle)
+	*s = append(*s, int64(_vl))
+}
+
+// Converters for implicit pointer handles for type: []int8
+func ptrFromHandle_Slice_int8(h CGoHandle) *[]int8 {
+	p := gopyh.VarFromHandle((gopyh.CGoHandle)(h), "[]int8")
+	if p == nil {
+		return nil
+	}
+	return p.(*[]int8)
+}
+func deptrFromHandle_Slice_int8(h CGoHandle) []int8 {
+	p := ptrFromHandle_Slice_int8(h)
+	if p == nil {
+		return nil
+	}
+	return *p
+}
+func handleFromPtr_Slice_int8(p interface{}) CGoHandle {
+	return CGoHandle(gopyh.Register("[]int8", p))
+}
+
+// --- wrapping slice: []int8 ---
+//
+//export Slice_int8_CTor
+func Slice_int8_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_Slice_int8(&[]int8{}))
+}
+
+//export Slice_int8_len
+func Slice_int8_len(handle CGoHandle) int {
+	return len(deptrFromHandle_Slice_int8(handle))
+}
+
+//export Slice_int8_elem
+func Slice_int8_elem(handle CGoHandle, _idx int) C.char {
+	s := deptrFromHandle_Slice_int8(handle)
+	return C.char(s[_idx])
+}
+
+//export Slice_int8_subslice
+func Slice_int8_subslice(handle CGoHandle, _st, _ed int) CGoHandle {
+	s := deptrFromHandle_Slice_int8(handle)
+	ss := s[_st:_ed]
+	return CGoHandle(handleFromPtr_Slice_int8(&ss))
+}
+
+//export Slice_int8_set
+func Slice_int8_set(handle CGoHandle, _idx int, _vl C.char) {
+	s := deptrFromHandle_Slice_int8(handle)
+	s[_idx] = int8(_vl)
+}
+
+//export Slice_int8_append
+func Slice_int8_append(handle CGoHandle, _vl C.char) {
+	s := ptrFromHandle_Slice_int8(handle)
+	*s = append(*s, int8(_vl))
+}
+
+// Converters for implicit pointer handles for type: []rune
+func ptrFromHandle_Slice_rune(h CGoHandle) *[]rune {
+	p := gopyh.VarFromHandle((gopyh.CGoHandle)(h), "[]rune")
+	if p == nil {
+		return nil
+	}
+	return p.(*[]rune)
+}
+func deptrFromHandle_Slice_rune(h CGoHandle) []rune {
+	p := ptrFromHandle_Slice_rune(h)
+	if p == nil {
+		return nil
+	}
+	return *p
+}
+func handleFromPtr_Slice_rune(p interface{}) CGoHandle {
+	return CGoHandle(gopyh.Register("[]rune", p))
+}
+
+// --- wrapping slice: []rune ---
+//
+//export Slice_rune_CTor
+func Slice_rune_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_Slice_rune(&[]rune{}))
+}
+
+//export Slice_rune_len
+func Slice_rune_len(handle CGoHandle) int {
+	return len(deptrFromHandle_Slice_rune(handle))
+}
+
+//export Slice_rune_elem
+func Slice_rune_elem(handle CGoHandle, _idx int) C.long {
+	s := deptrFromHandle_Slice_rune(handle)
+	return C.long(s[_idx])
+}
+
+//export Slice_rune_subslice
+func Slice_rune_subslice(handle CGoHandle, _st, _ed int) CGoHandle {
+	s := deptrFromHandle_Slice_rune(handle)
+	ss := s[_st:_ed]
+	return CGoHandle(handleFromPtr_Slice_rune(&ss))
+}
+
+//export Slice_rune_set
+func Slice_rune_set(handle CGoHandle, _idx int, _vl C.long) {
+	s := deptrFromHandle_Slice_rune(handle)
+	s[_idx] = rune(_vl)
+}
+
+//export Slice_rune_append
+func Slice_rune_append(handle CGoHandle, _vl C.long) {
+	s := ptrFromHandle_Slice_rune(handle)
+	*s = append(*s, rune(_vl))
+}
+
+// Converters for implicit pointer handles for type: []string
+func ptrFromHandle_Slice_string(h CGoHandle) *[]string {
+	p := gopyh.VarFromHandle((gopyh.CGoHandle)(h), "[]string")
+	if p == nil {
+		return nil
+	}
+	return p.(*[]string)
+}
+func deptrFromHandle_Slice_string(h CGoHandle) []string {
+	p := ptrFromHandle_Slice_string(h)
+	if p == nil {
+		return nil
+	}
+	return *p
+}
+func handleFromPtr_Slice_string(p interface{}) CGoHandle {
+	return CGoHandle(gopyh.Register("[]string", p))
+}
+
+// --- wrapping slice: []string ---
+//
+//export Slice_string_CTor
+func Slice_string_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_Slice_string(&[]string{}))
+}
+
+//export Slice_string_len
+func Slice_string_len(handle CGoHandle) int {
+	return len(deptrFromHandle_Slice_string(handle))
+}
+
+//export Slice_string_elem
+func Slice_string_elem(handle CGoHandle, _idx int) *C.char {
+	s := deptrFromHandle_Slice_string(handle)
+	return C.CString(s[_idx])
+}
+
+//export Slice_string_subslice
+func Slice_string_subslice(handle CGoHandle, _st, _ed int) CGoHandle {
+	s := deptrFromHandle_Slice_string(handle)
+	ss := s[_st:_ed]
+	return CGoHandle(handleFromPtr_Slice_string(&ss))
+}
+
+//export Slice_string_set
+func Slice_string_set(handle CGoHandle, _idx int, _vl *C.char) {
+	s := deptrFromHandle_Slice_string(handle)
+	s[_idx] = C.GoString(_vl)
+}
+
+//export Slice_string_append
+func Slice_string_append(handle CGoHandle, _vl *C.char) {
+	s := ptrFromHandle_Slice_string(handle)
+	*s = append(*s, C.GoString(_vl))
+}
+
+// Converters for implicit pointer handles for type: []uint
+func ptrFromHandle_Slice_uint(h CGoHandle) *[]uint {
+	p := gopyh.VarFromHandle((gopyh.CGoHandle)(h), "[]uint")
+	if p == nil {
+		return nil
+	}
+	return p.(*[]uint)
+}
+func deptrFromHandle_Slice_uint(h CGoHandle) []uint {
+	p := ptrFromHandle_Slice_uint(h)
+	if p == nil {
+		return nil
+	}
+	return *p
+}
+func handleFromPtr_Slice_uint(p interface{}) CGoHandle {
+	return CGoHandle(gopyh.Register("[]uint", p))
+}
+
+// --- wrapping slice: []uint ---
+//
+//export Slice_uint_CTor
+func Slice_uint_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_Slice_uint(&[]uint{}))
+}
+
+//export Slice_uint_len
+func Slice_uint_len(handle CGoHandle) int {
+	return len(deptrFromHandle_Slice_uint(handle))
+}
+
+//export Slice_uint_elem
+func Slice_uint_elem(handle CGoHandle, _idx int) C.ulonglong {
+	s := deptrFromHandle_Slice_uint(handle)
+	return C.ulonglong(s[_idx])
+}
+
+//export Slice_uint_subslice
+func Slice_uint_subslice(handle CGoHandle, _st, _ed int) CGoHandle {
+	s := deptrFromHandle_Slice_uint(handle)
+	ss := s[_st:_ed]
+	return CGoHandle(handleFromPtr_Slice_uint(&ss))
+}
+
+//export Slice_uint_set
+func Slice_uint_set(handle CGoHandle, _idx int, _vl C.ulonglong) {
+	s := deptrFromHandle_Slice_uint(handle)
+	s[_idx] = uint(_vl)
+}
+
+//export Slice_uint_append
+func Slice_uint_append(handle CGoHandle, _vl C.ulonglong) {
+	s := ptrFromHandle_Slice_uint(handle)
+	*s = append(*s, uint(_vl))
+}
+
+// Converters for implicit pointer handles for type: []uint16
+func ptrFromHandle_Slice_uint16(h CGoHandle) *[]uint16 {
+	p := gopyh.VarFromHandle((gopyh.CGoHandle)(h), "[]uint16")
+	if p == nil {
+		return nil
+	}
+	return p.(*[]uint16)
+}
+func deptrFromHandle_Slice_uint16(h CGoHandle) []uint16 {
+	p := ptrFromHandle_Slice_uint16(h)
+	if p == nil {
+		return nil
+	}
+	return *p
+}
+func handleFromPtr_Slice_uint16(p interface{}) CGoHandle {
+	return CGoHandle(gopyh.Register("[]uint16", p))
+}
+
+// --- wrapping slice: []uint16 ---
+//
+//export Slice_uint16_CTor
+func Slice_uint16_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_Slice_uint16(&[]uint16{}))
+}
+
+//export Slice_uint16_len
+func Slice_uint16_len(handle CGoHandle) int {
+	return len(deptrFromHandle_Slice_uint16(handle))
+}
+
+//export Slice_uint16_elem
+func Slice_uint16_elem(handle CGoHandle, _idx int) C.ushort {
+	s := deptrFromHandle_Slice_uint16(handle)
+	return C.ushort(s[_idx])
+}
+
+//export Slice_uint16_subslice
+func Slice_uint16_subslice(handle CGoHandle, _st, _ed int) CGoHandle {
+	s := deptrFromHandle_Slice_uint16(handle)
+	ss := s[_st:_ed]
+	return CGoHandle(handleFromPtr_Slice_uint16(&ss))
+}
+
+//export Slice_uint16_set
+func Slice_uint16_set(handle CGoHandle, _idx int, _vl C.ushort) {
+	s := deptrFromHandle_Slice_uint16(handle)
+	s[_idx] = uint16(_vl)
+}
+
+//export Slice_uint16_append
+func Slice_uint16_append(handle CGoHandle, _vl C.ushort) {
+	s := ptrFromHandle_Slice_uint16(handle)
+	*s = append(*s, uint16(_vl))
+}
+
+// Converters for implicit pointer handles for type: []uint32
+func ptrFromHandle_Slice_uint32(h CGoHandle) *[]uint32 {
+	p := gopyh.VarFromHandle((gopyh.CGoHandle)(h), "[]uint32")
+	if p == nil {
+		return nil
+	}
+	return p.(*[]uint32)
+}
+func deptrFromHandle_Slice_uint32(h CGoHandle) []uint32 {
+	p := ptrFromHandle_Slice_uint32(h)
+	if p == nil {
+		return nil
+	}
+	return *p
+}
+func handleFromPtr_Slice_uint32(p interface{}) CGoHandle {
+	return CGoHandle(gopyh.Register("[]uint32", p))
+}
+
+// --- wrapping slice: []uint32 ---
+//
+//export Slice_uint32_CTor
+func Slice_uint32_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_Slice_uint32(&[]uint32{}))
+}
+
+//export Slice_uint32_len
+func Slice_uint32_len(handle CGoHandle) int {
+	return len(deptrFromHandle_Slice_uint32(handle))
+}
+
+//export Slice_uint32_elem
+func Slice_uint32_elem(handle CGoHandle, _idx int) C.ulong {
+	s := deptrFromHandle_Slice_uint32(handle)
+	return C.ulong(s[_idx])
+}
+
+//export Slice_uint32_subslice
+func Slice_uint32_subslice(handle CGoHandle, _st, _ed int) CGoHandle {
+	s := deptrFromHandle_Slice_uint32(handle)
+	ss := s[_st:_ed]
+	return CGoHandle(handleFromPtr_Slice_uint32(&ss))
+}
+
+//export Slice_uint32_set
+func Slice_uint32_set(handle CGoHandle, _idx int, _vl C.ulong) {
+	s := deptrFromHandle_Slice_uint32(handle)
+	s[_idx] = uint32(_vl)
+}
+
+//export Slice_uint32_append
+func Slice_uint32_append(handle CGoHandle, _vl C.ulong) {
+	s := ptrFromHandle_Slice_uint32(handle)
+	*s = append(*s, uint32(_vl))
+}
+
+// Converters for implicit pointer handles for type: []uint64
+func ptrFromHandle_Slice_uint64(h CGoHandle) *[]uint64 {
+	p := gopyh.VarFromHandle((gopyh.CGoHandle)(h), "[]uint64")
+	if p == nil {
+		return nil
+	}
+	return p.(*[]uint64)
+}
+func deptrFromHandle_Slice_uint64(h CGoHandle) []uint64 {
+	p := ptrFromHandle_Slice_uint64(h)
+	if p == nil {
+		return nil
+	}
+	return *p
+}
+func handleFromPtr_Slice_uint64(p interface{}) CGoHandle {
+	return CGoHandle(gopyh.Register("[]uint64", p))
+}
+
+// --- wrapping slice: []uint64 ---
+//
+//export Slice_uint64_CTor
+func Slice_uint64_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_Slice_uint64(&[]uint64{}))
+}
+
+//export Slice_uint64_len
+func Slice_uint64_len(handle CGoHandle) int {
+	return len(deptrFromHandle_Slice_uint64(handle))
+}
+
+//export Slice_uint64_elem
+func Slice_uint64_elem(handle CGoHandle, _idx int) C.ulonglong {
+	s := deptrFromHandle_Slice_uint64(handle)
+	return C.ulonglong(s[_idx])
+}
+
+//export Slice_uint64_subslice
+func Slice_uint64_subslice(handle CGoHandle, _st, _ed int) CGoHandle {
+	s := deptrFromHandle_Slice_uint64(handle)
+	ss := s[_st:_ed]
+	return CGoHandle(handleFromPtr_Slice_uint64(&ss))
+}
+
+//export Slice_uint64_set
+func Slice_uint64_set(handle CGoHandle, _idx int, _vl C.ulonglong) {
+	s := deptrFromHandle_Slice_uint64(handle)
+	s[_idx] = uint64(_vl)
+}
+
+//export Slice_uint64_append
+func Slice_uint64_append(handle CGoHandle, _vl C.ulonglong) {
+	s := ptrFromHandle_Slice_uint64(handle)
+	*s = append(*s, uint64(_vl))
+}
+
+// Converters for implicit pointer handles for type: []uint8
+func ptrFromHandle_Slice_uint8(h CGoHandle) *[]uint8 {
+	p := gopyh.VarFromHandle((gopyh.CGoHandle)(h), "[]uint8")
+	if p == nil {
+		return nil
+	}
+	return p.(*[]uint8)
+}
+func deptrFromHandle_Slice_uint8(h CGoHandle) []uint8 {
+	p := ptrFromHandle_Slice_uint8(h)
+	if p == nil {
+		return nil
+	}
+	return *p
+}
+func handleFromPtr_Slice_uint8(p interface{}) CGoHandle {
+	return CGoHandle(gopyh.Register("[]uint8", p))
+}
+
+// --- wrapping slice: []uint8 ---
+//
+//export Slice_uint8_CTor
+func Slice_uint8_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_Slice_uint8(&[]uint8{}))
+}
+
+//export Slice_uint8_len
+func Slice_uint8_len(handle CGoHandle) int {
+	return len(deptrFromHandle_Slice_uint8(handle))
+}
+
+//export Slice_uint8_elem
+func Slice_uint8_elem(handle CGoHandle, _idx int) C.uchar {
+	s := deptrFromHandle_Slice_uint8(handle)
+	return C.uchar(s[_idx])
+}
+
+//export Slice_uint8_subslice
+func Slice_uint8_subslice(handle CGoHandle, _st, _ed int) CGoHandle {
+	s := deptrFromHandle_Slice_uint8(handle)
+	ss := s[_st:_ed]
+	return CGoHandle(handleFromPtr_Slice_uint8(&ss))
+}
+
+//export Slice_uint8_set
+func Slice_uint8_set(handle CGoHandle, _idx int, _vl C.uchar) {
+	s := deptrFromHandle_Slice_uint8(handle)
+	s[_idx] = uint8(_vl)
+}
+
+//export Slice_uint8_append
+func Slice_uint8_append(handle CGoHandle, _vl C.uchar) {
+	s := ptrFromHandle_Slice_uint8(handle)
+	*s = append(*s, uint8(_vl))
+}
+
+// ---- Package: scrypted_arlo_go ---
+
+// ---- Types ---
+
+// Converters for pointer handles for type: *scrypted_arlo_go.AuthHeader
+func ptrFromHandle_Ptr_scrypted_arlo_go_AuthHeader(h CGoHandle) *scrypted_arlo_go.AuthHeader {
+	p := gopyh.VarFromHandle((gopyh.CGoHandle)(h), "*scrypted_arlo_go.AuthHeader")
+	if p == nil {
+		return nil
+	}
+	return gopyh.Embed(p, reflect.TypeOf(scrypted_arlo_go.AuthHeader{})).(*scrypted_arlo_go.AuthHeader)
+}
+func handleFromPtr_Ptr_scrypted_arlo_go_AuthHeader(p interface{}) CGoHandle {
+	return CGoHandle(gopyh.Register("*scrypted_arlo_go.AuthHeader", p))
+}
+
+// Converters for pointer handles for type: *scrypted_arlo_go.KeysOutput
+func ptrFromHandle_Ptr_scrypted_arlo_go_KeysOutput(h CGoHandle) *scrypted_arlo_go.KeysOutput {
+	p := gopyh.VarFromHandle((gopyh.CGoHandle)(h), "*scrypted_arlo_go.KeysOutput")
+	if p == nil {
+		return nil
+	}
+	return gopyh.Embed(p, reflect.TypeOf(scrypted_arlo_go.KeysOutput{})).(*scrypted_arlo_go.KeysOutput)
+}
+func handleFromPtr_Ptr_scrypted_arlo_go_KeysOutput(p interface{}) CGoHandle {
+	return CGoHandle(gopyh.Register("*scrypted_arlo_go.KeysOutput", p))
+}
+
+// Converters for pointer handles for type: *scrypted_arlo_go.LocalStreamProxy
+func ptrFromHandle_Ptr_scrypted_arlo_go_LocalStreamProxy(h CGoHandle) *scrypted_arlo_go.LocalStreamProxy {
+	p := gopyh.VarFromHandle((gopyh.CGoHandle)(h), "*scrypted_arlo_go.LocalStreamProxy")
+	if p == nil {
+		return nil
+	}
+	return gopyh.Embed(p, reflect.TypeOf(scrypted_arlo_go.LocalStreamProxy{})).(*scrypted_arlo_go.LocalStreamProxy)
+}
+func handleFromPtr_Ptr_scrypted_arlo_go_LocalStreamProxy(p interface{}) CGoHandle {
+	return CGoHandle(gopyh.Register("*scrypted_arlo_go.LocalStreamProxy", p))
+}
+
+// Converters for pointer handles for type: *scrypted_arlo_go.SIPInfo
+func ptrFromHandle_Ptr_scrypted_arlo_go_SIPInfo(h CGoHandle) *scrypted_arlo_go.SIPInfo {
+	p := gopyh.VarFromHandle((gopyh.CGoHandle)(h), "*scrypted_arlo_go.SIPInfo")
+	if p == nil {
+		return nil
+	}
+	return gopyh.Embed(p, reflect.TypeOf(scrypted_arlo_go.SIPInfo{})).(*scrypted_arlo_go.SIPInfo)
+}
+func handleFromPtr_Ptr_scrypted_arlo_go_SIPInfo(p interface{}) CGoHandle {
+	return CGoHandle(gopyh.Register("*scrypted_arlo_go.SIPInfo", p))
+}
+
+// Converters for pointer handles for type: *scrypted_arlo_go.SIPWebRTCManager
+func ptrFromHandle_Ptr_scrypted_arlo_go_SIPWebRTCManager(h CGoHandle) *scrypted_arlo_go.SIPWebRTCManager {
+	p := gopyh.VarFromHandle((gopyh.CGoHandle)(h), "*scrypted_arlo_go.SIPWebRTCManager")
+	if p == nil {
+		return nil
+	}
+	return gopyh.Embed(p, reflect.TypeOf(scrypted_arlo_go.SIPWebRTCManager{})).(*scrypted_arlo_go.SIPWebRTCManager)
+}
+func handleFromPtr_Ptr_scrypted_arlo_go_SIPWebRTCManager(p interface{}) CGoHandle {
+	return CGoHandle(gopyh.Register("*scrypted_arlo_go.SIPWebRTCManager", p))
+}
+
+// Converters for pointer handles for type: *scrypted_arlo_go.SSEClient
+func ptrFromHandle_Ptr_scrypted_arlo_go_SSEClient(h CGoHandle) *scrypted_arlo_go.SSEClient {
+	p := gopyh.VarFromHandle((gopyh.CGoHandle)(h), "*scrypted_arlo_go.SSEClient")
+	if p == nil {
+		return nil
+	}
+	return gopyh.Embed(p, reflect.TypeOf(scrypted_arlo_go.SSEClient{})).(*scrypted_arlo_go.SSEClient)
+}
+func handleFromPtr_Ptr_scrypted_arlo_go_SSEClient(p interface{}) CGoHandle {
+	return CGoHandle(gopyh.Register("*scrypted_arlo_go.SSEClient", p))
+}
+
+// Converters for pointer handles for type: *scrypted_arlo_go.TCPLogger
+func ptrFromHandle_Ptr_scrypted_arlo_go_TCPLogger(h CGoHandle) *scrypted_arlo_go.TCPLogger {
+	p := gopyh.VarFromHandle((gopyh.CGoHandle)(h), "*scrypted_arlo_go.TCPLogger")
+	if p == nil {
+		return nil
+	}
+	return gopyh.Embed(p, reflect.TypeOf(scrypted_arlo_go.TCPLogger{})).(*scrypted_arlo_go.TCPLogger)
+}
+func handleFromPtr_Ptr_scrypted_arlo_go_TCPLogger(p interface{}) CGoHandle {
+	return CGoHandle(gopyh.Register("*scrypted_arlo_go.TCPLogger", p))
+}
+
+// Converters for pointer handles for type: *scrypted_arlo_go.WebRTCManager
+func ptrFromHandle_Ptr_scrypted_arlo_go_WebRTCManager(h CGoHandle) *scrypted_arlo_go.WebRTCManager {
+	p := gopyh.VarFromHandle((gopyh.CGoHandle)(h), "*scrypted_arlo_go.WebRTCManager")
+	if p == nil {
+		return nil
+	}
+	return gopyh.Embed(p, reflect.TypeOf(scrypted_arlo_go.WebRTCManager{})).(*scrypted_arlo_go.WebRTCManager)
+}
+func handleFromPtr_Ptr_scrypted_arlo_go_WebRTCManager(p interface{}) CGoHandle {
+	return CGoHandle(gopyh.Register("*scrypted_arlo_go.WebRTCManager", p))
+}
+
+// Converters for implicit pointer handles for type: []*sdp.MediaDescription
+func ptrFromHandle_Slice_Ptr_sdp_MediaDescription(h CGoHandle) *[]*sdp.MediaDescription {
+	p := gopyh.VarFromHandle((gopyh.CGoHandle)(h), "[]*sdp.MediaDescription")
+	if p == nil {
+		return nil
+	}
+	return p.(*[]*sdp.MediaDescription)
+}
+func deptrFromHandle_Slice_Ptr_sdp_MediaDescription(h CGoHandle) []*sdp.MediaDescription {
+	p := ptrFromHandle_Slice_Ptr_sdp_MediaDescription(h)
+	if p == nil {
+		return nil
+	}
+	return *p
+}
+func handleFromPtr_Slice_Ptr_sdp_MediaDescription(p interface{}) CGoHandle {
+	return CGoHandle(gopyh.Register("[]*sdp.MediaDescription", p))
+}
+
+// --- wrapping slice: []*sdp.MediaDescription ---
+//
+//export Slice_Ptr_sdp_MediaDescription_CTor
+func Slice_Ptr_sdp_MediaDescription_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_Slice_Ptr_sdp_MediaDescription(&[]*sdp.MediaDescription{}))
+}
+
+//export Slice_Ptr_sdp_MediaDescription_len
+func Slice_Ptr_sdp_MediaDescription_len(handle CGoHandle) int {
+	return len(deptrFromHandle_Slice_Ptr_sdp_MediaDescription(handle))
+}
+
+//export Slice_Ptr_sdp_MediaDescription_elem
+func Slice_Ptr_sdp_MediaDescription_elem(handle CGoHandle, _idx int) CGoHandle {
+	s := deptrFromHandle_Slice_Ptr_sdp_MediaDescription(handle)
+	return handleFromPtr_Ptr_sdp_MediaDescription(s[_idx])
+}
+
+//export Slice_Ptr_sdp_MediaDescription_subslice
+func Slice_Ptr_sdp_MediaDescription_subslice(handle CGoHandle, _st, _ed int) CGoHandle {
+	s := deptrFromHandle_Slice_Ptr_sdp_MediaDescription(handle)
+	ss := s[_st:_ed]
+	return CGoHandle(handleFromPtr_Slice_Ptr_sdp_MediaDescription(&ss))
+}
+
+//export Slice_Ptr_sdp_MediaDescription_set
+func Slice_Ptr_sdp_MediaDescription_set(handle CGoHandle, _idx int, _vl CGoHandle) {
+	s := deptrFromHandle_Slice_Ptr_sdp_MediaDescription(handle)
+	s[_idx] = ptrFromHandle_Ptr_sdp_MediaDescription(_vl)
+}
+
+//export Slice_Ptr_sdp_MediaDescription_append
+func Slice_Ptr_sdp_MediaDescription_append(handle CGoHandle, _vl CGoHandle) {
+	s := ptrFromHandle_Slice_Ptr_sdp_MediaDescription(handle)
+	*s = append(*s, ptrFromHandle_Ptr_sdp_MediaDescription(_vl))
+}
+
+// Converters for implicit pointer handles for type: []any
+func ptrFromHandle_Slice_any(h CGoHandle) *[]any {
+	p := gopyh.VarFromHandle((gopyh.CGoHandle)(h), "[]any")
+	if p == nil {
+		return nil
+	}
+	return p.(*[]any)
+}
+func deptrFromHandle_Slice_any(h CGoHandle) []any {
+	p := ptrFromHandle_Slice_any(h)
+	if p == nil {
+		return nil
+	}
+	return *p
+}
+func handleFromPtr_Slice_any(p interface{}) CGoHandle {
+	return CGoHandle(gopyh.Register("[]any", p))
+}
+
+// --- wrapping slice: []any ---
+//
+//export Slice_any_CTor
+func Slice_any_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_Slice_any(&[]any{}))
+}
+
+//export Slice_any_len
+func Slice_any_len(handle CGoHandle) int {
+	return len(deptrFromHandle_Slice_any(handle))
+}
+
+//export Slice_any_elem
+func Slice_any_elem(handle CGoHandle, _idx int) CGoHandle {
+	s := deptrFromHandle_Slice_any(handle)
+	return handleFromPtr_any(s[_idx])
+}
+
+//export Slice_any_subslice
+func Slice_any_subslice(handle CGoHandle, _st, _ed int) CGoHandle {
+	s := deptrFromHandle_Slice_any(handle)
+	ss := s[_st:_ed]
+	return CGoHandle(handleFromPtr_Slice_any(&ss))
+}
+
+//export Slice_any_set
+func Slice_any_set(handle CGoHandle, _idx int, _vl CGoHandle) {
+	s := deptrFromHandle_Slice_any(handle)
+	s[_idx] = ptrFromHandle_any(_vl)
+}
+
+//export Slice_any_append
+func Slice_any_append(handle CGoHandle, _vl CGoHandle) {
+	s := ptrFromHandle_Slice_any(handle)
+	*s = append(*s, ptrFromHandle_any(_vl))
+}
+
+// Converters for implicit pointer handles for type: []sdp.Attribute
+func ptrFromHandle_Slice_sdp_Attribute(h CGoHandle) *[]sdp.Attribute {
+	p := gopyh.VarFromHandle((gopyh.CGoHandle)(h), "[]sdp.Attribute")
+	if p == nil {
+		return nil
+	}
+	return p.(*[]sdp.Attribute)
+}
+func deptrFromHandle_Slice_sdp_Attribute(h CGoHandle) []sdp.Attribute {
+	p := ptrFromHandle_Slice_sdp_Attribute(h)
+	if p == nil {
+		return nil
+	}
+	return *p
+}
+func handleFromPtr_Slice_sdp_Attribute(p interface{}) CGoHandle {
+	return CGoHandle(gopyh.Register("[]sdp.Attribute", p))
+}
+
+// --- wrapping slice: []sdp.Attribute ---
+//
+//export Slice_sdp_Attribute_CTor
+func Slice_sdp_Attribute_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_Slice_sdp_Attribute(&[]sdp.Attribute{}))
+}
+
+//export Slice_sdp_Attribute_len
+func Slice_sdp_Attribute_len(handle CGoHandle) int {
+	return len(deptrFromHandle_Slice_sdp_Attribute(handle))
+}
+
+//export Slice_sdp_Attribute_elem
+func Slice_sdp_Attribute_elem(handle CGoHandle, _idx int) CGoHandle {
+	s := deptrFromHandle_Slice_sdp_Attribute(handle)
+	return handleFromPtr_sdp_Attribute(&(s[_idx]))
+}
+
+//export Slice_sdp_Attribute_subslice
+func Slice_sdp_Attribute_subslice(handle CGoHandle, _st, _ed int) CGoHandle {
+	s := deptrFromHandle_Slice_sdp_Attribute(handle)
+	ss := s[_st:_ed]
+	return CGoHandle(handleFromPtr_Slice_sdp_Attribute(&ss))
+}
+
+//export Slice_sdp_Attribute_set
+func Slice_sdp_Attribute_set(handle CGoHandle, _idx int, _vl CGoHandle) {
+	s := deptrFromHandle_Slice_sdp_Attribute(handle)
+	s[_idx] = *ptrFromHandle_sdp_Attribute(_vl)
+}
+
+//export Slice_sdp_Attribute_append
+func Slice_sdp_Attribute_append(handle CGoHandle, _vl CGoHandle) {
+	s := ptrFromHandle_Slice_sdp_Attribute(handle)
+	*s = append(*s, *ptrFromHandle_sdp_Attribute(_vl))
+}
+
+// Converters for implicit pointer handles for type: []sdp.Bandwidth
+func ptrFromHandle_Slice_sdp_Bandwidth(h CGoHandle) *[]sdp.Bandwidth {
+	p := gopyh.VarFromHandle((gopyh.CGoHandle)(h), "[]sdp.Bandwidth")
+	if p == nil {
+		return nil
+	}
+	return p.(*[]sdp.Bandwidth)
+}
+func deptrFromHandle_Slice_sdp_Bandwidth(h CGoHandle) []sdp.Bandwidth {
+	p := ptrFromHandle_Slice_sdp_Bandwidth(h)
+	if p == nil {
+		return nil
+	}
+	return *p
+}
+func handleFromPtr_Slice_sdp_Bandwidth(p interface{}) CGoHandle {
+	return CGoHandle(gopyh.Register("[]sdp.Bandwidth", p))
+}
+
+// --- wrapping slice: []sdp.Bandwidth ---
+//
+//export Slice_sdp_Bandwidth_CTor
+func Slice_sdp_Bandwidth_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_Slice_sdp_Bandwidth(&[]sdp.Bandwidth{}))
+}
+
+//export Slice_sdp_Bandwidth_len
+func Slice_sdp_Bandwidth_len(handle CGoHandle) int {
+	return len(deptrFromHandle_Slice_sdp_Bandwidth(handle))
+}
+
+//export Slice_sdp_Bandwidth_elem
+func Slice_sdp_Bandwidth_elem(handle CGoHandle, _idx int) CGoHandle {
+	s := deptrFromHandle_Slice_sdp_Bandwidth(handle)
+	return handleFromPtr_sdp_Bandwidth(&(s[_idx]))
+}
+
+//export Slice_sdp_Bandwidth_subslice
+func Slice_sdp_Bandwidth_subslice(handle CGoHandle, _st, _ed int) CGoHandle {
+	s := deptrFromHandle_Slice_sdp_Bandwidth(handle)
+	ss := s[_st:_ed]
+	return CGoHandle(handleFromPtr_Slice_sdp_Bandwidth(&ss))
+}
+
+//export Slice_sdp_Bandwidth_set
+func Slice_sdp_Bandwidth_set(handle CGoHandle, _idx int, _vl CGoHandle) {
+	s := deptrFromHandle_Slice_sdp_Bandwidth(handle)
+	s[_idx] = *ptrFromHandle_sdp_Bandwidth(_vl)
+}
+
+//export Slice_sdp_Bandwidth_append
+func Slice_sdp_Bandwidth_append(handle CGoHandle, _vl CGoHandle) {
+	s := ptrFromHandle_Slice_sdp_Bandwidth(handle)
+	*s = append(*s, *ptrFromHandle_sdp_Bandwidth(_vl))
+}
+
+// Converters for implicit pointer handles for type: []sdp.RepeatTime
+func ptrFromHandle_Slice_sdp_RepeatTime(h CGoHandle) *[]sdp.RepeatTime {
+	p := gopyh.VarFromHandle((gopyh.CGoHandle)(h), "[]sdp.RepeatTime")
+	if p == nil {
+		return nil
+	}
+	return p.(*[]sdp.RepeatTime)
+}
+func deptrFromHandle_Slice_sdp_RepeatTime(h CGoHandle) []sdp.RepeatTime {
+	p := ptrFromHandle_Slice_sdp_RepeatTime(h)
+	if p == nil {
+		return nil
+	}
+	return *p
+}
+func handleFromPtr_Slice_sdp_RepeatTime(p interface{}) CGoHandle {
+	return CGoHandle(gopyh.Register("[]sdp.RepeatTime", p))
+}
+
+// --- wrapping slice: []sdp.RepeatTime ---
+//
+//export Slice_sdp_RepeatTime_CTor
+func Slice_sdp_RepeatTime_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_Slice_sdp_RepeatTime(&[]sdp.RepeatTime{}))
+}
+
+//export Slice_sdp_RepeatTime_len
+func Slice_sdp_RepeatTime_len(handle CGoHandle) int {
+	return len(deptrFromHandle_Slice_sdp_RepeatTime(handle))
+}
+
+//export Slice_sdp_RepeatTime_elem
+func Slice_sdp_RepeatTime_elem(handle CGoHandle, _idx int) CGoHandle {
+	s := deptrFromHandle_Slice_sdp_RepeatTime(handle)
+	return handleFromPtr_sdp_RepeatTime(&(s[_idx]))
+}
+
+//export Slice_sdp_RepeatTime_subslice
+func Slice_sdp_RepeatTime_subslice(handle CGoHandle, _st, _ed int) CGoHandle {
+	s := deptrFromHandle_Slice_sdp_RepeatTime(handle)
+	ss := s[_st:_ed]
+	return CGoHandle(handleFromPtr_Slice_sdp_RepeatTime(&ss))
+}
+
+//export Slice_sdp_RepeatTime_set
+func Slice_sdp_RepeatTime_set(handle CGoHandle, _idx int, _vl CGoHandle) {
+	s := deptrFromHandle_Slice_sdp_RepeatTime(handle)
+	s[_idx] = *ptrFromHandle_sdp_RepeatTime(_vl)
+}
+
+//export Slice_sdp_RepeatTime_append
+func Slice_sdp_RepeatTime_append(handle CGoHandle, _vl CGoHandle) {
+	s := ptrFromHandle_Slice_sdp_RepeatTime(handle)
+	*s = append(*s, *ptrFromHandle_sdp_RepeatTime(_vl))
+}
+
+// Converters for implicit pointer handles for type: []sdp.TimeDescription
+func ptrFromHandle_Slice_sdp_TimeDescription(h CGoHandle) *[]sdp.TimeDescription {
+	p := gopyh.VarFromHandle((gopyh.CGoHandle)(h), "[]sdp.TimeDescription")
+	if p == nil {
+		return nil
+	}
+	return p.(*[]sdp.TimeDescription)
+}
+func deptrFromHandle_Slice_sdp_TimeDescription(h CGoHandle) []sdp.TimeDescription {
+	p := ptrFromHandle_Slice_sdp_TimeDescription(h)
+	if p == nil {
+		return nil
+	}
+	return *p
+}
+func handleFromPtr_Slice_sdp_TimeDescription(p interface{}) CGoHandle {
+	return CGoHandle(gopyh.Register("[]sdp.TimeDescription", p))
+}
+
+// --- wrapping slice: []sdp.TimeDescription ---
+//
+//export Slice_sdp_TimeDescription_CTor
+func Slice_sdp_TimeDescription_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_Slice_sdp_TimeDescription(&[]sdp.TimeDescription{}))
+}
+
+//export Slice_sdp_TimeDescription_len
+func Slice_sdp_TimeDescription_len(handle CGoHandle) int {
+	return len(deptrFromHandle_Slice_sdp_TimeDescription(handle))
+}
+
+//export Slice_sdp_TimeDescription_elem
+func Slice_sdp_TimeDescription_elem(handle CGoHandle, _idx int) CGoHandle {
+	s := deptrFromHandle_Slice_sdp_TimeDescription(handle)
+	return handleFromPtr_sdp_TimeDescription(&(s[_idx]))
+}
+
+//export Slice_sdp_TimeDescription_subslice
+func Slice_sdp_TimeDescription_subslice(handle CGoHandle, _st, _ed int) CGoHandle {
+	s := deptrFromHandle_Slice_sdp_TimeDescription(handle)
+	ss := s[_st:_ed]
+	return CGoHandle(handleFromPtr_Slice_sdp_TimeDescription(&ss))
+}
+
+//export Slice_sdp_TimeDescription_set
+func Slice_sdp_TimeDescription_set(handle CGoHandle, _idx int, _vl CGoHandle) {
+	s := deptrFromHandle_Slice_sdp_TimeDescription(handle)
+	s[_idx] = *ptrFromHandle_sdp_TimeDescription(_vl)
+}
+
+//export Slice_sdp_TimeDescription_append
+func Slice_sdp_TimeDescription_append(handle CGoHandle, _vl CGoHandle) {
+	s := ptrFromHandle_Slice_sdp_TimeDescription(handle)
+	*s = append(*s, *ptrFromHandle_sdp_TimeDescription(_vl))
+}
+
+// Converters for implicit pointer handles for type: []sdp.TimeZone
+func ptrFromHandle_Slice_sdp_TimeZone(h CGoHandle) *[]sdp.TimeZone {
+	p := gopyh.VarFromHandle((gopyh.CGoHandle)(h), "[]sdp.TimeZone")
+	if p == nil {
+		return nil
+	}
+	return p.(*[]sdp.TimeZone)
+}
+func deptrFromHandle_Slice_sdp_TimeZone(h CGoHandle) []sdp.TimeZone {
+	p := ptrFromHandle_Slice_sdp_TimeZone(h)
+	if p == nil {
+		return nil
+	}
+	return *p
+}
+func handleFromPtr_Slice_sdp_TimeZone(p interface{}) CGoHandle {
+	return CGoHandle(gopyh.Register("[]sdp.TimeZone", p))
+}
+
+// --- wrapping slice: []sdp.TimeZone ---
+//
+//export Slice_sdp_TimeZone_CTor
+func Slice_sdp_TimeZone_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_Slice_sdp_TimeZone(&[]sdp.TimeZone{}))
+}
+
+//export Slice_sdp_TimeZone_len
+func Slice_sdp_TimeZone_len(handle CGoHandle) int {
+	return len(deptrFromHandle_Slice_sdp_TimeZone(handle))
+}
+
+//export Slice_sdp_TimeZone_elem
+func Slice_sdp_TimeZone_elem(handle CGoHandle, _idx int) CGoHandle {
+	s := deptrFromHandle_Slice_sdp_TimeZone(handle)
+	return handleFromPtr_sdp_TimeZone(&(s[_idx]))
+}
+
+//export Slice_sdp_TimeZone_subslice
+func Slice_sdp_TimeZone_subslice(handle CGoHandle, _st, _ed int) CGoHandle {
+	s := deptrFromHandle_Slice_sdp_TimeZone(handle)
+	ss := s[_st:_ed]
+	return CGoHandle(handleFromPtr_Slice_sdp_TimeZone(&ss))
+}
+
+//export Slice_sdp_TimeZone_set
+func Slice_sdp_TimeZone_set(handle CGoHandle, _idx int, _vl CGoHandle) {
+	s := deptrFromHandle_Slice_sdp_TimeZone(handle)
+	s[_idx] = *ptrFromHandle_sdp_TimeZone(_vl)
+}
+
+//export Slice_sdp_TimeZone_append
+func Slice_sdp_TimeZone_append(handle CGoHandle, _vl CGoHandle) {
+	s := ptrFromHandle_Slice_sdp_TimeZone(handle)
+	*s = append(*s, *ptrFromHandle_sdp_TimeZone(_vl))
+}
+
+// Converters for implicit pointer handles for type: []webrtc.ICEServer
+func ptrFromHandle_Slice_webrtc_ICEServer(h CGoHandle) *[]webrtc.ICEServer {
+	p := gopyh.VarFromHandle((gopyh.CGoHandle)(h), "[]webrtc.ICEServer")
+	if p == nil {
+		return nil
+	}
+	return p.(*[]webrtc.ICEServer)
+}
+func deptrFromHandle_Slice_webrtc_ICEServer(h CGoHandle) []webrtc.ICEServer {
+	p := ptrFromHandle_Slice_webrtc_ICEServer(h)
+	if p == nil {
+		return nil
+	}
+	return *p
+}
+func handleFromPtr_Slice_webrtc_ICEServer(p interface{}) CGoHandle {
+	return CGoHandle(gopyh.Register("[]webrtc.ICEServer", p))
+}
+
+// --- wrapping slice: []webrtc.ICEServer ---
+//
+//export Slice_webrtc_ICEServer_CTor
+func Slice_webrtc_ICEServer_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_Slice_webrtc_ICEServer(&[]webrtc.ICEServer{}))
+}
+
+//export Slice_webrtc_ICEServer_len
+func Slice_webrtc_ICEServer_len(handle CGoHandle) int {
+	return len(deptrFromHandle_Slice_webrtc_ICEServer(handle))
+}
+
+//export Slice_webrtc_ICEServer_elem
+func Slice_webrtc_ICEServer_elem(handle CGoHandle, _idx int) CGoHandle {
+	s := deptrFromHandle_Slice_webrtc_ICEServer(handle)
+	return handleFromPtr_webrtc_ICEServer(&(s[_idx]))
+}
+
+//export Slice_webrtc_ICEServer_subslice
+func Slice_webrtc_ICEServer_subslice(handle CGoHandle, _st, _ed int) CGoHandle {
+	s := deptrFromHandle_Slice_webrtc_ICEServer(handle)
+	ss := s[_st:_ed]
+	return CGoHandle(handleFromPtr_Slice_webrtc_ICEServer(&ss))
+}
+
+//export Slice_webrtc_ICEServer_set
+func Slice_webrtc_ICEServer_set(handle CGoHandle, _idx int, _vl CGoHandle) {
+	s := deptrFromHandle_Slice_webrtc_ICEServer(handle)
+	s[_idx] = *ptrFromHandle_webrtc_ICEServer(_vl)
+}
+
+//export Slice_webrtc_ICEServer_append
+func Slice_webrtc_ICEServer_append(handle CGoHandle, _vl CGoHandle) {
+	s := ptrFromHandle_Slice_webrtc_ICEServer(handle)
+	*s = append(*s, *ptrFromHandle_webrtc_ICEServer(_vl))
+}
+
+// Converters for pointer handles for type: any
+func ptrFromHandle_any(h CGoHandle) any {
+	p := gopyh.VarFromHandle((gopyh.CGoHandle)(h), "any")
+	if p == nil {
+		return nil
+	}
+	return p.(any)
+}
+func handleFromPtr_any(p interface{}) CGoHandle {
+	return CGoHandle(gopyh.Register("any", p))
+}
+
+// Converters for implicit pointer handles for type: map[string]string
+func ptrFromHandle_Map_string_string(h CGoHandle) *map[string]string {
+	p := gopyh.VarFromHandle((gopyh.CGoHandle)(h), "map[string]string")
+	if p == nil {
+		return nil
+	}
+	return p.(*map[string]string)
+}
+func deptrFromHandle_Map_string_string(h CGoHandle) map[string]string {
+	p := ptrFromHandle_Map_string_string(h)
+	if p == nil {
+		return nil
+	}
+	return *p
+}
+func handleFromPtr_Map_string_string(p interface{}) CGoHandle {
+	return CGoHandle(gopyh.Register("map[string]string", p))
+}
+
+// --- wrapping map: map[string]string ---
+//
+//export Map_string_string_CTor
+func Map_string_string_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_Map_string_string(&map[string]string{}))
+}
+
+//export Map_string_string_len
+func Map_string_string_len(handle CGoHandle) int {
+	return len(deptrFromHandle_Map_string_string(handle))
+}
+
+//export Map_string_string_elem
+func Map_string_string_elem(handle CGoHandle, _ky *C.char) *C.char {
+	s := deptrFromHandle_Map_string_string(handle)
+	v, ok := s[C.GoString(_ky)]
+	if !ok {
+		C.PyErr_SetString(C.PyExc_KeyError, C.CString("key not in map"))
+	}
+	return C.CString(v)
+}
+
+//export Map_string_string_contains
+func Map_string_string_contains(handle CGoHandle, _ky *C.char) C.char {
+	s := deptrFromHandle_Map_string_string(handle)
+	_, ok := s[C.GoString(_ky)]
+	return boolGoToPy(ok)
+}
+
+//export Map_string_string_set
+func Map_string_string_set(handle CGoHandle, _ky *C.char, _vl *C.char) {
+	s := deptrFromHandle_Map_string_string(handle)
+	s[C.GoString(_ky)] = C.GoString(_vl)
+}
+
+//export Map_string_string_delete
+func Map_string_string_delete(handle CGoHandle, _ky *C.char) {
+	s := deptrFromHandle_Map_string_string(handle)
+	delete(s, C.GoString(_ky))
+}
+
+//export Map_string_string_keys
+func Map_string_string_keys(handle CGoHandle) CGoHandle {
+	s := deptrFromHandle_Map_string_string(handle)
+	kys := make([]string, 0, len(s))
+	for k := range s {
+		kys = append(kys, k)
+	}
+	return handleFromPtr_Slice_string(&kys)
+}
+
+// Converters for non-pointer handles for type: scrypted_arlo_go.AuthHeader
+func ptrFromHandle_scrypted_arlo_go_AuthHeader(h CGoHandle) *scrypted_arlo_go.AuthHeader {
+	p := gopyh.VarFromHandle((gopyh.CGoHandle)(h), "scrypted_arlo_go.AuthHeader")
+	if p == nil {
+		return nil
+	}
+	return gopyh.Embed(p, reflect.TypeOf(scrypted_arlo_go.AuthHeader{})).(*scrypted_arlo_go.AuthHeader)
+}
+func handleFromPtr_scrypted_arlo_go_AuthHeader(p interface{}) CGoHandle {
+	return CGoHandle(gopyh.Register("scrypted_arlo_go.AuthHeader", p))
+}
+
+// Converters for implicit pointer handles for type: scrypted_arlo_go.HeadersMap
+func ptrFromHandle_scrypted_arlo_go_HeadersMap(h CGoHandle) *scrypted_arlo_go.HeadersMap {
+	p := gopyh.VarFromHandle((gopyh.CGoHandle)(h), "scrypted_arlo_go.HeadersMap")
+	if p == nil {
+		return nil
+	}
+	return p.(*scrypted_arlo_go.HeadersMap)
+}
+func deptrFromHandle_scrypted_arlo_go_HeadersMap(h CGoHandle) scrypted_arlo_go.HeadersMap {
+	p := ptrFromHandle_scrypted_arlo_go_HeadersMap(h)
+	if p == nil {
+		return nil
+	}
+	return *p
+}
+func handleFromPtr_scrypted_arlo_go_HeadersMap(p interface{}) CGoHandle {
+	return CGoHandle(gopyh.Register("scrypted_arlo_go.HeadersMap", p))
+}
+
+// Converters for non-pointer handles for type: scrypted_arlo_go.KeysOutput
+func ptrFromHandle_scrypted_arlo_go_KeysOutput(h CGoHandle) *scrypted_arlo_go.KeysOutput {
+	p := gopyh.VarFromHandle((gopyh.CGoHandle)(h), "scrypted_arlo_go.KeysOutput")
+	if p == nil {
+		return nil
+	}
+	return gopyh.Embed(p, reflect.TypeOf(scrypted_arlo_go.KeysOutput{})).(*scrypted_arlo_go.KeysOutput)
+}
+func handleFromPtr_scrypted_arlo_go_KeysOutput(p interface{}) CGoHandle {
+	return CGoHandle(gopyh.Register("scrypted_arlo_go.KeysOutput", p))
+}
+
+// Converters for non-pointer handles for type: scrypted_arlo_go.LocalStreamProxy
+func ptrFromHandle_scrypted_arlo_go_LocalStreamProxy(h CGoHandle) *scrypted_arlo_go.LocalStreamProxy {
+	p := gopyh.VarFromHandle((gopyh.CGoHandle)(h), "scrypted_arlo_go.LocalStreamProxy")
+	if p == nil {
+		return nil
+	}
+	return gopyh.Embed(p, reflect.TypeOf(scrypted_arlo_go.LocalStreamProxy{})).(*scrypted_arlo_go.LocalStreamProxy)
+}
+func handleFromPtr_scrypted_arlo_go_LocalStreamProxy(p interface{}) CGoHandle {
+	return CGoHandle(gopyh.Register("scrypted_arlo_go.LocalStreamProxy", p))
+}
+
+// Converters for non-pointer handles for type: scrypted_arlo_go.SIPInfo
+func ptrFromHandle_scrypted_arlo_go_SIPInfo(h CGoHandle) *scrypted_arlo_go.SIPInfo {
+	p := gopyh.VarFromHandle((gopyh.CGoHandle)(h), "scrypted_arlo_go.SIPInfo")
+	if p == nil {
+		return nil
+	}
+	return gopyh.Embed(p, reflect.TypeOf(scrypted_arlo_go.SIPInfo{})).(*scrypted_arlo_go.SIPInfo)
+}
+func handleFromPtr_scrypted_arlo_go_SIPInfo(p interface{}) CGoHandle {
+	return CGoHandle(gopyh.Register("scrypted_arlo_go.SIPInfo", p))
+}
+
+// Converters for non-pointer handles for type: scrypted_arlo_go.SIPWebRTCManager
+func ptrFromHandle_scrypted_arlo_go_SIPWebRTCManager(h CGoHandle) *scrypted_arlo_go.SIPWebRTCManager {
+	p := gopyh.VarFromHandle((gopyh.CGoHandle)(h), "scrypted_arlo_go.SIPWebRTCManager")
+	if p == nil {
+		return nil
+	}
+	return gopyh.Embed(p, reflect.TypeOf(scrypted_arlo_go.SIPWebRTCManager{})).(*scrypted_arlo_go.SIPWebRTCManager)
+}
+func handleFromPtr_scrypted_arlo_go_SIPWebRTCManager(p interface{}) CGoHandle {
+	return CGoHandle(gopyh.Register("scrypted_arlo_go.SIPWebRTCManager", p))
+}
+
+// Converters for non-pointer handles for type: scrypted_arlo_go.SSEClient
+func ptrFromHandle_scrypted_arlo_go_SSEClient(h CGoHandle) *scrypted_arlo_go.SSEClient {
+	p := gopyh.VarFromHandle((gopyh.CGoHandle)(h), "scrypted_arlo_go.SSEClient")
+	if p == nil {
+		return nil
+	}
+	return gopyh.Embed(p, reflect.TypeOf(scrypted_arlo_go.SSEClient{})).(*scrypted_arlo_go.SSEClient)
+}
+func handleFromPtr_scrypted_arlo_go_SSEClient(p interface{}) CGoHandle {
+	return CGoHandle(gopyh.Register("scrypted_arlo_go.SSEClient", p))
+}
+
+// Converters for non-pointer handles for type: scrypted_arlo_go.TCPLogger
+func ptrFromHandle_scrypted_arlo_go_TCPLogger(h CGoHandle) *scrypted_arlo_go.TCPLogger {
+	p := gopyh.VarFromHandle((gopyh.CGoHandle)(h), "scrypted_arlo_go.TCPLogger")
+	if p == nil {
+		return nil
+	}
+	return gopyh.Embed(p, reflect.TypeOf(scrypted_arlo_go.TCPLogger{})).(*scrypted_arlo_go.TCPLogger)
+}
+func handleFromPtr_scrypted_arlo_go_TCPLogger(p interface{}) CGoHandle {
+	return CGoHandle(gopyh.Register("scrypted_arlo_go.TCPLogger", p))
+}
+
+// Converters for non-pointer handles for type: scrypted_arlo_go.WebRTCManager
+func ptrFromHandle_scrypted_arlo_go_WebRTCManager(h CGoHandle) *scrypted_arlo_go.WebRTCManager {
+	p := gopyh.VarFromHandle((gopyh.CGoHandle)(h), "scrypted_arlo_go.WebRTCManager")
+	if p == nil {
+		return nil
+	}
+	return gopyh.Embed(p, reflect.TypeOf(scrypted_arlo_go.WebRTCManager{})).(*scrypted_arlo_go.WebRTCManager)
+}
+func handleFromPtr_scrypted_arlo_go_WebRTCManager(p interface{}) CGoHandle {
+	return CGoHandle(gopyh.Register("scrypted_arlo_go.WebRTCManager", p))
+}
+
+// ---- Global Variables: can only use functions to access ---
+//
+//export scrypted_arlo_go_DEBUG
+func scrypted_arlo_go_DEBUG() C.char {
+	return boolGoToPy(scrypted_arlo_go.DEBUG)
+}
+
+//export scrypted_arlo_go_Set_DEBUG
+func scrypted_arlo_go_Set_DEBUG(val C.char) {
+	scrypted_arlo_go.DEBUG = boolPyToGo(val)
+}
+
+//export scrypted_arlo_go_UDP_PACKET_SIZE
+func scrypted_arlo_go_UDP_PACKET_SIZE() C.longlong {
+	return C.longlong(scrypted_arlo_go.UDP_PACKET_SIZE)
+}
+
+//export scrypted_arlo_go_Set_UDP_PACKET_SIZE
+func scrypted_arlo_go_Set_UDP_PACKET_SIZE(val C.longlong) {
+	scrypted_arlo_go.UDP_PACKET_SIZE = int(val)
+}
+
+// ---- Interfaces ---
+
+// ---- Structs ---
+
+// --- wrapping struct: webrtc.ICECandidate ---
+//
+//export webrtc_ICECandidate_CTor
+func webrtc_ICECandidate_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_webrtc_ICECandidate(&webrtc.ICECandidate{}))
+}
+
+//export webrtc_ICECandidate_Foundation_Get
+func webrtc_ICECandidate_Foundation_Get(handle CGoHandle) *C.char {
+	op := ptrFromHandle_webrtc_ICECandidate(handle)
+	return C.CString(op.Foundation)
+}
+
+//export webrtc_ICECandidate_Foundation_Set
+func webrtc_ICECandidate_Foundation_Set(handle CGoHandle, val *C.char) {
+	op := ptrFromHandle_webrtc_ICECandidate(handle)
+	op.Foundation = C.GoString(val)
+}
+
+//export webrtc_ICECandidate_Priority_Get
+func webrtc_ICECandidate_Priority_Get(handle CGoHandle) C.ulong {
+	op := ptrFromHandle_webrtc_ICECandidate(handle)
+	return C.ulong(op.Priority)
+}
+
+//export webrtc_ICECandidate_Priority_Set
+func webrtc_ICECandidate_Priority_Set(handle CGoHandle, val C.ulong) {
+	op := ptrFromHandle_webrtc_ICECandidate(handle)
+	op.Priority = uint32(val)
+}
+
+//export webrtc_ICECandidate_Address_Get
+func webrtc_ICECandidate_Address_Get(handle CGoHandle) *C.char {
+	op := ptrFromHandle_webrtc_ICECandidate(handle)
+	return C.CString(op.Address)
+}
+
+//export webrtc_ICECandidate_Address_Set
+func webrtc_ICECandidate_Address_Set(handle CGoHandle, val *C.char) {
+	op := ptrFromHandle_webrtc_ICECandidate(handle)
+	op.Address = C.GoString(val)
+}
+
+//export webrtc_ICECandidate_Protocol_Get
+func webrtc_ICECandidate_Protocol_Get(handle CGoHandle) C.longlong {
+	op := ptrFromHandle_webrtc_ICECandidate(handle)
+	return C.longlong(int(op.Protocol))
+}
+
+//export webrtc_ICECandidate_Protocol_Set
+func webrtc_ICECandidate_Protocol_Set(handle CGoHandle, val C.longlong) {
+	op := ptrFromHandle_webrtc_ICECandidate(handle)
+	op.Protocol = webrtc.ICEProtocol(int(val))
+}
+
+//export webrtc_ICECandidate_Port_Get
+func webrtc_ICECandidate_Port_Get(handle CGoHandle) C.ushort {
+	op := ptrFromHandle_webrtc_ICECandidate(handle)
+	return C.ushort(op.Port)
+}
+
+//export webrtc_ICECandidate_Port_Set
+func webrtc_ICECandidate_Port_Set(handle CGoHandle, val C.ushort) {
+	op := ptrFromHandle_webrtc_ICECandidate(handle)
+	op.Port = uint16(val)
+}
+
+//export webrtc_ICECandidate_Typ_Get
+func webrtc_ICECandidate_Typ_Get(handle CGoHandle) C.longlong {
+	op := ptrFromHandle_webrtc_ICECandidate(handle)
+	return C.longlong(int(op.Typ))
+}
+
+//export webrtc_ICECandidate_Typ_Set
+func webrtc_ICECandidate_Typ_Set(handle CGoHandle, val C.longlong) {
+	op := ptrFromHandle_webrtc_ICECandidate(handle)
+	op.Typ = webrtc.ICECandidateType(int(val))
+}
+
+//export webrtc_ICECandidate_Component_Get
+func webrtc_ICECandidate_Component_Get(handle CGoHandle) C.ushort {
+	op := ptrFromHandle_webrtc_ICECandidate(handle)
+	return C.ushort(op.Component)
+}
+
+//export webrtc_ICECandidate_Component_Set
+func webrtc_ICECandidate_Component_Set(handle CGoHandle, val C.ushort) {
+	op := ptrFromHandle_webrtc_ICECandidate(handle)
+	op.Component = uint16(val)
+}
+
+//export webrtc_ICECandidate_RelatedAddress_Get
+func webrtc_ICECandidate_RelatedAddress_Get(handle CGoHandle) *C.char {
+	op := ptrFromHandle_webrtc_ICECandidate(handle)
+	return C.CString(op.RelatedAddress)
+}
+
+//export webrtc_ICECandidate_RelatedAddress_Set
+func webrtc_ICECandidate_RelatedAddress_Set(handle CGoHandle, val *C.char) {
+	op := ptrFromHandle_webrtc_ICECandidate(handle)
+	op.RelatedAddress = C.GoString(val)
+}
+
+//export webrtc_ICECandidate_RelatedPort_Get
+func webrtc_ICECandidate_RelatedPort_Get(handle CGoHandle) C.ushort {
+	op := ptrFromHandle_webrtc_ICECandidate(handle)
+	return C.ushort(op.RelatedPort)
+}
+
+//export webrtc_ICECandidate_RelatedPort_Set
+func webrtc_ICECandidate_RelatedPort_Set(handle CGoHandle, val C.ushort) {
+	op := ptrFromHandle_webrtc_ICECandidate(handle)
+	op.RelatedPort = uint16(val)
+}
+
+//export webrtc_ICECandidate_TCPType_Get
+func webrtc_ICECandidate_TCPType_Get(handle CGoHandle) *C.char {
+	op := ptrFromHandle_webrtc_ICECandidate(handle)
+	return C.CString(op.TCPType)
+}
+
+//export webrtc_ICECandidate_TCPType_Set
+func webrtc_ICECandidate_TCPType_Set(handle CGoHandle, val *C.char) {
+	op := ptrFromHandle_webrtc_ICECandidate(handle)
+	op.TCPType = C.GoString(val)
+}
+
+//export webrtc_ICECandidate_String
+func webrtc_ICECandidate_String(_handle CGoHandle) *C.char {
+	_saved_thread := C.PyEval_SaveThread()
+	defer C.PyEval_RestoreThread(_saved_thread)
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*webrtc.ICECandidate")
+	if __err != nil {
+		return C.CString("")
+	}
+	return C.CString(gopyh.Embed(vifc, reflect.TypeOf(webrtc.ICECandidate{})).(*webrtc.ICECandidate).String())
+
+}
+
+//export webrtc_ICECandidate_ToJSON
+func webrtc_ICECandidate_ToJSON(_handle CGoHandle) CGoHandle {
+	_saved_thread := C.PyEval_SaveThread()
+	defer C.PyEval_RestoreThread(_saved_thread)
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*webrtc.ICECandidate")
+	if __err != nil {
+		return handleFromPtr_webrtc_ICECandidateInit(nil)
+	}
+	cret := gopyh.Embed(vifc, reflect.TypeOf(webrtc.ICECandidate{})).(*webrtc.ICECandidate).ToJSON()
+
+	return handleFromPtr_webrtc_ICECandidateInit(&cret)
+}
+
+// --- wrapping struct: webrtc.ICEServer ---
+//
+//export webrtc_ICEServer_CTor
+func webrtc_ICEServer_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_webrtc_ICEServer(&webrtc.ICEServer{}))
+}
+
+//export webrtc_ICEServer_URLs_Get
+func webrtc_ICEServer_URLs_Get(handle CGoHandle) CGoHandle {
+	op := ptrFromHandle_webrtc_ICEServer(handle)
+	return handleFromPtr_Slice_string(&op.URLs)
+}
+
+//export webrtc_ICEServer_URLs_Set
+func webrtc_ICEServer_URLs_Set(handle CGoHandle, val CGoHandle) {
+	op := ptrFromHandle_webrtc_ICEServer(handle)
+	op.URLs = deptrFromHandle_Slice_string(val)
+}
+
+//export webrtc_ICEServer_Username_Get
+func webrtc_ICEServer_Username_Get(handle CGoHandle) *C.char {
+	op := ptrFromHandle_webrtc_ICEServer(handle)
+	return C.CString(op.Username)
+}
+
+//export webrtc_ICEServer_Username_Set
+func webrtc_ICEServer_Username_Set(handle CGoHandle, val *C.char) {
+	op := ptrFromHandle_webrtc_ICEServer(handle)
+	op.Username = C.GoString(val)
+}
+
+//export webrtc_ICEServer_CredentialType_Get
+func webrtc_ICEServer_CredentialType_Get(handle CGoHandle) C.longlong {
+	op := ptrFromHandle_webrtc_ICEServer(handle)
+	return C.longlong(int(op.CredentialType))
+}
+
+//export webrtc_ICEServer_CredentialType_Set
+func webrtc_ICEServer_CredentialType_Set(handle CGoHandle, val C.longlong) {
+	op := ptrFromHandle_webrtc_ICEServer(handle)
+	op.CredentialType = webrtc.ICECredentialType(int(val))
+}
+
+//export webrtc_ICEServer_UnmarshalJSON
+func webrtc_ICEServer_UnmarshalJSON(_handle CGoHandle, b CGoHandle) *C.char {
+	_saved_thread := C.PyEval_SaveThread()
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*webrtc.ICEServer")
+	if __err != nil {
+		return errorGoToPy(nil)
+	}
+	__err = gopyh.Embed(vifc, reflect.TypeOf(webrtc.ICEServer{})).(*webrtc.ICEServer).UnmarshalJSON(deptrFromHandle_Slice_byte(b))
+
+	C.PyEval_RestoreThread(_saved_thread)
+	if __err != nil {
+		estr := C.CString(__err.Error())
+		C.PyErr_SetString(C.PyExc_RuntimeError, estr)
+		return estr
+	}
+	return C.CString("")
+}
+
+//export webrtc_ICEServer_MarshalJSON
+func webrtc_ICEServer_MarshalJSON(_handle CGoHandle) CGoHandle {
+	_saved_thread := C.PyEval_SaveThread()
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*webrtc.ICEServer")
+	if __err != nil {
+		return handleFromPtr_Slice_byte(nil)
+	}
+	cret, __err := gopyh.Embed(vifc, reflect.TypeOf(webrtc.ICEServer{})).(*webrtc.ICEServer).MarshalJSON()
+
+	C.PyEval_RestoreThread(_saved_thread)
+	if __err != nil {
+		estr := C.CString(__err.Error())
+		C.PyErr_SetString(C.PyExc_RuntimeError, estr)
+		C.free(unsafe.Pointer(estr))
+		return handleFromPtr_Slice_byte(nil)
+	}
+	return handleFromPtr_Slice_byte(&cret)
+}
+
+// --- wrapping struct: webrtc.SessionDescription ---
+//
+//export webrtc_SessionDescription_CTor
+func webrtc_SessionDescription_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_webrtc_SessionDescription(&webrtc.SessionDescription{}))
+}
+
+//export webrtc_SessionDescription_Type_Get
+func webrtc_SessionDescription_Type_Get(handle CGoHandle) C.longlong {
+	op := ptrFromHandle_webrtc_SessionDescription(handle)
+	return C.longlong(int(op.Type))
+}
+
+//export webrtc_SessionDescription_Type_Set
+func webrtc_SessionDescription_Type_Set(handle CGoHandle, val C.longlong) {
+	op := ptrFromHandle_webrtc_SessionDescription(handle)
+	op.Type = webrtc.SDPType(int(val))
+}
+
+//export webrtc_SessionDescription_SDP_Get
+func webrtc_SessionDescription_SDP_Get(handle CGoHandle) *C.char {
+	op := ptrFromHandle_webrtc_SessionDescription(handle)
+	return C.CString(op.SDP)
+}
+
+//export webrtc_SessionDescription_SDP_Set
+func webrtc_SessionDescription_SDP_Set(handle CGoHandle, val *C.char) {
+	op := ptrFromHandle_webrtc_SessionDescription(handle)
+	op.SDP = C.GoString(val)
+}
+
+//export webrtc_SessionDescription_Unmarshal
+func webrtc_SessionDescription_Unmarshal(_handle CGoHandle) CGoHandle {
+	_saved_thread := C.PyEval_SaveThread()
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*webrtc.SessionDescription")
+	if __err != nil {
+		return handleFromPtr_Ptr_sdp_SessionDescription(nil)
+	}
+	cret, __err := gopyh.Embed(vifc, reflect.TypeOf(webrtc.SessionDescription{})).(*webrtc.SessionDescription).Unmarshal()
+
+	C.PyEval_RestoreThread(_saved_thread)
+	if __err != nil {
+		estr := C.CString(__err.Error())
+		C.PyErr_SetString(C.PyExc_RuntimeError, estr)
+		C.free(unsafe.Pointer(estr))
+		return handleFromPtr_Ptr_sdp_SessionDescription(nil)
+	}
+	return handleFromPtr_Ptr_sdp_SessionDescription(cret)
+}
+
+// --- wrapping struct: scrypted_arlo_go.AuthHeader ---
+//
+//export scrypted_arlo_go_AuthHeader_CTor
+func scrypted_arlo_go_AuthHeader_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_scrypted_arlo_go_AuthHeader(&scrypted_arlo_go.AuthHeader{}))
+}
+
+//export scrypted_arlo_go_AuthHeader_Mode_Get
+func scrypted_arlo_go_AuthHeader_Mode_Get(handle CGoHandle) *C.char {
+	op := ptrFromHandle_scrypted_arlo_go_AuthHeader(handle)
+	return C.CString(op.Mode)
+}
+
+//export scrypted_arlo_go_AuthHeader_Mode_Set
+func scrypted_arlo_go_AuthHeader_Mode_Set(handle CGoHandle, val *C.char) {
+	op := ptrFromHandle_scrypted_arlo_go_AuthHeader(handle)
+	op.Mode = C.GoString(val)
+}
+
+//export scrypted_arlo_go_AuthHeader_Params_Get
+func scrypted_arlo_go_AuthHeader_Params_Get(handle CGoHandle) CGoHandle {
+	op := ptrFromHandle_scrypted_arlo_go_AuthHeader(handle)
+	return handleFromPtr_Map_string_string(&op.Params)
+}
+
+//export scrypted_arlo_go_AuthHeader_Params_Set
+func scrypted_arlo_go_AuthHeader_Params_Set(handle CGoHandle, val CGoHandle) {
+	op := ptrFromHandle_scrypted_arlo_go_AuthHeader(handle)
+	op.Params = deptrFromHandle_Map_string_string(val)
+}
+
+//export scrypted_arlo_go_AuthHeader_UpdateResponseDigest
+func scrypted_arlo_go_AuthHeader_UpdateResponseDigest(_handle CGoHandle, method *C.char, password *C.char) *C.char {
+	_saved_thread := C.PyEval_SaveThread()
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*scrypted_arlo_go.AuthHeader")
+	if __err != nil {
+		return errorGoToPy(nil)
+	}
+	__err = gopyh.Embed(vifc, reflect.TypeOf(scrypted_arlo_go.AuthHeader{})).(*scrypted_arlo_go.AuthHeader).UpdateResponseDigest(C.GoString(method), C.GoString(password))
+
+	C.PyEval_RestoreThread(_saved_thread)
+	if __err != nil {
+		estr := C.CString(__err.Error())
+		C.PyErr_SetString(C.PyExc_RuntimeError, estr)
+		return estr
+	}
+	return C.CString("")
+}
+
+//export scrypted_arlo_go_AuthHeader_String
+func scrypted_arlo_go_AuthHeader_String(_handle CGoHandle) *C.char {
+	_saved_thread := C.PyEval_SaveThread()
+	defer C.PyEval_RestoreThread(_saved_thread)
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*scrypted_arlo_go.AuthHeader")
+	if __err != nil {
+		return C.CString("")
+	}
+	return C.CString(gopyh.Embed(vifc, reflect.TypeOf(scrypted_arlo_go.AuthHeader{})).(*scrypted_arlo_go.AuthHeader).String())
+
+}
+
+// --- wrapping struct: scrypted_arlo_go.SIPInfo ---
+//
+//export scrypted_arlo_go_SIPInfo_CTor
+func scrypted_arlo_go_SIPInfo_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_scrypted_arlo_go_SIPInfo(&scrypted_arlo_go.SIPInfo{}))
+}
+
+//export scrypted_arlo_go_SIPInfo_DeviceID_Get
+func scrypted_arlo_go_SIPInfo_DeviceID_Get(handle CGoHandle) *C.char {
+	op := ptrFromHandle_scrypted_arlo_go_SIPInfo(handle)
+	return C.CString(op.DeviceID)
+}
+
+//export scrypted_arlo_go_SIPInfo_DeviceID_Set
+func scrypted_arlo_go_SIPInfo_DeviceID_Set(handle CGoHandle, val *C.char) {
+	op := ptrFromHandle_scrypted_arlo_go_SIPInfo(handle)
+	op.DeviceID = C.GoString(val)
+}
+
+//export scrypted_arlo_go_SIPInfo_CallerURI_Get
+func scrypted_arlo_go_SIPInfo_CallerURI_Get(handle CGoHandle) *C.char {
+	op := ptrFromHandle_scrypted_arlo_go_SIPInfo(handle)
+	return C.CString(op.CallerURI)
+}
+
+//export scrypted_arlo_go_SIPInfo_CallerURI_Set
+func scrypted_arlo_go_SIPInfo_CallerURI_Set(handle CGoHandle, val *C.char) {
+	op := ptrFromHandle_scrypted_arlo_go_SIPInfo(handle)
+	op.CallerURI = C.GoString(val)
+}
+
+//export scrypted_arlo_go_SIPInfo_CalleeURI_Get
+func scrypted_arlo_go_SIPInfo_CalleeURI_Get(handle CGoHandle) *C.char {
+	op := ptrFromHandle_scrypted_arlo_go_SIPInfo(handle)
+	return C.CString(op.CalleeURI)
+}
+
+//export scrypted_arlo_go_SIPInfo_CalleeURI_Set
+func scrypted_arlo_go_SIPInfo_CalleeURI_Set(handle CGoHandle, val *C.char) {
+	op := ptrFromHandle_scrypted_arlo_go_SIPInfo(handle)
+	op.CalleeURI = C.GoString(val)
+}
+
+//export scrypted_arlo_go_SIPInfo_Password_Get
+func scrypted_arlo_go_SIPInfo_Password_Get(handle CGoHandle) *C.char {
+	op := ptrFromHandle_scrypted_arlo_go_SIPInfo(handle)
+	return C.CString(op.Password)
+}
+
+//export scrypted_arlo_go_SIPInfo_Password_Set
+func scrypted_arlo_go_SIPInfo_Password_Set(handle CGoHandle, val *C.char) {
+	op := ptrFromHandle_scrypted_arlo_go_SIPInfo(handle)
+	op.Password = C.GoString(val)
+}
+
+//export scrypted_arlo_go_SIPInfo_UserAgent_Get
+func scrypted_arlo_go_SIPInfo_UserAgent_Get(handle CGoHandle) *C.char {
+	op := ptrFromHandle_scrypted_arlo_go_SIPInfo(handle)
+	return C.CString(op.UserAgent)
+}
+
+//export scrypted_arlo_go_SIPInfo_UserAgent_Set
+func scrypted_arlo_go_SIPInfo_UserAgent_Set(handle CGoHandle, val *C.char) {
+	op := ptrFromHandle_scrypted_arlo_go_SIPInfo(handle)
+	op.UserAgent = C.GoString(val)
+}
+
+//export scrypted_arlo_go_SIPInfo_WebsocketURI_Get
+func scrypted_arlo_go_SIPInfo_WebsocketURI_Get(handle CGoHandle) *C.char {
+	op := ptrFromHandle_scrypted_arlo_go_SIPInfo(handle)
+	return C.CString(op.WebsocketURI)
+}
+
+//export scrypted_arlo_go_SIPInfo_WebsocketURI_Set
+func scrypted_arlo_go_SIPInfo_WebsocketURI_Set(handle CGoHandle, val *C.char) {
+	op := ptrFromHandle_scrypted_arlo_go_SIPInfo(handle)
+	op.WebsocketURI = C.GoString(val)
+}
+
+//export scrypted_arlo_go_SIPInfo_WebsocketHeaders_Get
+func scrypted_arlo_go_SIPInfo_WebsocketHeaders_Get(handle CGoHandle) CGoHandle {
+	op := ptrFromHandle_scrypted_arlo_go_SIPInfo(handle)
+	return handleFromPtr_scrypted_arlo_go_HeadersMap(&op.WebsocketHeaders)
+}
+
+//export scrypted_arlo_go_SIPInfo_WebsocketHeaders_Set
+func scrypted_arlo_go_SIPInfo_WebsocketHeaders_Set(handle CGoHandle, val CGoHandle) {
+	op := ptrFromHandle_scrypted_arlo_go_SIPInfo(handle)
+	op.WebsocketHeaders = deptrFromHandle_scrypted_arlo_go_HeadersMap(val)
+}
+
+//export scrypted_arlo_go_SIPInfo_WebsocketOrigin_Get
+func scrypted_arlo_go_SIPInfo_WebsocketOrigin_Get(handle CGoHandle) *C.char {
+	op := ptrFromHandle_scrypted_arlo_go_SIPInfo(handle)
+	return C.CString(op.WebsocketOrigin)
+}
+
+//export scrypted_arlo_go_SIPInfo_WebsocketOrigin_Set
+func scrypted_arlo_go_SIPInfo_WebsocketOrigin_Set(handle CGoHandle, val *C.char) {
+	op := ptrFromHandle_scrypted_arlo_go_SIPInfo(handle)
+	op.WebsocketOrigin = C.GoString(val)
+}
+
+//export scrypted_arlo_go_SIPInfo_SDP_Get
+func scrypted_arlo_go_SIPInfo_SDP_Get(handle CGoHandle) *C.char {
+	op := ptrFromHandle_scrypted_arlo_go_SIPInfo(handle)
+	return C.CString(op.SDP)
+}
+
+//export scrypted_arlo_go_SIPInfo_SDP_Set
+func scrypted_arlo_go_SIPInfo_SDP_Set(handle CGoHandle, val *C.char) {
+	op := ptrFromHandle_scrypted_arlo_go_SIPInfo(handle)
+	op.SDP = C.GoString(val)
+}
+
+// --- wrapping struct: scrypted_arlo_go.SSEClient ---
+//
+//export scrypted_arlo_go_SSEClient_CTor
+func scrypted_arlo_go_SSEClient_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_scrypted_arlo_go_SSEClient(&scrypted_arlo_go.SSEClient{}))
+}
+
+//export scrypted_arlo_go_SSEClient_UUID_Get
+func scrypted_arlo_go_SSEClient_UUID_Get(handle CGoHandle) *C.char {
+	op := ptrFromHandle_scrypted_arlo_go_SSEClient(handle)
+	return C.CString(op.UUID)
+}
+
+//export scrypted_arlo_go_SSEClient_UUID_Set
+func scrypted_arlo_go_SSEClient_UUID_Set(handle CGoHandle, val *C.char) {
+	op := ptrFromHandle_scrypted_arlo_go_SSEClient(handle)
+	op.UUID = C.GoString(val)
+}
+
+//export scrypted_arlo_go_SSEClient_Start
+func scrypted_arlo_go_SSEClient_Start(_handle CGoHandle, goRun C.char) {
+	_saved_thread := C.PyEval_SaveThread()
+	defer C.PyEval_RestoreThread(_saved_thread)
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*scrypted_arlo_go.SSEClient")
+	if __err != nil {
+		return
+	}
+	if boolPyToGo(goRun) {
+		go gopyh.Embed(vifc, reflect.TypeOf(scrypted_arlo_go.SSEClient{})).(*scrypted_arlo_go.SSEClient).Start()
+	} else {
+		gopyh.Embed(vifc, reflect.TypeOf(scrypted_arlo_go.SSEClient{})).(*scrypted_arlo_go.SSEClient).Start()
+	}
+}
+
+//export scrypted_arlo_go_SSEClient_Next
+func scrypted_arlo_go_SSEClient_Next(_handle CGoHandle) *C.char {
+	_saved_thread := C.PyEval_SaveThread()
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*scrypted_arlo_go.SSEClient")
+	if __err != nil {
+		return C.CString("")
+	}
+	cret, __err := gopyh.Embed(vifc, reflect.TypeOf(scrypted_arlo_go.SSEClient{})).(*scrypted_arlo_go.SSEClient).Next()
+
+	C.PyEval_RestoreThread(_saved_thread)
+	if __err != nil {
+		estr := C.CString(__err.Error())
+		C.PyErr_SetString(C.PyExc_RuntimeError, estr)
+		C.free(unsafe.Pointer(estr))
+		return C.CString("")
+	}
+	return C.CString(cret)
+}
+
+//export scrypted_arlo_go_SSEClient_Close
+func scrypted_arlo_go_SSEClient_Close(_handle CGoHandle, goRun C.char) {
+	_saved_thread := C.PyEval_SaveThread()
+	defer C.PyEval_RestoreThread(_saved_thread)
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*scrypted_arlo_go.SSEClient")
+	if __err != nil {
+		return
+	}
+	if boolPyToGo(goRun) {
+		go gopyh.Embed(vifc, reflect.TypeOf(scrypted_arlo_go.SSEClient{})).(*scrypted_arlo_go.SSEClient).Close()
+	} else {
+		gopyh.Embed(vifc, reflect.TypeOf(scrypted_arlo_go.SSEClient{})).(*scrypted_arlo_go.SSEClient).Close()
+	}
+}
+
+// --- wrapping struct: scrypted_arlo_go.TCPLogger ---
+//
+//export scrypted_arlo_go_TCPLogger_CTor
+func scrypted_arlo_go_TCPLogger_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_scrypted_arlo_go_TCPLogger(&scrypted_arlo_go.TCPLogger{}))
+}
+
+//export scrypted_arlo_go_TCPLogger_Send
+func scrypted_arlo_go_TCPLogger_Send(_handle CGoHandle, s *C.char, goRun C.char) {
+	_saved_thread := C.PyEval_SaveThread()
+	defer C.PyEval_RestoreThread(_saved_thread)
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*scrypted_arlo_go.TCPLogger")
+	if __err != nil {
+		return
+	}
+	if boolPyToGo(goRun) {
+		go gopyh.Embed(vifc, reflect.TypeOf(scrypted_arlo_go.TCPLogger{})).(*scrypted_arlo_go.TCPLogger).Send(C.GoString(s))
+	} else {
+		gopyh.Embed(vifc, reflect.TypeOf(scrypted_arlo_go.TCPLogger{})).(*scrypted_arlo_go.TCPLogger).Send(C.GoString(s))
+	}
+}
+
+//export scrypted_arlo_go_TCPLogger_Write
+func scrypted_arlo_go_TCPLogger_Write(_handle CGoHandle, p CGoHandle) C.longlong {
+	_saved_thread := C.PyEval_SaveThread()
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*scrypted_arlo_go.TCPLogger")
+	if __err != nil {
+		return C.longlong(0)
+	}
+	cret, __err := gopyh.Embed(vifc, reflect.TypeOf(scrypted_arlo_go.TCPLogger{})).(*scrypted_arlo_go.TCPLogger).Write(deptrFromHandle_Slice_byte(p))
+
+	C.PyEval_RestoreThread(_saved_thread)
+	if __err != nil {
+		estr := C.CString(__err.Error())
+		C.PyErr_SetString(C.PyExc_RuntimeError, estr)
+		C.free(unsafe.Pointer(estr))
+		return C.longlong(0)
+	}
+	return C.longlong(cret)
+}
+
+//export scrypted_arlo_go_TCPLogger_Close
+func scrypted_arlo_go_TCPLogger_Close(_handle CGoHandle, goRun C.char) {
+	_saved_thread := C.PyEval_SaveThread()
+	defer C.PyEval_RestoreThread(_saved_thread)
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*scrypted_arlo_go.TCPLogger")
+	if __err != nil {
+		return
+	}
+	if boolPyToGo(goRun) {
+		go gopyh.Embed(vifc, reflect.TypeOf(scrypted_arlo_go.TCPLogger{})).(*scrypted_arlo_go.TCPLogger).Close()
+	} else {
+		gopyh.Embed(vifc, reflect.TypeOf(scrypted_arlo_go.TCPLogger{})).(*scrypted_arlo_go.TCPLogger).Close()
+	}
+}
+
+// --- wrapping struct: scrypted_arlo_go.WebRTCManager ---
+//
+//export scrypted_arlo_go_WebRTCManager_CTor
+func scrypted_arlo_go_WebRTCManager_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_scrypted_arlo_go_WebRTCManager(&scrypted_arlo_go.WebRTCManager{}))
+}
+
+//export scrypted_arlo_go_WebRTCManager_Info
+func scrypted_arlo_go_WebRTCManager_Info(_handle CGoHandle, msg *C.char, args CGoHandle, goRun C.char) {
+	_saved_thread := C.PyEval_SaveThread()
+	defer C.PyEval_RestoreThread(_saved_thread)
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*scrypted_arlo_go.WebRTCManager")
+	if __err != nil {
+		return
+	}
+	if boolPyToGo(goRun) {
+		go gopyh.Embed(vifc, reflect.TypeOf(scrypted_arlo_go.WebRTCManager{})).(*scrypted_arlo_go.WebRTCManager).Info(C.GoString(msg), deptrFromHandle_Slice_any(args)...)
+	} else {
+		gopyh.Embed(vifc, reflect.TypeOf(scrypted_arlo_go.WebRTCManager{})).(*scrypted_arlo_go.WebRTCManager).Info(C.GoString(msg), deptrFromHandle_Slice_any(args)...)
+	}
+}
+
+//export scrypted_arlo_go_WebRTCManager_Debug
+func scrypted_arlo_go_WebRTCManager_Debug(_handle CGoHandle, msg *C.char, args CGoHandle, goRun C.char) {
+	_saved_thread := C.PyEval_SaveThread()
+	defer C.PyEval_RestoreThread(_saved_thread)
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*scrypted_arlo_go.WebRTCManager")
+	if __err != nil {
+		return
+	}
+	if boolPyToGo(goRun) {
+		go gopyh.Embed(vifc, reflect.TypeOf(scrypted_arlo_go.WebRTCManager{})).(*scrypted_arlo_go.WebRTCManager).Debug(C.GoString(msg), deptrFromHandle_Slice_any(args)...)
+	} else {
+		gopyh.Embed(vifc, reflect.TypeOf(scrypted_arlo_go.WebRTCManager{})).(*scrypted_arlo_go.WebRTCManager).Debug(C.GoString(msg), deptrFromHandle_Slice_any(args)...)
+	}
+}
+
+//export scrypted_arlo_go_WebRTCManager_PrintTimeSinceCreation
+func scrypted_arlo_go_WebRTCManager_PrintTimeSinceCreation(_handle CGoHandle, goRun C.char) {
+	_saved_thread := C.PyEval_SaveThread()
+	defer C.PyEval_RestoreThread(_saved_thread)
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*scrypted_arlo_go.WebRTCManager")
+	if __err != nil {
+		return
+	}
+	if boolPyToGo(goRun) {
+		go gopyh.Embed(vifc, reflect.TypeOf(scrypted_arlo_go.WebRTCManager{})).(*scrypted_arlo_go.WebRTCManager).PrintTimeSinceCreation()
+	} else {
+		gopyh.Embed(vifc, reflect.TypeOf(scrypted_arlo_go.WebRTCManager{})).(*scrypted_arlo_go.WebRTCManager).PrintTimeSinceCreation()
+	}
+}
+
+//export scrypted_arlo_go_WebRTCManager_InitializeAudioRTPListener
+func scrypted_arlo_go_WebRTCManager_InitializeAudioRTPListener(_handle CGoHandle, codecMimeType *C.char) C.longlong {
+	_saved_thread := C.PyEval_SaveThread()
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*scrypted_arlo_go.WebRTCManager")
+	if __err != nil {
+		return C.longlong(0)
+	}
+	cret, __err := gopyh.Embed(vifc, reflect.TypeOf(scrypted_arlo_go.WebRTCManager{})).(*scrypted_arlo_go.WebRTCManager).InitializeAudioRTPListener(C.GoString(codecMimeType))
+
+	C.PyEval_RestoreThread(_saved_thread)
+	if __err != nil {
+		estr := C.CString(__err.Error())
+		C.PyErr_SetString(C.PyExc_RuntimeError, estr)
+		C.free(unsafe.Pointer(estr))
+		return C.longlong(0)
+	}
+	return C.longlong(cret)
+}
+
+//export scrypted_arlo_go_WebRTCManager_CreateOffer
+func scrypted_arlo_go_WebRTCManager_CreateOffer(_handle CGoHandle) CGoHandle {
+	_saved_thread := C.PyEval_SaveThread()
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*scrypted_arlo_go.WebRTCManager")
+	if __err != nil {
+		return handleFromPtr_webrtc_SessionDescription(nil)
+	}
+	cret, __err := gopyh.Embed(vifc, reflect.TypeOf(scrypted_arlo_go.WebRTCManager{})).(*scrypted_arlo_go.WebRTCManager).CreateOffer()
+
+	C.PyEval_RestoreThread(_saved_thread)
+	if __err != nil {
+		estr := C.CString(__err.Error())
+		C.PyErr_SetString(C.PyExc_RuntimeError, estr)
+		C.free(unsafe.Pointer(estr))
+		return handleFromPtr_webrtc_SessionDescription(nil)
+	}
+	return handleFromPtr_webrtc_SessionDescription(&cret)
+}
+
+//export scrypted_arlo_go_WebRTCManager_CreateAnswer
+func scrypted_arlo_go_WebRTCManager_CreateAnswer(_handle CGoHandle) CGoHandle {
+	_saved_thread := C.PyEval_SaveThread()
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*scrypted_arlo_go.WebRTCManager")
+	if __err != nil {
+		return handleFromPtr_webrtc_SessionDescription(nil)
+	}
+	cret, __err := gopyh.Embed(vifc, reflect.TypeOf(scrypted_arlo_go.WebRTCManager{})).(*scrypted_arlo_go.WebRTCManager).CreateAnswer()
+
+	C.PyEval_RestoreThread(_saved_thread)
+	if __err != nil {
+		estr := C.CString(__err.Error())
+		C.PyErr_SetString(C.PyExc_RuntimeError, estr)
+		C.free(unsafe.Pointer(estr))
+		return handleFromPtr_webrtc_SessionDescription(nil)
+	}
+	return handleFromPtr_webrtc_SessionDescription(&cret)
+}
+
+//export scrypted_arlo_go_WebRTCManager_SetLocalDescription
+func scrypted_arlo_go_WebRTCManager_SetLocalDescription(_handle CGoHandle, desc CGoHandle) *C.char {
+	_saved_thread := C.PyEval_SaveThread()
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*scrypted_arlo_go.WebRTCManager")
+	if __err != nil {
+		return errorGoToPy(nil)
+	}
+	__err = gopyh.Embed(vifc, reflect.TypeOf(scrypted_arlo_go.WebRTCManager{})).(*scrypted_arlo_go.WebRTCManager).SetLocalDescription(*ptrFromHandle_webrtc_SessionDescription(desc))
+
+	C.PyEval_RestoreThread(_saved_thread)
+	if __err != nil {
+		estr := C.CString(__err.Error())
+		C.PyErr_SetString(C.PyExc_RuntimeError, estr)
+		return estr
+	}
+	return C.CString("")
+}
+
+//export scrypted_arlo_go_WebRTCManager_SetRemoteDescription
+func scrypted_arlo_go_WebRTCManager_SetRemoteDescription(_handle CGoHandle, desc CGoHandle) *C.char {
+	_saved_thread := C.PyEval_SaveThread()
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*scrypted_arlo_go.WebRTCManager")
+	if __err != nil {
+		return errorGoToPy(nil)
+	}
+	__err = gopyh.Embed(vifc, reflect.TypeOf(scrypted_arlo_go.WebRTCManager{})).(*scrypted_arlo_go.WebRTCManager).SetRemoteDescription(*ptrFromHandle_webrtc_SessionDescription(desc))
+
+	C.PyEval_RestoreThread(_saved_thread)
+	if __err != nil {
+		estr := C.CString(__err.Error())
+		C.PyErr_SetString(C.PyExc_RuntimeError, estr)
+		return estr
+	}
+	return C.CString("")
+}
+
+//export scrypted_arlo_go_WebRTCManager_AddICECandidate
+func scrypted_arlo_go_WebRTCManager_AddICECandidate(_handle CGoHandle, c CGoHandle) *C.char {
+	_saved_thread := C.PyEval_SaveThread()
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*scrypted_arlo_go.WebRTCManager")
+	if __err != nil {
+		return errorGoToPy(nil)
+	}
+	__err = gopyh.Embed(vifc, reflect.TypeOf(scrypted_arlo_go.WebRTCManager{})).(*scrypted_arlo_go.WebRTCManager).AddICECandidate(*ptrFromHandle_webrtc_ICECandidateInit(c))
+
+	C.PyEval_RestoreThread(_saved_thread)
+	if __err != nil {
+		estr := C.CString(__err.Error())
+		C.PyErr_SetString(C.PyExc_RuntimeError, estr)
+		return estr
+	}
+	return C.CString("")
+}
+
+//export scrypted_arlo_go_WebRTCManager_WaitForICEComplete
+func scrypted_arlo_go_WebRTCManager_WaitForICEComplete(_handle CGoHandle, goRun C.char) {
+	_saved_thread := C.PyEval_SaveThread()
+	defer C.PyEval_RestoreThread(_saved_thread)
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*scrypted_arlo_go.WebRTCManager")
+	if __err != nil {
+		return
+	}
+	if boolPyToGo(goRun) {
+		go gopyh.Embed(vifc, reflect.TypeOf(scrypted_arlo_go.WebRTCManager{})).(*scrypted_arlo_go.WebRTCManager).WaitForICEComplete()
+	} else {
+		gopyh.Embed(vifc, reflect.TypeOf(scrypted_arlo_go.WebRTCManager{})).(*scrypted_arlo_go.WebRTCManager).WaitForICEComplete()
+	}
+}
+
+//export scrypted_arlo_go_WebRTCManager_GetNextICECandidate
+func scrypted_arlo_go_WebRTCManager_GetNextICECandidate(_handle CGoHandle) CGoHandle {
+	_saved_thread := C.PyEval_SaveThread()
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*scrypted_arlo_go.WebRTCManager")
+	if __err != nil {
+		return handleFromPtr_webrtc_ICECandidate(nil)
+	}
+	cret, __err := gopyh.Embed(vifc, reflect.TypeOf(scrypted_arlo_go.WebRTCManager{})).(*scrypted_arlo_go.WebRTCManager).GetNextICECandidate()
+
+	C.PyEval_RestoreThread(_saved_thread)
+	if __err != nil {
+		estr := C.CString(__err.Error())
+		C.PyErr_SetString(C.PyExc_RuntimeError, estr)
+		C.free(unsafe.Pointer(estr))
+		return handleFromPtr_webrtc_ICECandidate(nil)
+	}
+	return handleFromPtr_webrtc_ICECandidate(&cret)
+}
+
+//export scrypted_arlo_go_WebRTCManager_Close
+func scrypted_arlo_go_WebRTCManager_Close(_handle CGoHandle, goRun C.char) {
+	_saved_thread := C.PyEval_SaveThread()
+	defer C.PyEval_RestoreThread(_saved_thread)
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*scrypted_arlo_go.WebRTCManager")
+	if __err != nil {
+		return
+	}
+	if boolPyToGo(goRun) {
+		go gopyh.Embed(vifc, reflect.TypeOf(scrypted_arlo_go.WebRTCManager{})).(*scrypted_arlo_go.WebRTCManager).Close()
+	} else {
+		gopyh.Embed(vifc, reflect.TypeOf(scrypted_arlo_go.WebRTCManager{})).(*scrypted_arlo_go.WebRTCManager).Close()
+	}
+}
+
+// --- wrapping struct: scrypted_arlo_go.KeysOutput ---
+//
+//export scrypted_arlo_go_KeysOutput_CTor
+func scrypted_arlo_go_KeysOutput_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_scrypted_arlo_go_KeysOutput(&scrypted_arlo_go.KeysOutput{}))
+}
+
+//export scrypted_arlo_go_KeysOutput_PublicPEM_Get
+func scrypted_arlo_go_KeysOutput_PublicPEM_Get(handle CGoHandle) *C.char {
+	op := ptrFromHandle_scrypted_arlo_go_KeysOutput(handle)
+	return C.CString(op.PublicPEM)
+}
+
+//export scrypted_arlo_go_KeysOutput_PublicPEM_Set
+func scrypted_arlo_go_KeysOutput_PublicPEM_Set(handle CGoHandle, val *C.char) {
+	op := ptrFromHandle_scrypted_arlo_go_KeysOutput(handle)
+	op.PublicPEM = C.GoString(val)
+}
+
+//export scrypted_arlo_go_KeysOutput_PrivatePEM_Get
+func scrypted_arlo_go_KeysOutput_PrivatePEM_Get(handle CGoHandle) *C.char {
+	op := ptrFromHandle_scrypted_arlo_go_KeysOutput(handle)
+	return C.CString(op.PrivatePEM)
+}
+
+//export scrypted_arlo_go_KeysOutput_PrivatePEM_Set
+func scrypted_arlo_go_KeysOutput_PrivatePEM_Set(handle CGoHandle, val *C.char) {
+	op := ptrFromHandle_scrypted_arlo_go_KeysOutput(handle)
+	op.PrivatePEM = C.GoString(val)
+}
+
+// --- wrapping struct: scrypted_arlo_go.LocalStreamProxy ---
+//
+//export scrypted_arlo_go_LocalStreamProxy_CTor
+func scrypted_arlo_go_LocalStreamProxy_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_scrypted_arlo_go_LocalStreamProxy(&scrypted_arlo_go.LocalStreamProxy{}))
+}
+
+//export scrypted_arlo_go_LocalStreamProxy_Info
+func scrypted_arlo_go_LocalStreamProxy_Info(_handle CGoHandle, msg *C.char, args CGoHandle, goRun C.char) {
+	_saved_thread := C.PyEval_SaveThread()
+	defer C.PyEval_RestoreThread(_saved_thread)
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*scrypted_arlo_go.LocalStreamProxy")
+	if __err != nil {
+		return
+	}
+	if boolPyToGo(goRun) {
+		go gopyh.Embed(vifc, reflect.TypeOf(scrypted_arlo_go.LocalStreamProxy{})).(*scrypted_arlo_go.LocalStreamProxy).Info(C.GoString(msg), deptrFromHandle_Slice_any(args)...)
+	} else {
+		gopyh.Embed(vifc, reflect.TypeOf(scrypted_arlo_go.LocalStreamProxy{})).(*scrypted_arlo_go.LocalStreamProxy).Info(C.GoString(msg), deptrFromHandle_Slice_any(args)...)
+	}
+}
+
+//export scrypted_arlo_go_LocalStreamProxy_Debug
+func scrypted_arlo_go_LocalStreamProxy_Debug(_handle CGoHandle, msg *C.char, args CGoHandle, goRun C.char) {
+	_saved_thread := C.PyEval_SaveThread()
+	defer C.PyEval_RestoreThread(_saved_thread)
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*scrypted_arlo_go.LocalStreamProxy")
+	if __err != nil {
+		return
+	}
+	if boolPyToGo(goRun) {
+		go gopyh.Embed(vifc, reflect.TypeOf(scrypted_arlo_go.LocalStreamProxy{})).(*scrypted_arlo_go.LocalStreamProxy).Debug(C.GoString(msg), deptrFromHandle_Slice_any(args)...)
+	} else {
+		gopyh.Embed(vifc, reflect.TypeOf(scrypted_arlo_go.LocalStreamProxy{})).(*scrypted_arlo_go.LocalStreamProxy).Debug(C.GoString(msg), deptrFromHandle_Slice_any(args)...)
+	}
+}
+
+//export scrypted_arlo_go_LocalStreamProxy_Start
+func scrypted_arlo_go_LocalStreamProxy_Start(_handle CGoHandle) C.longlong {
+	_saved_thread := C.PyEval_SaveThread()
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*scrypted_arlo_go.LocalStreamProxy")
+	if __err != nil {
+		return C.longlong(0)
+	}
+	cret, __err := gopyh.Embed(vifc, reflect.TypeOf(scrypted_arlo_go.LocalStreamProxy{})).(*scrypted_arlo_go.LocalStreamProxy).Start()
+
+	C.PyEval_RestoreThread(_saved_thread)
+	if __err != nil {
+		estr := C.CString(__err.Error())
+		C.PyErr_SetString(C.PyExc_RuntimeError, estr)
+		C.free(unsafe.Pointer(estr))
+		return C.longlong(0)
+	}
+	return C.longlong(cret)
+}
+
+//export scrypted_arlo_go_LocalStreamProxy_Close
+func scrypted_arlo_go_LocalStreamProxy_Close(_handle CGoHandle, goRun C.char) {
+	_saved_thread := C.PyEval_SaveThread()
+	defer C.PyEval_RestoreThread(_saved_thread)
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*scrypted_arlo_go.LocalStreamProxy")
+	if __err != nil {
+		return
+	}
+	if boolPyToGo(goRun) {
+		go gopyh.Embed(vifc, reflect.TypeOf(scrypted_arlo_go.LocalStreamProxy{})).(*scrypted_arlo_go.LocalStreamProxy).Close()
+	} else {
+		gopyh.Embed(vifc, reflect.TypeOf(scrypted_arlo_go.LocalStreamProxy{})).(*scrypted_arlo_go.LocalStreamProxy).Close()
+	}
+}
+
+// --- wrapping struct: scrypted_arlo_go.SIPWebRTCManager ---
+//
+//export scrypted_arlo_go_SIPWebRTCManager_CTor
+func scrypted_arlo_go_SIPWebRTCManager_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_scrypted_arlo_go_SIPWebRTCManager(&scrypted_arlo_go.SIPWebRTCManager{}))
+}
+
+//export scrypted_arlo_go_SIPWebRTCManager_Info
+func scrypted_arlo_go_SIPWebRTCManager_Info(_handle CGoHandle, msg *C.char, args CGoHandle, goRun C.char) {
+	_saved_thread := C.PyEval_SaveThread()
+	defer C.PyEval_RestoreThread(_saved_thread)
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*scrypted_arlo_go.SIPWebRTCManager")
+	if __err != nil {
+		return
+	}
+	if boolPyToGo(goRun) {
+		go gopyh.Embed(vifc, reflect.TypeOf(scrypted_arlo_go.SIPWebRTCManager{})).(*scrypted_arlo_go.SIPWebRTCManager).Info(C.GoString(msg), deptrFromHandle_Slice_any(args)...)
+	} else {
+		gopyh.Embed(vifc, reflect.TypeOf(scrypted_arlo_go.SIPWebRTCManager{})).(*scrypted_arlo_go.SIPWebRTCManager).Info(C.GoString(msg), deptrFromHandle_Slice_any(args)...)
+	}
+}
+
+//export scrypted_arlo_go_SIPWebRTCManager_Debug
+func scrypted_arlo_go_SIPWebRTCManager_Debug(_handle CGoHandle, msg *C.char, args CGoHandle, goRun C.char) {
+	_saved_thread := C.PyEval_SaveThread()
+	defer C.PyEval_RestoreThread(_saved_thread)
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*scrypted_arlo_go.SIPWebRTCManager")
+	if __err != nil {
+		return
+	}
+	if boolPyToGo(goRun) {
+		go gopyh.Embed(vifc, reflect.TypeOf(scrypted_arlo_go.SIPWebRTCManager{})).(*scrypted_arlo_go.SIPWebRTCManager).Debug(C.GoString(msg), deptrFromHandle_Slice_any(args)...)
+	} else {
+		gopyh.Embed(vifc, reflect.TypeOf(scrypted_arlo_go.SIPWebRTCManager{})).(*scrypted_arlo_go.SIPWebRTCManager).Debug(C.GoString(msg), deptrFromHandle_Slice_any(args)...)
+	}
+}
+
+//export scrypted_arlo_go_SIPWebRTCManager_InitializeAudioRTPListener
+func scrypted_arlo_go_SIPWebRTCManager_InitializeAudioRTPListener(_handle CGoHandle, codecMimeType *C.char) C.longlong {
+	_saved_thread := C.PyEval_SaveThread()
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*scrypted_arlo_go.SIPWebRTCManager")
+	if __err != nil {
+		return C.longlong(0)
+	}
+	cret, __err := gopyh.Embed(vifc, reflect.TypeOf(scrypted_arlo_go.SIPWebRTCManager{})).(*scrypted_arlo_go.SIPWebRTCManager).InitializeAudioRTPListener(C.GoString(codecMimeType))
+
+	C.PyEval_RestoreThread(_saved_thread)
+	if __err != nil {
+		estr := C.CString(__err.Error())
+		C.PyErr_SetString(C.PyExc_RuntimeError, estr)
+		C.free(unsafe.Pointer(estr))
+		return C.longlong(0)
+	}
+	return C.longlong(cret)
+}
+
+//export scrypted_arlo_go_SIPWebRTCManager_Start
+func scrypted_arlo_go_SIPWebRTCManager_Start(_handle CGoHandle) *C.char {
+	_saved_thread := C.PyEval_SaveThread()
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*scrypted_arlo_go.SIPWebRTCManager")
+	if __err != nil {
+		return C.CString("")
+	}
+	cret, __err := gopyh.Embed(vifc, reflect.TypeOf(scrypted_arlo_go.SIPWebRTCManager{})).(*scrypted_arlo_go.SIPWebRTCManager).Start()
+
+	C.PyEval_RestoreThread(_saved_thread)
+	if __err != nil {
+		estr := C.CString(__err.Error())
+		C.PyErr_SetString(C.PyExc_RuntimeError, estr)
+		C.free(unsafe.Pointer(estr))
+		return C.CString("")
+	}
+	return C.CString(cret)
+}
+
+//export scrypted_arlo_go_SIPWebRTCManager_StartTalk
+func scrypted_arlo_go_SIPWebRTCManager_StartTalk(_handle CGoHandle) *C.char {
+	_saved_thread := C.PyEval_SaveThread()
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*scrypted_arlo_go.SIPWebRTCManager")
+	if __err != nil {
+		return errorGoToPy(nil)
+	}
+	__err = gopyh.Embed(vifc, reflect.TypeOf(scrypted_arlo_go.SIPWebRTCManager{})).(*scrypted_arlo_go.SIPWebRTCManager).StartTalk()
+
+	C.PyEval_RestoreThread(_saved_thread)
+	if __err != nil {
+		estr := C.CString(__err.Error())
+		C.PyErr_SetString(C.PyExc_RuntimeError, estr)
+		return estr
+	}
+	return C.CString("")
+}
+
+//export scrypted_arlo_go_SIPWebRTCManager_StopTalk
+func scrypted_arlo_go_SIPWebRTCManager_StopTalk(_handle CGoHandle) *C.char {
+	_saved_thread := C.PyEval_SaveThread()
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*scrypted_arlo_go.SIPWebRTCManager")
+	if __err != nil {
+		return errorGoToPy(nil)
+	}
+	__err = gopyh.Embed(vifc, reflect.TypeOf(scrypted_arlo_go.SIPWebRTCManager{})).(*scrypted_arlo_go.SIPWebRTCManager).StopTalk()
+
+	C.PyEval_RestoreThread(_saved_thread)
+	if __err != nil {
+		estr := C.CString(__err.Error())
+		C.PyErr_SetString(C.PyExc_RuntimeError, estr)
+		return estr
+	}
+	return C.CString("")
+}
+
+//export scrypted_arlo_go_SIPWebRTCManager_Close
+func scrypted_arlo_go_SIPWebRTCManager_Close(_handle CGoHandle, goRun C.char) {
+	_saved_thread := C.PyEval_SaveThread()
+	defer C.PyEval_RestoreThread(_saved_thread)
+	vifc, __err := gopyh.VarFromHandleTry((gopyh.CGoHandle)(_handle), "*scrypted_arlo_go.SIPWebRTCManager")
+	if __err != nil {
+		return
+	}
+	if boolPyToGo(goRun) {
+		go gopyh.Embed(vifc, reflect.TypeOf(scrypted_arlo_go.SIPWebRTCManager{})).(*scrypted_arlo_go.SIPWebRTCManager).Close()
+	} else {
+		gopyh.Embed(vifc, reflect.TypeOf(scrypted_arlo_go.SIPWebRTCManager{})).(*scrypted_arlo_go.SIPWebRTCManager).Close()
+	}
+}
+
+// --- wrapping struct: webrtc.ICECandidateInit ---
+//
+//export webrtc_ICECandidateInit_CTor
+func webrtc_ICECandidateInit_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_webrtc_ICECandidateInit(&webrtc.ICECandidateInit{}))
+}
+
+//export webrtc_ICECandidateInit_Candidate_Get
+func webrtc_ICECandidateInit_Candidate_Get(handle CGoHandle) *C.char {
+	op := ptrFromHandle_webrtc_ICECandidateInit(handle)
+	return C.CString(op.Candidate)
+}
+
+//export webrtc_ICECandidateInit_Candidate_Set
+func webrtc_ICECandidateInit_Candidate_Set(handle CGoHandle, val *C.char) {
+	op := ptrFromHandle_webrtc_ICECandidateInit(handle)
+	op.Candidate = C.GoString(val)
+}
+
+// ---- Slices ---
+
+// ---- Maps ---
+
+// --- wrapping map: scrypted_arlo_go.HeadersMap ---
+//
+//export scrypted_arlo_go_HeadersMap_CTor
+func scrypted_arlo_go_HeadersMap_CTor() CGoHandle {
+	return CGoHandle(handleFromPtr_scrypted_arlo_go_HeadersMap(&scrypted_arlo_go.HeadersMap{}))
+}
+
+//export scrypted_arlo_go_HeadersMap_len
+func scrypted_arlo_go_HeadersMap_len(handle CGoHandle) int {
+	return len(deptrFromHandle_scrypted_arlo_go_HeadersMap(handle))
+}
+
+//export scrypted_arlo_go_HeadersMap_elem
+func scrypted_arlo_go_HeadersMap_elem(handle CGoHandle, _ky *C.char) *C.char {
+	s := deptrFromHandle_scrypted_arlo_go_HeadersMap(handle)
+	v, ok := s[C.GoString(_ky)]
+	if !ok {
+		C.PyErr_SetString(C.PyExc_KeyError, C.CString("key not in map"))
+	}
+	return C.CString(v)
+}
+
+//export scrypted_arlo_go_HeadersMap_contains
+func scrypted_arlo_go_HeadersMap_contains(handle CGoHandle, _ky *C.char) C.char {
+	s := deptrFromHandle_scrypted_arlo_go_HeadersMap(handle)
+	_, ok := s[C.GoString(_ky)]
+	return boolGoToPy(ok)
+}
+
+//export scrypted_arlo_go_HeadersMap_set
+func scrypted_arlo_go_HeadersMap_set(handle CGoHandle, _ky *C.char, _vl *C.char) {
+	s := deptrFromHandle_scrypted_arlo_go_HeadersMap(handle)
+	s[C.GoString(_ky)] = C.GoString(_vl)
+}
+
+//export scrypted_arlo_go_HeadersMap_delete
+func scrypted_arlo_go_HeadersMap_delete(handle CGoHandle, _ky *C.char) {
+	s := deptrFromHandle_scrypted_arlo_go_HeadersMap(handle)
+	delete(s, C.GoString(_ky))
+}
+
+//export scrypted_arlo_go_HeadersMap_keys
+func scrypted_arlo_go_HeadersMap_keys(handle CGoHandle) CGoHandle {
+	s := deptrFromHandle_scrypted_arlo_go_HeadersMap(handle)
+	kys := make([]string, 0, len(s))
+	for k := range s {
+		kys = append(kys, k)
+	}
+	return handleFromPtr_Slice_string(&kys)
+}
+
+// ---- Constructors ---
+
+//export scrypted_arlo_go_NewWebRTCICEServer
+func scrypted_arlo_go_NewWebRTCICEServer(urls CGoHandle, username *C.char, credential *C.char) CGoHandle {
+	_saved_thread := C.PyEval_SaveThread()
+	defer C.PyEval_RestoreThread(_saved_thread)
+	cret := scrypted_arlo_go.NewWebRTCICEServer(deptrFromHandle_Slice_string(urls), C.GoString(username), C.GoString(credential))
+
+	return handleFromPtr_webrtc_ICEServer(&cret)
+}
+
+//export scrypted_arlo_go_ParseAuthHeader
+func scrypted_arlo_go_ParseAuthHeader(header *C.char) CGoHandle {
+	_saved_thread := C.PyEval_SaveThread()
+	cret, __err := scrypted_arlo_go.ParseAuthHeader(C.GoString(header))
+
+	C.PyEval_RestoreThread(_saved_thread)
+	if __err != nil {
+		estr := C.CString(__err.Error())
+		C.PyErr_SetString(C.PyExc_RuntimeError, estr)
+		C.free(unsafe.Pointer(estr))
+		return handleFromPtr_scrypted_arlo_go_AuthHeader(nil)
+	}
+	return handleFromPtr_scrypted_arlo_go_AuthHeader(&cret)
+}
+
+//export scrypted_arlo_go_NewSSEClient
+func scrypted_arlo_go_NewSSEClient(url *C.char, headers CGoHandle) CGoHandle {
+	_saved_thread := C.PyEval_SaveThread()
+	cret, __err := scrypted_arlo_go.NewSSEClient(C.GoString(url), deptrFromHandle_scrypted_arlo_go_HeadersMap(headers))
+
+	C.PyEval_RestoreThread(_saved_thread)
+	if __err != nil {
+		estr := C.CString(__err.Error())
+		C.PyErr_SetString(C.PyExc_RuntimeError, estr)
+		C.free(unsafe.Pointer(estr))
+		return handleFromPtr_Ptr_scrypted_arlo_go_SSEClient(nil)
+	}
+	return handleFromPtr_Ptr_scrypted_arlo_go_SSEClient(cret)
+}
+
+//export scrypted_arlo_go_NewTCPLogger
+func scrypted_arlo_go_NewTCPLogger(loggerPort C.longlong, name *C.char) CGoHandle {
+	_saved_thread := C.PyEval_SaveThread()
+	cret, __err := scrypted_arlo_go.NewTCPLogger(int(loggerPort), C.GoString(name))
+
+	C.PyEval_RestoreThread(_saved_thread)
+	if __err != nil {
+		estr := C.CString(__err.Error())
+		C.PyErr_SetString(C.PyExc_RuntimeError, estr)
+		C.free(unsafe.Pointer(estr))
+		return handleFromPtr_Ptr_scrypted_arlo_go_TCPLogger(nil)
+	}
+	return handleFromPtr_Ptr_scrypted_arlo_go_TCPLogger(cret)
+}
+
+//export scrypted_arlo_go_NewWebRTCManager
+func scrypted_arlo_go_NewWebRTCManager(infoLoggerPort C.longlong, debugLoggerPort C.longlong, iceServers CGoHandle) CGoHandle {
+	_saved_thread := C.PyEval_SaveThread()
+	cret, __err := scrypted_arlo_go.NewWebRTCManager(int(infoLoggerPort), int(debugLoggerPort), deptrFromHandle_Slice_webrtc_ICEServer(iceServers))
+
+	C.PyEval_RestoreThread(_saved_thread)
+	if __err != nil {
+		estr := C.CString(__err.Error())
+		C.PyErr_SetString(C.PyExc_RuntimeError, estr)
+		C.free(unsafe.Pointer(estr))
+		return handleFromPtr_Ptr_scrypted_arlo_go_WebRTCManager(nil)
+	}
+	return handleFromPtr_Ptr_scrypted_arlo_go_WebRTCManager(cret)
+}
+
+//export scrypted_arlo_go_GenerateRSAKeys
+func scrypted_arlo_go_GenerateRSAKeys(bitsize C.longlong) CGoHandle {
+	_saved_thread := C.PyEval_SaveThread()
+	cret, __err := scrypted_arlo_go.GenerateRSAKeys(int(bitsize))
+
+	C.PyEval_RestoreThread(_saved_thread)
+	if __err != nil {
+		estr := C.CString(__err.Error())
+		C.PyErr_SetString(C.PyExc_RuntimeError, estr)
+		C.free(unsafe.Pointer(estr))
+		return handleFromPtr_scrypted_arlo_go_KeysOutput(nil)
+	}
+	return handleFromPtr_scrypted_arlo_go_KeysOutput(&cret)
+}
+
+//export scrypted_arlo_go_NewLocalStreamProxy
+func scrypted_arlo_go_NewLocalStreamProxy(infoLoggerPort C.longlong, debugLoggerPort C.longlong, basestationHostname *C.char, basestationIP *C.char, certPEM *C.char, keyPEM *C.char) CGoHandle {
+	_saved_thread := C.PyEval_SaveThread()
+	cret, __err := scrypted_arlo_go.NewLocalStreamProxy(int(infoLoggerPort), int(debugLoggerPort), C.GoString(basestationHostname), C.GoString(basestationIP), C.GoString(certPEM), C.GoString(keyPEM))
+
+	C.PyEval_RestoreThread(_saved_thread)
+	if __err != nil {
+		estr := C.CString(__err.Error())
+		C.PyErr_SetString(C.PyExc_RuntimeError, estr)
+		C.free(unsafe.Pointer(estr))
+		return handleFromPtr_Ptr_scrypted_arlo_go_LocalStreamProxy(nil)
+	}
+	return handleFromPtr_Ptr_scrypted_arlo_go_LocalStreamProxy(cret)
+}
+
+//export scrypted_arlo_go_NewSIPWebRTCManager
+func scrypted_arlo_go_NewSIPWebRTCManager(infoLoggerPort C.longlong, debugLoggerPort C.longlong, iceServers CGoHandle, sipInfo CGoHandle) CGoHandle {
+	_saved_thread := C.PyEval_SaveThread()
+	cret, __err := scrypted_arlo_go.NewSIPWebRTCManager(int(infoLoggerPort), int(debugLoggerPort), deptrFromHandle_Slice_webrtc_ICEServer(iceServers), *ptrFromHandle_scrypted_arlo_go_SIPInfo(sipInfo))
+
+	C.PyEval_RestoreThread(_saved_thread)
+	if __err != nil {
+		estr := C.CString(__err.Error())
+		C.PyErr_SetString(C.PyExc_RuntimeError, estr)
+		C.free(unsafe.Pointer(estr))
+		return handleFromPtr_Ptr_scrypted_arlo_go_SIPWebRTCManager(nil)
+	}
+	return handleFromPtr_Ptr_scrypted_arlo_go_SIPWebRTCManager(cret)
+}
+
+// ---- Functions ---
+
+//export scrypted_arlo_go_VerifyCertHostname
+func scrypted_arlo_go_VerifyCertHostname(cert *C.char, hostname *C.char) *C.char {
+	_saved_thread := C.PyEval_SaveThread()
+	var __err error
+	__err = scrypted_arlo_go.VerifyCertHostname(C.GoString(cert), C.GoString(hostname))
+
+	C.PyEval_RestoreThread(_saved_thread)
+	if __err != nil {
+		estr := C.CString(__err.Error())
+		C.PyErr_SetString(C.PyExc_RuntimeError, estr)
+		return estr
+	}
+	return C.CString("")
+}
+
+//export scrypted_arlo_go_WebRTCSessionDescriptionSDP
+func scrypted_arlo_go_WebRTCSessionDescriptionSDP(s CGoHandle) *C.char {
+	_saved_thread := C.PyEval_SaveThread()
+	defer C.PyEval_RestoreThread(_saved_thread)
+	return C.CString(scrypted_arlo_go.WebRTCSessionDescriptionSDP(*ptrFromHandle_webrtc_SessionDescription(s)))
+
+}
+
+//export scrypted_arlo_go_NewWebRTCSDPType
+func scrypted_arlo_go_NewWebRTCSDPType(sdpType *C.char) C.longlong {
+	_saved_thread := C.PyEval_SaveThread()
+	defer C.PyEval_RestoreThread(_saved_thread)
+	return C.longlong(int(scrypted_arlo_go.NewWebRTCSDPType(C.GoString(sdpType))))
+
+}