diff --git a/examples/bins/main.go b/examples/bins/main.go
index d318a76..07b2813 100644
--- a/examples/bins/main.go
+++ b/examples/bins/main.go
@@ -4,47 +4,42 @@ import (
 	"fmt"
 	"time"
 
-	"github.com/diamondburned/gotk4/pkg/glib/v2"
 	"github.com/go-gst/go-gst/pkg/gst"
 )
 
 func main() {
 	gst.Init()
-
-	mainLoop := glib.NewMainLoop(glib.MainContextDefault(), false)
-
 	bin, err := gst.ParseBinFromDescription("fakesrc num-buffers=5 ! fakesink", true)
 	if err != nil {
 		panic(err)
 	}
 
-	pipeline := gst.NewPipeline("pipeline")
+	pipeline := gst.NewPipeline("pipeline").(gst.Pipeline)
 
 	pipeline.Add(bin)
 
-	pipeline.Bus().AddWatch(0, func(bus *gst.Bus, msg *gst.Message) bool {
+	// Start the pipeline
+	pipeline.SetState(gst.StatePlaying)
+
+	// handle messages
+	messages:
+	for msg := range pipeline.GetBus().Messages() {
 		switch msg.Type() {
-		case gst.MessageEos: // When end-of-stream is received stop the main loop
+		case gst.MessageEos: // When end-of-stream is received stop
+			fmt.Println("End-of-stream reached")
 			bin.BlockSetState(gst.StateNull, gst.ClockTime(time.Second))
-			mainLoop.Quit()
+			break messages
 		case gst.MessageError: // Error messages are always fatal
-			err, debug := msg.ParseError()
+			debug, err := msg.ParseError()
 			fmt.Println("ERROR:", err.Error())
 			if debug != "" {
 				fmt.Println("DEBUG:", debug)
 			}
-			mainLoop.Quit()
+			break messages
 		default:
 			// All messages implement a Stringer. However, this is
 			// typically an expensive thing to do and should be avoided.
 			fmt.Println(msg)
 		}
-		return true
-	})
-
-	// Start the pipeline
-	pipeline.SetState(gst.StatePlaying)
-
-	// Block on the main loop
-	mainLoop.Run()
+	}
 }
diff --git a/generator.go b/generator.go
index f928635..83afbaf 100644
--- a/generator.go
+++ b/generator.go
@@ -61,6 +61,8 @@ var Data = genmain.Overlay(
 			{Name: "gstreamer-player-1.0", Namespaces: []string{"GstPlayer-1"}},
 		},
 		Preprocessors: []types.Preprocessor{
+			types.MustIntrospect("Gst-1.Message.copy"),
+
 			// Enum has a member of same name:
 			types.TypeRenamer("Gst-1.BufferCopyFlags", "BufferCopyFlagsType"),
 
@@ -97,6 +99,19 @@ var Data = genmain.Overlay(
 		Config: typesystem.Config{
 			Namespaces: map[string]typesystem.NamespaceConfig{
 				"Gst-1": {
+					ManualTypes: []typesystem.Type{
+						&typesystem.Alias{
+							BaseType: typesystem.BaseType{
+								GirName: "ClockTime",
+								GoTyp:   "ClockTime",
+								CGoTyp:  "C.GstClockTime",
+								CTyp:    "GstClockTime",
+							},
+							AliasedType: typesystem.CouldBeForeign[typesystem.Type]{
+								Type: typesystem.Guint64,
+							},
+						},
+					},
 					IgnoredDefinitions: []typesystem.IgnoreFunc{
 						// Collide and use an out array of values. TODO: manually implement
 						typesystem.IgnoreMatching("Object.get_g_value_array"),
@@ -153,6 +168,7 @@ var Data = genmain.Overlay(
 			typesystem.MarkAsManuallyExtended("Gst", 1, "Object"),
 			typesystem.MarkAsManuallyExtended("Gst", 1, "Element"),
 			typesystem.MarkAsManuallyExtended("Gst", 1, "Bin"),
+			typesystem.MarkAsManuallyExtended("Gst", 1, "Bus"),
 			typesystem.MarkAsManuallyExtended("Gst", 1, "ChildProxy"),
 		},
 		GeneratorHooks: []genmain.GeneratorHook{
diff --git a/go.mod b/go.mod
index 48f8b5c..28daab0 100644
--- a/go.mod
+++ b/go.mod
@@ -1,12 +1,8 @@
 module github.com/go-gst/go-gst
 
-go 1.24
+go 1.24.0
 
-require (
-	github.com/diamondburned/gotk4 v0.3.1
-	github.com/diamondburned/gotk4/pkg v0.3.1
-	github.com/go-gst/go-glib v1.4.0
-)
+require github.com/diamondburned/gotk4 v0.3.1
 
 require (
 	github.com/KarpelesLab/weak v0.1.1 // indirect
@@ -14,11 +10,9 @@ require (
 	github.com/fatih/color v1.10.0 // indirect
 	github.com/mattn/go-colorable v0.1.8 // indirect
 	github.com/mattn/go-isatty v0.0.12 // indirect
-	github.com/mattn/go-pointer v0.0.1 // indirect
 	go4.org/unsafe/assume-no-moving-gc v0.0.0-20231121144256-b99613f794b6 // indirect
-	golang.org/x/exp v0.0.0-20240909161429-701f63a606c0 // indirect
 	golang.org/x/sync v0.8.0 // indirect
 	golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae // indirect
 )
 
-replace github.com/diamondburned/gotk4 => github.com/rswilli/gotk4 v0.0.0-20250218150900-a50dc615a9cd
+replace github.com/diamondburned/gotk4 => github.com/rswilli/gotk4 v0.0.0-20250414144439-3ea5b58c435c
diff --git a/go.sum b/go.sum
index 4755dde..d7e0348 100644
--- a/go.sum
+++ b/go.sum
@@ -6,26 +6,18 @@ github.com/alecthomas/repr v0.4.0 h1:GhI2A8MACjfegCPVq9f1FLvIBS+DrQ2KQBFZP1iFzXc
 github.com/alecthomas/repr v0.4.0/go.mod h1:Fr0507jx4eOXV7AlPV6AVZLYrLIuIeSOWtW57eE/O/4=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/diamondburned/gotk4/pkg v0.3.1 h1:uhkXSUPUsCyz3yujdvl7DSN8jiLS2BgNTQE95hk6ygg=
-github.com/diamondburned/gotk4/pkg v0.3.1/go.mod h1:DqeOW+MxSZFg9OO+esk4JgQk0TiUJJUBfMltKhG+ub4=
 github.com/fatih/color v1.10.0 h1:s36xzo75JdqLaaWoiEHk767eHiwo0598uUxyfiPkDsg=
 github.com/fatih/color v1.10.0/go.mod h1:ELkj/draVOlAH/xkhN6mQ50Qd0MPOk5AAr3maGEBuJM=
-github.com/go-gst/go-glib v1.4.0 h1:FB2uVfB0uqz7/M6EaDdWWlBZRQpvFAbWfL7drdw8lAE=
-github.com/go-gst/go-glib v1.4.0/go.mod h1:GUIpWmkxQ1/eL+FYSjKpLDyTZx6Vgd9nNXt8dA31d5M=
 github.com/hexops/gotextdiff v1.0.3 h1:gitA9+qJrrTCsiCl7+kh75nPqQt1cx4ZkudSTLoUqJM=
 github.com/hexops/gotextdiff v1.0.3/go.mod h1:pSWU5MAI3yDq+fZBTazCSJysOMbxWL1BSow5/V2vxeg=
 github.com/mattn/go-colorable v0.1.8 h1:c1ghPdyEDarC70ftn0y+A/Ee++9zz8ljHG1b13eJ0s8=
 github.com/mattn/go-colorable v0.1.8/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
 github.com/mattn/go-isatty v0.0.12 h1:wuysRhFDzyxgEmMf5xjvJ2M9dZoWAXNNr5LSBS7uHXY=
 github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
-github.com/mattn/go-pointer v0.0.1 h1:n+XhsuGeVO6MEAp7xyEukFINEa+Quek5psIR/ylA6o0=
-github.com/mattn/go-pointer v0.0.1/go.mod h1:2zXcozF6qYGgmsG+SeTZz3oAbFLdD3OWqnUbNvJZAlc=
-github.com/rswilli/gotk4 v0.0.0-20250218150900-a50dc615a9cd h1:zr2YKjDmZ87sjIuteDikBBJ703mV0VVj1YbLWb6VzRc=
-github.com/rswilli/gotk4 v0.0.0-20250218150900-a50dc615a9cd/go.mod h1:zjEfxmFGTAr8nGFEn41VI62JFbq+LR0pet7EfGtpCnA=
+github.com/rswilli/gotk4 v0.0.0-20250414144439-3ea5b58c435c h1:eMl/WmLOqEOrBWjkbmCG059tgPQoCKa898h7GzaSl98=
+github.com/rswilli/gotk4 v0.0.0-20250414144439-3ea5b58c435c/go.mod h1:bvqvG9zCPsZpqPMKfx0TvmR6ltWKEOaBHzLHY02/Rf8=
 go4.org/unsafe/assume-no-moving-gc v0.0.0-20231121144256-b99613f794b6 h1:lGdhQUN/cnWdSH3291CUuxSEqc+AsGTiDxPP3r2J0l4=
 go4.org/unsafe/assume-no-moving-gc v0.0.0-20231121144256-b99613f794b6/go.mod h1:FftLjUGFEDu5k8lt0ddY+HcrH/qU/0qk+H8j9/nTl3E=
-golang.org/x/exp v0.0.0-20240909161429-701f63a606c0 h1:e66Fs6Z+fZTbFBAxKfP3PALWBtpfqks2bwGcexMxgtk=
-golang.org/x/exp v0.0.0-20240909161429-701f63a606c0/go.mod h1:2TbTHSBQa924w8M6Xs1QcRcFwyucIwBGpK1p2f1YFFY=
 golang.org/x/sync v0.8.0 h1:3NFvSEYkUoMifnESzZl15y791HH1qU2xm6eCJU5ZPXQ=
 golang.org/x/sync v0.8.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
 golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
diff --git a/pkg/gst/bus_manual.go b/pkg/gst/bus_manual.go
new file mode 100644
index 0000000..15775a6
--- /dev/null
+++ b/pkg/gst/bus_manual.go
@@ -0,0 +1,32 @@
+package gst
+
+import "iter"
+
+type BusExtManual interface {
+	// Messages adds a watch to the bus. This is a convenience function that
+	// actually attaches a sync handler to the bus. This way you don't need to create a
+	// main loop.
+	//
+	// Since this is a sync handler, make sure to handle the messages as fast as
+	// possible. Otherwise your pipeline may block.
+	Messages() iter.Seq[*Message]
+}
+
+func (bus *BusInstance) Messages() iter.Seq[*Message] {
+	messages := make(chan *Message, 20) // arbitrary cap to not block instantly
+
+	bus.SetSyncHandler(func(bus Bus, message *Message) BusSyncReply {
+		messages <- message.Copy()
+		return BusDrop
+	})
+
+	return func(yield func(*Message) bool) {
+		for message := range messages {
+			if !yield(message) {
+				bus.SetSyncHandler(nil)
+				close(messages)
+				return
+			}
+		}
+	}
+}
diff --git a/pkg/gst/clocktime.go b/pkg/gst/clocktime.go
new file mode 100644
index 0000000..cebce3e
--- /dev/null
+++ b/pkg/gst/clocktime.go
@@ -0,0 +1,16 @@
+package gst
+
+import "time"
+
+// ClockTimeNone is a constant that represents an infinite or non-existent time.
+const ClockTimeNone ClockTime = 0xFFFFFFFFFFFFFFFF
+
+// ClockTime wraps GstClockTime
+//
+// A datatype to hold a time, measured in nanoseconds.
+type ClockTime uint64
+
+// String returns a string representation of the ClockTime.
+func (c ClockTime) String() string {
+	return time.Duration(c).String()
+}
diff --git a/pkg/gst/gst.gen.go b/pkg/gst/gst.gen.go
index 4b5ac82..110a9c3 100644
--- a/pkg/gst/gst.gen.go
+++ b/pkg/gst/gst.gen.go
@@ -3,7 +3,9 @@
 package gst
 
 import (
+	"fmt"
 	"runtime"
+	"strings"
 	"unsafe"
 
 	"github.com/diamondburned/gotk4/pkg/core/userdata"
@@ -484,10 +486,6 @@ const VERSION_NANO = 0
 //
 // A datatype to hold the handle to an outstanding sync or async clock callback.
 type ClockID = unsafe.Pointer
-// ClockTime wraps GstClockTime
-//
-// A datatype to hold a time, measured in nanoseconds.
-type ClockTime = uint64
 // ClockTimeDiff wraps GstClockTimeDiff
 //
 // A datatype to hold a time difference, measured in nanoseconds.
@@ -531,6 +529,16 @@ func (e BufferingMode) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e BufferingMode) String() string {
+	switch e {
+		case BufferingStream: return "BufferingStream"
+		case BufferingDownload: return "BufferingDownload"
+		case BufferingTimeshift: return "BufferingTimeshift"
+		case BufferingLive: return "BufferingLive"
+		default: return fmt.Sprintf("BufferingMode(%d)", e)
+	}
+}
+
 // BusSyncReply wraps GstBusSyncReply
 //
 // The result values for a GstBusSyncHandler.
@@ -562,6 +570,15 @@ func (e BusSyncReply) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e BusSyncReply) String() string {
+	switch e {
+		case BusAsync: return "BusAsync"
+		case BusDrop: return "BusDrop"
+		case BusPass: return "BusPass"
+		default: return fmt.Sprintf("BusSyncReply(%d)", e)
+	}
+}
+
 // CapsIntersectMode wraps GstCapsIntersectMode
 //
 // Modes of caps intersection
@@ -609,6 +626,14 @@ func (e CapsIntersectMode) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e CapsIntersectMode) String() string {
+	switch e {
+		case CapsIntersectZigZag: return "CapsIntersectZigZag"
+		case CapsIntersectFirst: return "CapsIntersectFirst"
+		default: return fmt.Sprintf("CapsIntersectMode(%d)", e)
+	}
+}
+
 // ClockEntryType wraps GstClockEntryType
 //
 // The type of the clock entry
@@ -636,6 +661,14 @@ func (e ClockEntryType) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e ClockEntryType) String() string {
+	switch e {
+		case ClockEntryPeriodic: return "ClockEntryPeriodic"
+		case ClockEntrySingle: return "ClockEntrySingle"
+		default: return fmt.Sprintf("ClockEntryType(%d)", e)
+	}
+}
+
 // ClockReturn wraps GstClockReturn
 //
 // The return value of a clock operation.
@@ -687,6 +720,20 @@ func (e ClockReturn) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e ClockReturn) String() string {
+	switch e {
+		case ClockUnscheduled: return "ClockUnscheduled"
+		case ClockBusy: return "ClockBusy"
+		case ClockBadtime: return "ClockBadtime"
+		case ClockError: return "ClockError"
+		case ClockUnsupported: return "ClockUnsupported"
+		case ClockDone: return "ClockDone"
+		case ClockOK: return "ClockOK"
+		case ClockEarly: return "ClockEarly"
+		default: return fmt.Sprintf("ClockReturn(%d)", e)
+	}
+}
+
 // ClockType wraps GstClockType
 //
 // The different kind of clocks.
@@ -724,6 +771,16 @@ func (e ClockType) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e ClockType) String() string {
+	switch e {
+		case ClockTypeRealtime: return "ClockTypeRealtime"
+		case ClockTypeMonotonic: return "ClockTypeMonotonic"
+		case ClockTypeOther: return "ClockTypeOther"
+		case ClockTypeTai: return "ClockTypeTai"
+		default: return fmt.Sprintf("ClockType(%d)", e)
+	}
+}
+
 // CoreError wraps GstCoreError
 //
 // Core errors are errors inside the core GStreamer library.
@@ -807,6 +864,27 @@ func (e CoreError) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e CoreError) String() string {
+	switch e {
+		case CoreErrorClock: return "CoreErrorClock"
+		case CoreErrorTooLaZY: return "CoreErrorTooLaZY"
+		case CoreErrorNegotiation: return "CoreErrorNegotiation"
+		case CoreErrorSeek: return "CoreErrorSeek"
+		case CoreErrorMissingPlugin: return "CoreErrorMissingPlugin"
+		case CoreErrorFailed: return "CoreErrorFailed"
+		case CoreErrorCaps: return "CoreErrorCaps"
+		case CoreErrorTag: return "CoreErrorTag"
+		case CoreErrorDisabled: return "CoreErrorDisabled"
+		case CoreErrorNotImplemented: return "CoreErrorNotImplemented"
+		case CoreErrorStateChange: return "CoreErrorStateChange"
+		case CoreErrorThread: return "CoreErrorThread"
+		case CoreErrorEvent: return "CoreErrorEvent"
+		case CoreErrorNumErrors: return "CoreErrorNumErrors"
+		case CoreErrorPad: return "CoreErrorPad"
+		default: return fmt.Sprintf("CoreError(%d)", e)
+	}
+}
+
 // DebugColorMode wraps GstDebugColorMode
 type DebugColorMode C.int
 
@@ -837,6 +915,15 @@ func (e DebugColorMode) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e DebugColorMode) String() string {
+	switch e {
+		case DebugColorModeOff: return "DebugColorModeOff"
+		case DebugColorModeOn: return "DebugColorModeOn"
+		case DebugColorModeUnix: return "DebugColorModeUnix"
+		default: return fmt.Sprintf("DebugColorMode(%d)", e)
+	}
+}
+
 // DebugLevel wraps GstDebugLevel
 //
 // The level defines the importance of a debugging message. The more important a
@@ -924,6 +1011,22 @@ func (e DebugLevel) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e DebugLevel) String() string {
+	switch e {
+		case LevelNone: return "LevelNone"
+		case LevelWarning: return "LevelWarning"
+		case LevelInfo: return "LevelInfo"
+		case LevelLog: return "LevelLog"
+		case LevelMemdump: return "LevelMemdump"
+		case LevelError: return "LevelError"
+		case LevelFixme: return "LevelFixme"
+		case LevelDebug: return "LevelDebug"
+		case LevelTrace: return "LevelTrace"
+		case LevelCount: return "LevelCount"
+		default: return fmt.Sprintf("DebugLevel(%d)", e)
+	}
+}
+
 // EventType wraps GstEventType
 //
 // #GstEventType lists the standard event types that can be sent in a pipeline.
@@ -1105,6 +1208,44 @@ func (e EventType) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e EventType) String() string {
+	switch e {
+		case EventFlushStop: return "EventFlushStop"
+		case EventStreamStart: return "EventStreamStart"
+		case EventCustomDownstreamOob: return "EventCustomDownstreamOob"
+		case EventCustomBoth: return "EventCustomBoth"
+		case EventCustomBothOob: return "EventCustomBothOob"
+		case EventProtection: return "EventProtection"
+		case EventLatency: return "EventLatency"
+		case EventTocSelect: return "EventTocSelect"
+		case EventCustomDownstream: return "EventCustomDownstream"
+		case EventSegment: return "EventSegment"
+		case EventStreamCollection: return "EventStreamCollection"
+		case EventBuffersize: return "EventBuffersize"
+		case EventNavigation: return "EventNavigation"
+		case EventCaps: return "EventCaps"
+		case EventQos: return "EventQos"
+		case EventCustomUpstream: return "EventCustomUpstream"
+		case EventToc: return "EventToc"
+		case EventTag: return "EventTag"
+		case EventStreamGroupDone: return "EventStreamGroupDone"
+		case EventGap: return "EventGap"
+		case EventCustomDownstreamSticky: return "EventCustomDownstreamSticky"
+		case EventSeek: return "EventSeek"
+		case EventSelectStreams: return "EventSelectStreams"
+		case EventSegmentDone: return "EventSegmentDone"
+		case EventStep: return "EventStep"
+		case EventInstantRateSyncTime: return "EventInstantRateSyncTime"
+		case EventFlushStart: return "EventFlushStart"
+		case EventSinkMessage: return "EventSinkMessage"
+		case EventInstantRateChange: return "EventInstantRateChange"
+		case EventReconfigure: return "EventReconfigure"
+		case EventEos: return "EventEos"
+		case EventUnknown: return "EventUnknown"
+		default: return fmt.Sprintf("EventType(%d)", e)
+	}
+}
+
 // FlowReturn wraps GstFlowReturn
 //
 // The result of passing data to a pad.
@@ -1188,6 +1329,25 @@ func (e FlowReturn) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e FlowReturn) String() string {
+	switch e {
+		case FlowCustomSuccess2: return "FlowCustomSuccess2"
+		case FlowCustomSuccess: return "FlowCustomSuccess"
+		case FlowNotLinked: return "FlowNotLinked"
+		case FlowFlushing: return "FlowFlushing"
+		case FlowEos: return "FlowEos"
+		case FlowNotNegotiated: return "FlowNotNegotiated"
+		case FlowCustomError2: return "FlowCustomError2"
+		case FlowCustomSuccess1: return "FlowCustomSuccess1"
+		case FlowOK: return "FlowOK"
+		case FlowError: return "FlowError"
+		case FlowNotSupported: return "FlowNotSupported"
+		case FlowCustomError: return "FlowCustomError"
+		case FlowCustomError1: return "FlowCustomError1"
+		default: return fmt.Sprintf("FlowReturn(%d)", e)
+	}
+}
+
 // Format wraps GstFormat
 //
 // Standard predefined formats
@@ -1236,6 +1396,18 @@ func (e Format) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e Format) String() string {
+	switch e {
+		case FormatBytes: return "FormatBytes"
+		case FormatTime: return "FormatTime"
+		case FormatBuffers: return "FormatBuffers"
+		case FormatPercent: return "FormatPercent"
+		case FormatUndefined: return "FormatUndefined"
+		case FormatDefault: return "FormatDefault"
+		default: return fmt.Sprintf("Format(%d)", e)
+	}
+}
+
 // IteratorItem wraps GstIteratorItem
 //
 // The result of a #GstIteratorItemFunction.
@@ -1267,6 +1439,15 @@ func (e IteratorItem) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e IteratorItem) String() string {
+	switch e {
+		case IteratorItemSkip: return "IteratorItemSkip"
+		case IteratorItemPass: return "IteratorItemPass"
+		case IteratorItemEnd: return "IteratorItemEnd"
+		default: return fmt.Sprintf("IteratorItem(%d)", e)
+	}
+}
+
 // IteratorResult wraps GstIteratorResult
 //
 // The result of gst_iterator_next().
@@ -1302,6 +1483,16 @@ func (e IteratorResult) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e IteratorResult) String() string {
+	switch e {
+		case IteratorDone: return "IteratorDone"
+		case IteratorOK: return "IteratorOK"
+		case IteratorResync: return "IteratorResync"
+		case IteratorError: return "IteratorError"
+		default: return fmt.Sprintf("IteratorResult(%d)", e)
+	}
+}
+
 // LibraryError wraps GstLibraryError
 //
 // Library errors are for errors from the library being used by elements
@@ -1352,6 +1543,19 @@ func (e LibraryError) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e LibraryError) String() string {
+	switch e {
+		case LibraryErrorEncode: return "LibraryErrorEncode"
+		case LibraryErrorNumErrors: return "LibraryErrorNumErrors"
+		case LibraryErrorFailed: return "LibraryErrorFailed"
+		case LibraryErrorTooLaZY: return "LibraryErrorTooLaZY"
+		case LibraryErrorInit: return "LibraryErrorInit"
+		case LibraryErrorShutdown: return "LibraryErrorShutdown"
+		case LibraryErrorSettings: return "LibraryErrorSettings"
+		default: return fmt.Sprintf("LibraryError(%d)", e)
+	}
+}
+
 // PadDirection wraps GstPadDirection
 //
 // The direction of a pad.
@@ -1383,6 +1587,15 @@ func (e PadDirection) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e PadDirection) String() string {
+	switch e {
+		case PadUnknown: return "PadUnknown"
+		case PadSrc: return "PadSrc"
+		case PadSink: return "PadSink"
+		default: return fmt.Sprintf("PadDirection(%d)", e)
+	}
+}
+
 // PadLinkReturn wraps GstPadLinkReturn
 //
 // Result values from gst_pad_link and friends.
@@ -1430,6 +1643,19 @@ func (e PadLinkReturn) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e PadLinkReturn) String() string {
+	switch e {
+		case PadLinkNoformat: return "PadLinkNoformat"
+		case PadLinkNosched: return "PadLinkNosched"
+		case PadLinkRefused: return "PadLinkRefused"
+		case PadLinkOK: return "PadLinkOK"
+		case PadLinkWrongHierarchy: return "PadLinkWrongHierarchy"
+		case PadLinkWasLinked: return "PadLinkWasLinked"
+		case PadLinkWrongDirection: return "PadLinkWrongDirection"
+		default: return fmt.Sprintf("PadLinkReturn(%d)", e)
+	}
+}
+
 // PadMode wraps GstPadMode
 //
 // The status of a GstPad. After activating a pad, which usually happens when the
@@ -1463,6 +1689,15 @@ func (e PadMode) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e PadMode) String() string {
+	switch e {
+		case PadModePush: return "PadModePush"
+		case PadModePull: return "PadModePull"
+		case PadModeNone: return "PadModeNone"
+		default: return fmt.Sprintf("PadMode(%d)", e)
+	}
+}
+
 // PadPresence wraps GstPadPresence
 //
 // Indicates when this pad will become available.
@@ -1495,6 +1730,15 @@ func (e PadPresence) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e PadPresence) String() string {
+	switch e {
+		case PadAlways: return "PadAlways"
+		case PadSometimes: return "PadSometimes"
+		case PadRequest: return "PadRequest"
+		default: return fmt.Sprintf("PadPresence(%d)", e)
+	}
+}
+
 // PadProbeReturn wraps GstPadProbeReturn
 //
 // Different return values for the #GstPadProbeCallback.
@@ -1553,6 +1797,17 @@ func (e PadProbeReturn) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e PadProbeReturn) String() string {
+	switch e {
+		case PadProbeRemove: return "PadProbeRemove"
+		case PadProbePass: return "PadProbePass"
+		case PadProbeHandled: return "PadProbeHandled"
+		case PadProbeDrop: return "PadProbeDrop"
+		case PadProbeOK: return "PadProbeOK"
+		default: return fmt.Sprintf("PadProbeReturn(%d)", e)
+	}
+}
+
 // ParseError wraps GstParseError
 //
 // The different parsing errors that can occur.
@@ -1604,6 +1859,20 @@ func (e ParseError) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e ParseError) String() string {
+	switch e {
+		case ParseErrorNoSuchElement: return "ParseErrorNoSuchElement"
+		case ParseErrorNoSuchProperty: return "ParseErrorNoSuchProperty"
+		case ParseErrorLink: return "ParseErrorLink"
+		case ParseErrorCouldNotSetProperty: return "ParseErrorCouldNotSetProperty"
+		case ParseErrorEmptyBin: return "ParseErrorEmptyBin"
+		case ParseErrorEmpty: return "ParseErrorEmpty"
+		case ParseErrorDelayedLink: return "ParseErrorDelayedLink"
+		case ParseErrorSyntax: return "ParseErrorSyntax"
+		default: return fmt.Sprintf("ParseError(%d)", e)
+	}
+}
+
 // PluginError wraps GstPluginError
 //
 // The plugin loading errors
@@ -1635,6 +1904,15 @@ func (e PluginError) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e PluginError) String() string {
+	switch e {
+		case PluginErrorModule: return "PluginErrorModule"
+		case PluginErrorDependencies: return "PluginErrorDependencies"
+		case PluginErrorNameMismatch: return "PluginErrorNameMismatch"
+		default: return fmt.Sprintf("PluginError(%d)", e)
+	}
+}
+
 // ProgressType wraps GstProgressType
 //
 // The type of a %GST_MESSAGE_PROGRESS. The progress messages inform the
@@ -1676,6 +1954,17 @@ func (e ProgressType) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e ProgressType) String() string {
+	switch e {
+		case ProgressTypeCanceled: return "ProgressTypeCanceled"
+		case ProgressTypeError: return "ProgressTypeError"
+		case ProgressTypeStart: return "ProgressTypeStart"
+		case ProgressTypeContinue: return "ProgressTypeContinue"
+		case ProgressTypeComplete: return "ProgressTypeComplete"
+		default: return fmt.Sprintf("ProgressType(%d)", e)
+	}
+}
+
 // PromiseResult wraps GstPromiseResult
 //
 // The result of a #GstPromise
@@ -1714,6 +2003,16 @@ func (e PromiseResult) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e PromiseResult) String() string {
+	switch e {
+		case PromiseResultReplied: return "PromiseResultReplied"
+		case PromiseResultExpired: return "PromiseResultExpired"
+		case PromiseResultPending: return "PromiseResultPending"
+		case PromiseResultInterrupted: return "PromiseResultInterrupted"
+		default: return fmt.Sprintf("PromiseResult(%d)", e)
+	}
+}
+
 // QOSType wraps GstQOSType
 //
 // The different types of QoS events that can be given to the
@@ -1752,6 +2051,15 @@ func (e QOSType) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e QOSType) String() string {
+	switch e {
+		case QosTypeThrottle: return "QosTypeThrottle"
+		case QosTypeOverflow: return "QosTypeOverflow"
+		case QosTypeUnderflow: return "QosTypeUnderflow"
+		default: return fmt.Sprintf("QOSType(%d)", e)
+	}
+}
+
 // QueryType wraps GstQueryType
 //
 // Standard predefined Query types
@@ -1856,6 +2164,33 @@ func (e QueryType) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e QueryType) String() string {
+	switch e {
+		case QueryPosition: return "QueryPosition"
+		case QueryJitter: return "QueryJitter"
+		case QuerySeeking: return "QuerySeeking"
+		case QuerySegment: return "QuerySegment"
+		case QueryFormats: return "QueryFormats"
+		case QueryCustom: return "QueryCustom"
+		case QueryScheduling: return "QueryScheduling"
+		case QueryCaps: return "QueryCaps"
+		case QueryUnknown: return "QueryUnknown"
+		case QueryLatency: return "QueryLatency"
+		case QueryConvert: return "QueryConvert"
+		case QueryBuffering: return "QueryBuffering"
+		case QueryAllocation: return "QueryAllocation"
+		case QueryDrain: return "QueryDrain"
+		case QueryContext: return "QueryContext"
+		case QuerySelectable: return "QuerySelectable"
+		case QueryRate: return "QueryRate"
+		case QueryURI: return "QueryURI"
+		case QueryDuration: return "QueryDuration"
+		case QueryAcceptCaps: return "QueryAcceptCaps"
+		case QueryBitrate: return "QueryBitrate"
+		default: return fmt.Sprintf("QueryType(%d)", e)
+	}
+}
+
 // Rank wraps GstRank
 //
 // Element priority ranks. Defines the order in which the autoplugger (or
@@ -1897,6 +2232,16 @@ func (e Rank) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e Rank) String() string {
+	switch e {
+		case RankNone: return "RankNone"
+		case RankMarginal: return "RankMarginal"
+		case RankSecondary: return "RankSecondary"
+		case RankPrimary: return "RankPrimary"
+		default: return fmt.Sprintf("Rank(%d)", e)
+	}
+}
+
 // ResourceError wraps GstResourceError
 //
 // Resource errors are for any resource used by an element:
@@ -1987,6 +2332,28 @@ func (e ResourceError) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e ResourceError) String() string {
+	switch e {
+		case ResourceErrorFailed: return "ResourceErrorFailed"
+		case ResourceErrorTooLaZY: return "ResourceErrorTooLaZY"
+		case ResourceErrorOpenRead: return "ResourceErrorOpenRead"
+		case ResourceErrorSync: return "ResourceErrorSync"
+		case ResourceErrorOpenReadWrite: return "ResourceErrorOpenReadWrite"
+		case ResourceErrorNotAuthorized: return "ResourceErrorNotAuthorized"
+		case ResourceErrorNumErrors: return "ResourceErrorNumErrors"
+		case ResourceErrorNoSpaceLeft: return "ResourceErrorNoSpaceLeft"
+		case ResourceErrorBusy: return "ResourceErrorBusy"
+		case ResourceErrorOpenWrite: return "ResourceErrorOpenWrite"
+		case ResourceErrorSeek: return "ResourceErrorSeek"
+		case ResourceErrorSettings: return "ResourceErrorSettings"
+		case ResourceErrorNotFound: return "ResourceErrorNotFound"
+		case ResourceErrorClose: return "ResourceErrorClose"
+		case ResourceErrorRead: return "ResourceErrorRead"
+		case ResourceErrorWrite: return "ResourceErrorWrite"
+		default: return fmt.Sprintf("ResourceError(%d)", e)
+	}
+}
+
 // SearchMode wraps GstSearchMode
 //
 // The different search modes.
@@ -2018,6 +2385,15 @@ func (e SearchMode) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e SearchMode) String() string {
+	switch e {
+		case SearchModeBefore: return "SearchModeBefore"
+		case SearchModeAfter: return "SearchModeAfter"
+		case SearchModeExact: return "SearchModeExact"
+		default: return fmt.Sprintf("SearchMode(%d)", e)
+	}
+}
+
 // SeekType wraps GstSeekType
 //
 // The different types of seek events. When constructing a seek event with
@@ -2050,6 +2426,15 @@ func (e SeekType) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e SeekType) String() string {
+	switch e {
+		case SeekTypeNone: return "SeekTypeNone"
+		case SeekTypeSet: return "SeekTypeSet"
+		case SeekTypeEnd: return "SeekTypeEnd"
+		default: return fmt.Sprintf("SeekType(%d)", e)
+	}
+}
+
 // State wraps GstState
 //
 // The possible states an element can be in. States can be changed using
@@ -2093,6 +2478,17 @@ func (e State) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e State) String() string {
+	switch e {
+		case StateVoidPending: return "StateVoidPending"
+		case StateNull: return "StateNull"
+		case StateReady: return "StateReady"
+		case StatePaused: return "StatePaused"
+		case StatePlaying: return "StatePlaying"
+		default: return fmt.Sprintf("State(%d)", e)
+	}
+}
+
 // StateChange wraps GstStateChange
 //
 // These are the different state changes an element goes through.
@@ -2206,6 +2602,22 @@ func (e StateChange) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e StateChange) String() string {
+	switch e {
+		case StateChangePausedToPaused: return "StateChangePausedToPaused"
+		case StateChangePlayingToPlaying: return "StateChangePlayingToPlaying"
+		case StateChangeReadyToPaused: return "StateChangeReadyToPaused"
+		case StateChangePausedToPlaying: return "StateChangePausedToPlaying"
+		case StateChangeNullToNull: return "StateChangeNullToNull"
+		case StateChangeNullToReady: return "StateChangeNullToReady"
+		case StateChangePlayingToPaused: return "StateChangePlayingToPaused"
+		case StateChangePausedToReady: return "StateChangePausedToReady"
+		case StateChangeReadyToNull: return "StateChangeReadyToNull"
+		case StateChangeReadyToReady: return "StateChangeReadyToReady"
+		default: return fmt.Sprintf("StateChange(%d)", e)
+	}
+}
+
 // StateChangeReturn wraps GstStateChangeReturn
 //
 // The possible return values from a state change function such as
@@ -2244,6 +2656,16 @@ func (e StateChangeReturn) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e StateChangeReturn) String() string {
+	switch e {
+		case StateChangeFailure: return "StateChangeFailure"
+		case StateChangeSuccess: return "StateChangeSuccess"
+		case StateChangeAsync: return "StateChangeAsync"
+		case StateChangeNoPreroll: return "StateChangeNoPreroll"
+		default: return fmt.Sprintf("StateChangeReturn(%d)", e)
+	}
+}
+
 // StreamError wraps GstStreamError
 //
 // Stream errors are for anything related to the stream being processed:
@@ -2330,6 +2752,26 @@ func (e StreamError) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e StreamError) String() string {
+	switch e {
+		case StreamErrorCodecNotFound: return "StreamErrorCodecNotFound"
+		case StreamErrorDemux: return "StreamErrorDemux"
+		case StreamErrorMux: return "StreamErrorMux"
+		case StreamErrorFormat: return "StreamErrorFormat"
+		case StreamErrorDecrypt: return "StreamErrorDecrypt"
+		case StreamErrorFailed: return "StreamErrorFailed"
+		case StreamErrorTypeNotFound: return "StreamErrorTypeNotFound"
+		case StreamErrorDecode: return "StreamErrorDecode"
+		case StreamErrorEncode: return "StreamErrorEncode"
+		case StreamErrorDecryptNokey: return "StreamErrorDecryptNokey"
+		case StreamErrorNumErrors: return "StreamErrorNumErrors"
+		case StreamErrorTooLaZY: return "StreamErrorTooLaZY"
+		case StreamErrorNotImplemented: return "StreamErrorNotImplemented"
+		case StreamErrorWrongType: return "StreamErrorWrongType"
+		default: return fmt.Sprintf("StreamError(%d)", e)
+	}
+}
+
 // StreamStatusType wraps GstStreamStatusType
 //
 // The type of a %GST_MESSAGE_STREAM_STATUS. The stream status messages inform the
@@ -2378,6 +2820,19 @@ func (e StreamStatusType) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e StreamStatusType) String() string {
+	switch e {
+		case StreamStatusTypeEnter: return "StreamStatusTypeEnter"
+		case StreamStatusTypeLeave: return "StreamStatusTypeLeave"
+		case StreamStatusTypeDestroy: return "StreamStatusTypeDestroy"
+		case StreamStatusTypeStart: return "StreamStatusTypeStart"
+		case StreamStatusTypePause: return "StreamStatusTypePause"
+		case StreamStatusTypeStop: return "StreamStatusTypeStop"
+		case StreamStatusTypeCreate: return "StreamStatusTypeCreate"
+		default: return fmt.Sprintf("StreamStatusType(%d)", e)
+	}
+}
+
 // StructureChangeType wraps GstStructureChangeType
 //
 // The type of a %GST_MESSAGE_STRUCTURE_CHANGE.
@@ -2405,6 +2860,14 @@ func (e StructureChangeType) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e StructureChangeType) String() string {
+	switch e {
+		case StructureChangeTypePadLink: return "StructureChangeTypePadLink"
+		case StructureChangeTypePadUnlink: return "StructureChangeTypePadUnlink"
+		default: return fmt.Sprintf("StructureChangeType(%d)", e)
+	}
+}
+
 // TagFlag wraps GstTagFlag
 //
 // Extra tag flags used when registering tags.
@@ -2444,6 +2907,17 @@ func (e TagFlag) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e TagFlag) String() string {
+	switch e {
+		case TagFlagEncoded: return "TagFlagEncoded"
+		case TagFlagDecoded: return "TagFlagDecoded"
+		case TagFlagCount: return "TagFlagCount"
+		case TagFlagUndefined: return "TagFlagUndefined"
+		case TagFlagMeta: return "TagFlagMeta"
+		default: return fmt.Sprintf("TagFlag(%d)", e)
+	}
+}
+
 // TagMergeMode wraps GstTagMergeMode
 //
 // The different tag merging modes are basically replace, overwrite and append,
@@ -2510,6 +2984,20 @@ func (e TagMergeMode) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e TagMergeMode) String() string {
+	switch e {
+		case TagMergePrepend: return "TagMergePrepend"
+		case TagMergeKeep: return "TagMergeKeep"
+		case TagMergeKeepAll: return "TagMergeKeepAll"
+		case TagMergeCount: return "TagMergeCount"
+		case TagMergeUndefined: return "TagMergeUndefined"
+		case TagMergeReplaceAll: return "TagMergeReplaceAll"
+		case TagMergeReplace: return "TagMergeReplace"
+		case TagMergeAppend: return "TagMergeAppend"
+		default: return fmt.Sprintf("TagMergeMode(%d)", e)
+	}
+}
+
 // TagScope wraps GstTagScope
 //
 // GstTagScope specifies if a taglist applies to the complete
@@ -2538,6 +3026,14 @@ func (e TagScope) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e TagScope) String() string {
+	switch e {
+		case TagScopeStream: return "TagScopeStream"
+		case TagScopeGlobal: return "TagScopeGlobal"
+		default: return fmt.Sprintf("TagScope(%d)", e)
+	}
+}
+
 // TaskState wraps GstTaskState
 //
 // The different states a task can be in
@@ -2569,6 +3065,15 @@ func (e TaskState) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e TaskState) String() string {
+	switch e {
+		case TaskStarted: return "TaskStarted"
+		case TaskStopped: return "TaskStopped"
+		case TaskPaused: return "TaskPaused"
+		default: return fmt.Sprintf("TaskState(%d)", e)
+	}
+}
+
 // TocEntryType wraps GstTocEntryType
 //
 // The different types of TOC entries (see #GstTocEntry).
@@ -2618,6 +3123,19 @@ func (e TocEntryType) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e TocEntryType) String() string {
+	switch e {
+		case TocEntryTypeTrack: return "TocEntryTypeTrack"
+		case TocEntryTypeChapter: return "TocEntryTypeChapter"
+		case TocEntryTypeAngle: return "TocEntryTypeAngle"
+		case TocEntryTypeVersion: return "TocEntryTypeVersion"
+		case TocEntryTypeEdition: return "TocEntryTypeEdition"
+		case TocEntryTypeInvalid: return "TocEntryTypeInvalid"
+		case TocEntryTypeTitle: return "TocEntryTypeTitle"
+		default: return fmt.Sprintf("TocEntryType(%d)", e)
+	}
+}
+
 // TocLoopType wraps GstTocLoopType
 //
 // How a #GstTocEntry should be repeated. By default, entries are played a
@@ -2654,6 +3172,16 @@ func (e TocLoopType) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e TocLoopType) String() string {
+	switch e {
+		case TocLoopNone: return "TocLoopNone"
+		case TocLoopForward: return "TocLoopForward"
+		case TocLoopReverse: return "TocLoopReverse"
+		case TocLoopPingPong: return "TocLoopPingPong"
+		default: return fmt.Sprintf("TocLoopType(%d)", e)
+	}
+}
+
 // TocScope wraps GstTocScope
 //
 // The scope of a TOC.
@@ -2687,6 +3215,14 @@ func (e TocScope) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e TocScope) String() string {
+	switch e {
+		case TocScopeGlobal: return "TocScopeGlobal"
+		case TocScopeCurrent: return "TocScopeCurrent"
+		default: return fmt.Sprintf("TocScope(%d)", e)
+	}
+}
+
 // TracerValueScope wraps GstTracerValueScope
 //
 // Tracing record will contain fields that contain a measured value or extra
@@ -2726,6 +3262,16 @@ func (e TracerValueScope) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e TracerValueScope) String() string {
+	switch e {
+		case TracerValueScopeElement: return "TracerValueScopeElement"
+		case TracerValueScopePad: return "TracerValueScopePad"
+		case TracerValueScopeProcess: return "TracerValueScopeProcess"
+		case TracerValueScopeThread: return "TracerValueScopeThread"
+		default: return fmt.Sprintf("TracerValueScope(%d)", e)
+	}
+}
+
 // TypeFindProbability wraps GstTypeFindProbability
 //
 // The probability of the typefind function. Higher values have more certainty
@@ -2770,6 +3316,18 @@ func (e TypeFindProbability) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e TypeFindProbability) String() string {
+	switch e {
+		case TypeFindNearlyCertain: return "TypeFindNearlyCertain"
+		case TypeFindMaximum: return "TypeFindMaximum"
+		case TypeFindNone: return "TypeFindNone"
+		case TypeFindMinimum: return "TypeFindMinimum"
+		case TypeFindPossible: return "TypeFindPossible"
+		case TypeFindLikely: return "TypeFindLikely"
+		default: return fmt.Sprintf("TypeFindProbability(%d)", e)
+	}
+}
+
 // URIError wraps GstURIError
 //
 // Different URI-related errors that can occur.
@@ -2807,6 +3365,16 @@ func (e URIError) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e URIError) String() string {
+	switch e {
+		case URIErrorUnsupportedProtocol: return "URIErrorUnsupportedProtocol"
+		case URIErrorBadURI: return "URIErrorBadURI"
+		case URIErrorBadState: return "URIErrorBadState"
+		case URIErrorBadReference: return "URIErrorBadReference"
+		default: return fmt.Sprintf("URIError(%d)", e)
+	}
+}
+
 // URIType wraps GstURIType
 //
 // The different types of URI direction.
@@ -2838,6 +3406,15 @@ func (e URIType) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e URIType) String() string {
+	switch e {
+		case URIUnknown: return "URIUnknown"
+		case URISink: return "URISink"
+		case URISrc: return "URISrc"
+		default: return fmt.Sprintf("URIType(%d)", e)
+	}
+}
+
 // AllocatorFlags wraps GstAllocatorFlags
 //
 // Flags for allocators.
@@ -2879,6 +3456,24 @@ func (f AllocatorFlags) InitGoValue(v *gobject.Value) {
 	v.SetFlags(int(f))
 }
 
+func (f AllocatorFlags) String() string {
+	if f == 0 {
+		return "AllocatorFlags(0)"
+	}
+
+	var parts []string
+	if (f & AllocatorFlagCustomAlloc) != 0 {
+		parts = append(parts, "AllocatorFlagCustomAlloc")
+	}
+	if (f & AllocatorFlagNoCopy) != 0 {
+		parts = append(parts, "AllocatorFlagNoCopy")
+	}
+	if (f & AllocatorFlagLast) != 0 {
+		parts = append(parts, "AllocatorFlagLast")
+	}
+	return "AllocatorFlags(" + strings.Join(parts, "|") + ")"
+}
+
 // BinFlags wraps GstBinFlags
 //
 // GstBinFlags are a set of flags specific to bins. Most are set/used
@@ -2918,6 +3513,24 @@ func (f BinFlags) InitGoValue(v *gobject.Value) {
 	v.SetFlags(int(f))
 }
 
+func (f BinFlags) String() string {
+	if f == 0 {
+		return "BinFlags(0)"
+	}
+
+	var parts []string
+	if (f & BinFlagNoResync) != 0 {
+		parts = append(parts, "BinFlagNoResync")
+	}
+	if (f & BinFlagStreamsAware) != 0 {
+		parts = append(parts, "BinFlagStreamsAware")
+	}
+	if (f & BinFlagLast) != 0 {
+		parts = append(parts, "BinFlagLast")
+	}
+	return "BinFlags(" + strings.Join(parts, "|") + ")"
+}
+
 // BufferCopyFlagsType wraps GstBufferCopyFlags
 //
 // A set of flags that can be provided to the gst_buffer_copy_into()
@@ -2978,6 +3591,36 @@ func (f BufferCopyFlagsType) InitGoValue(v *gobject.Value) {
 	v.SetFlags(int(f))
 }
 
+func (f BufferCopyFlagsType) String() string {
+	if f == 0 {
+		return "BufferCopyFlagsType(0)"
+	}
+
+	var parts []string
+	if (f & BufferCopyNone) != 0 {
+		parts = append(parts, "BufferCopyNone")
+	}
+	if (f & BufferCopyFlags) != 0 {
+		parts = append(parts, "BufferCopyFlags")
+	}
+	if (f & BufferCopyTimestamps) != 0 {
+		parts = append(parts, "BufferCopyTimestamps")
+	}
+	if (f & BufferCopyMeta) != 0 {
+		parts = append(parts, "BufferCopyMeta")
+	}
+	if (f & BufferCopyMemory) != 0 {
+		parts = append(parts, "BufferCopyMemory")
+	}
+	if (f & BufferCopyMerge) != 0 {
+		parts = append(parts, "BufferCopyMerge")
+	}
+	if (f & BufferCopyDeep) != 0 {
+		parts = append(parts, "BufferCopyDeep")
+	}
+	return "BufferCopyFlagsType(" + strings.Join(parts, "|") + ")"
+}
+
 // BufferFlags wraps GstBufferFlags
 //
 // A set of buffer flags used to describe properties of a #GstBuffer.
@@ -3081,6 +3724,57 @@ func (f BufferFlags) InitGoValue(v *gobject.Value) {
 	v.SetFlags(int(f))
 }
 
+func (f BufferFlags) String() string {
+	if f == 0 {
+		return "BufferFlags(0)"
+	}
+
+	var parts []string
+	if (f & BufferFlagLive) != 0 {
+		parts = append(parts, "BufferFlagLive")
+	}
+	if (f & BufferFlagDecodeOnly) != 0 {
+		parts = append(parts, "BufferFlagDecodeOnly")
+	}
+	if (f & BufferFlagDiscont) != 0 {
+		parts = append(parts, "BufferFlagDiscont")
+	}
+	if (f & BufferFlagResync) != 0 {
+		parts = append(parts, "BufferFlagResync")
+	}
+	if (f & BufferFlagCorrupted) != 0 {
+		parts = append(parts, "BufferFlagCorrupted")
+	}
+	if (f & BufferFlagMarker) != 0 {
+		parts = append(parts, "BufferFlagMarker")
+	}
+	if (f & BufferFlagHeader) != 0 {
+		parts = append(parts, "BufferFlagHeader")
+	}
+	if (f & BufferFlagGap) != 0 {
+		parts = append(parts, "BufferFlagGap")
+	}
+	if (f & BufferFlagDroppable) != 0 {
+		parts = append(parts, "BufferFlagDroppable")
+	}
+	if (f & BufferFlagDeltaUnit) != 0 {
+		parts = append(parts, "BufferFlagDeltaUnit")
+	}
+	if (f & BufferFlagTagMemory) != 0 {
+		parts = append(parts, "BufferFlagTagMemory")
+	}
+	if (f & BufferFlagSyncAfter) != 0 {
+		parts = append(parts, "BufferFlagSyncAfter")
+	}
+	if (f & BufferFlagNonDroppable) != 0 {
+		parts = append(parts, "BufferFlagNonDroppable")
+	}
+	if (f & BufferFlagLast) != 0 {
+		parts = append(parts, "BufferFlagLast")
+	}
+	return "BufferFlags(" + strings.Join(parts, "|") + ")"
+}
+
 // BufferPoolAcquireFlags wraps GstBufferPoolAcquireFlags
 //
 // Additional flags to control the allocation of a buffer
@@ -3127,6 +3821,30 @@ func (f BufferPoolAcquireFlags) InitGoValue(v *gobject.Value) {
 	v.SetFlags(int(f))
 }
 
+func (f BufferPoolAcquireFlags) String() string {
+	if f == 0 {
+		return "BufferPoolAcquireFlags(0)"
+	}
+
+	var parts []string
+	if (f & BufferPoolAcquireFlagNone) != 0 {
+		parts = append(parts, "BufferPoolAcquireFlagNone")
+	}
+	if (f & BufferPoolAcquireFlagKeyUnit) != 0 {
+		parts = append(parts, "BufferPoolAcquireFlagKeyUnit")
+	}
+	if (f & BufferPoolAcquireFlagDontwait) != 0 {
+		parts = append(parts, "BufferPoolAcquireFlagDontwait")
+	}
+	if (f & BufferPoolAcquireFlagDiscont) != 0 {
+		parts = append(parts, "BufferPoolAcquireFlagDiscont")
+	}
+	if (f & BufferPoolAcquireFlagLast) != 0 {
+		parts = append(parts, "BufferPoolAcquireFlagLast")
+	}
+	return "BufferPoolAcquireFlags(" + strings.Join(parts, "|") + ")"
+}
+
 // BusFlags wraps GstBusFlags
 //
 // The standard flags that a bus may have.
@@ -3158,6 +3876,21 @@ func (f BusFlags) InitGoValue(v *gobject.Value) {
 	v.SetFlags(int(f))
 }
 
+func (f BusFlags) String() string {
+	if f == 0 {
+		return "BusFlags(0)"
+	}
+
+	var parts []string
+	if (f & BusFlushing) != 0 {
+		parts = append(parts, "BusFlushing")
+	}
+	if (f & BusFlagLast) != 0 {
+		parts = append(parts, "BusFlagLast")
+	}
+	return "BusFlags(" + strings.Join(parts, "|") + ")"
+}
+
 // CapsFlags wraps GstCapsFlags
 //
 // Extra flags for a caps.
@@ -3186,6 +3919,18 @@ func (f CapsFlags) InitGoValue(v *gobject.Value) {
 	v.SetFlags(int(f))
 }
 
+func (f CapsFlags) String() string {
+	if f == 0 {
+		return "CapsFlags(0)"
+	}
+
+	var parts []string
+	if (f & CapsFlagAny) != 0 {
+		parts = append(parts, "CapsFlagAny")
+	}
+	return "CapsFlags(" + strings.Join(parts, "|") + ")"
+}
+
 // ClockFlags wraps GstClockFlags
 //
 // The capabilities of this clock
@@ -3241,6 +3986,39 @@ func (f ClockFlags) InitGoValue(v *gobject.Value) {
 	v.SetFlags(int(f))
 }
 
+func (f ClockFlags) String() string {
+	if f == 0 {
+		return "ClockFlags(0)"
+	}
+
+	var parts []string
+	if (f & ClockFlagCanDoSingleSync) != 0 {
+		parts = append(parts, "ClockFlagCanDoSingleSync")
+	}
+	if (f & ClockFlagCanDoSingleAsync) != 0 {
+		parts = append(parts, "ClockFlagCanDoSingleAsync")
+	}
+	if (f & ClockFlagCanDoPeriodicSync) != 0 {
+		parts = append(parts, "ClockFlagCanDoPeriodicSync")
+	}
+	if (f & ClockFlagCanDoPeriodicAsync) != 0 {
+		parts = append(parts, "ClockFlagCanDoPeriodicAsync")
+	}
+	if (f & ClockFlagCanSetResolution) != 0 {
+		parts = append(parts, "ClockFlagCanSetResolution")
+	}
+	if (f & ClockFlagCanSetMaster) != 0 {
+		parts = append(parts, "ClockFlagCanSetMaster")
+	}
+	if (f & ClockFlagNeedsStartupSync) != 0 {
+		parts = append(parts, "ClockFlagNeedsStartupSync")
+	}
+	if (f & ClockFlagLast) != 0 {
+		parts = append(parts, "ClockFlagLast")
+	}
+	return "ClockFlags(" + strings.Join(parts, "|") + ")"
+}
+
 // DebugColorFlags wraps GstDebugColorFlags
 //
 // These are some terminal style flags you can use when creating your
@@ -3337,6 +4115,69 @@ func (f DebugColorFlags) InitGoValue(v *gobject.Value) {
 	v.SetFlags(int(f))
 }
 
+func (f DebugColorFlags) String() string {
+	if f == 0 {
+		return "DebugColorFlags(0)"
+	}
+
+	var parts []string
+	if (f & DebugFgBlack) != 0 {
+		parts = append(parts, "DebugFgBlack")
+	}
+	if (f & DebugFgRed) != 0 {
+		parts = append(parts, "DebugFgRed")
+	}
+	if (f & DebugFgGreen) != 0 {
+		parts = append(parts, "DebugFgGreen")
+	}
+	if (f & DebugFgYellow) != 0 {
+		parts = append(parts, "DebugFgYellow")
+	}
+	if (f & DebugFgBlue) != 0 {
+		parts = append(parts, "DebugFgBlue")
+	}
+	if (f & DebugFgMagenta) != 0 {
+		parts = append(parts, "DebugFgMagenta")
+	}
+	if (f & DebugFgCyan) != 0 {
+		parts = append(parts, "DebugFgCyan")
+	}
+	if (f & DebugFgWhite) != 0 {
+		parts = append(parts, "DebugFgWhite")
+	}
+	if (f & DebugBgBlack) != 0 {
+		parts = append(parts, "DebugBgBlack")
+	}
+	if (f & DebugBgRed) != 0 {
+		parts = append(parts, "DebugBgRed")
+	}
+	if (f & DebugBgGreen) != 0 {
+		parts = append(parts, "DebugBgGreen")
+	}
+	if (f & DebugBgYellow) != 0 {
+		parts = append(parts, "DebugBgYellow")
+	}
+	if (f & DebugBgBlue) != 0 {
+		parts = append(parts, "DebugBgBlue")
+	}
+	if (f & DebugBgMagenta) != 0 {
+		parts = append(parts, "DebugBgMagenta")
+	}
+	if (f & DebugBgCyan) != 0 {
+		parts = append(parts, "DebugBgCyan")
+	}
+	if (f & DebugBgWhite) != 0 {
+		parts = append(parts, "DebugBgWhite")
+	}
+	if (f & DebugBold) != 0 {
+		parts = append(parts, "DebugBold")
+	}
+	if (f & DebugUnderline) != 0 {
+		parts = append(parts, "DebugUnderline")
+	}
+	return "DebugColorFlags(" + strings.Join(parts, "|") + ")"
+}
+
 // DebugGraphDetails wraps GstDebugGraphDetails
 //
 // Available details for pipeline graphs produced by GST_DEBUG_BIN_TO_DOT_FILE()
@@ -3392,6 +4233,36 @@ func (f DebugGraphDetails) InitGoValue(v *gobject.Value) {
 	v.SetFlags(int(f))
 }
 
+func (f DebugGraphDetails) String() string {
+	if f == 0 {
+		return "DebugGraphDetails(0)"
+	}
+
+	var parts []string
+	if (f & DebugGraphShowMediaType) != 0 {
+		parts = append(parts, "DebugGraphShowMediaType")
+	}
+	if (f & DebugGraphShowCapsDetails) != 0 {
+		parts = append(parts, "DebugGraphShowCapsDetails")
+	}
+	if (f & DebugGraphShowNonDefaultParams) != 0 {
+		parts = append(parts, "DebugGraphShowNonDefaultParams")
+	}
+	if (f & DebugGraphShowStates) != 0 {
+		parts = append(parts, "DebugGraphShowStates")
+	}
+	if (f & DebugGraphShowFullParams) != 0 {
+		parts = append(parts, "DebugGraphShowFullParams")
+	}
+	if (f & DebugGraphShowAll) != 0 {
+		parts = append(parts, "DebugGraphShowAll")
+	}
+	if (f & DebugGraphShowVerbose) != 0 {
+		parts = append(parts, "DebugGraphShowVerbose")
+	}
+	return "DebugGraphDetails(" + strings.Join(parts, "|") + ")"
+}
+
 // ElementFlags wraps GstElementFlags
 //
 // The standard flags that an element may have.
@@ -3443,6 +4314,36 @@ func (f ElementFlags) InitGoValue(v *gobject.Value) {
 	v.SetFlags(int(f))
 }
 
+func (f ElementFlags) String() string {
+	if f == 0 {
+		return "ElementFlags(0)"
+	}
+
+	var parts []string
+	if (f & ElementFlagLockedState) != 0 {
+		parts = append(parts, "ElementFlagLockedState")
+	}
+	if (f & ElementFlagSink) != 0 {
+		parts = append(parts, "ElementFlagSink")
+	}
+	if (f & ElementFlagSource) != 0 {
+		parts = append(parts, "ElementFlagSource")
+	}
+	if (f & ElementFlagProvideClock) != 0 {
+		parts = append(parts, "ElementFlagProvideClock")
+	}
+	if (f & ElementFlagRequireClock) != 0 {
+		parts = append(parts, "ElementFlagRequireClock")
+	}
+	if (f & ElementFlagIndexable) != 0 {
+		parts = append(parts, "ElementFlagIndexable")
+	}
+	if (f & ElementFlagLast) != 0 {
+		parts = append(parts, "ElementFlagLast")
+	}
+	return "ElementFlags(" + strings.Join(parts, "|") + ")"
+}
+
 // EventTypeFlags wraps GstEventTypeFlags
 //
 // #GstEventTypeFlags indicate the aspects of the different #GstEventType
@@ -3490,6 +4391,30 @@ func (f EventTypeFlags) InitGoValue(v *gobject.Value) {
 	v.SetFlags(int(f))
 }
 
+func (f EventTypeFlags) String() string {
+	if f == 0 {
+		return "EventTypeFlags(0)"
+	}
+
+	var parts []string
+	if (f & EventTypeUpstream) != 0 {
+		parts = append(parts, "EventTypeUpstream")
+	}
+	if (f & EventTypeDownstream) != 0 {
+		parts = append(parts, "EventTypeDownstream")
+	}
+	if (f & EventTypeSerialized) != 0 {
+		parts = append(parts, "EventTypeSerialized")
+	}
+	if (f & EventTypeSticky) != 0 {
+		parts = append(parts, "EventTypeSticky")
+	}
+	if (f & EventTypeStickyMulti) != 0 {
+		parts = append(parts, "EventTypeStickyMulti")
+	}
+	return "EventTypeFlags(" + strings.Join(parts, "|") + ")"
+}
+
 // GapFlags wraps GstGapFlags
 //
 // The different flags that can be set on #GST_EVENT_GAP events. See
@@ -3519,6 +4444,18 @@ func (f GapFlags) InitGoValue(v *gobject.Value) {
 	v.SetFlags(int(f))
 }
 
+func (f GapFlags) String() string {
+	if f == 0 {
+		return "GapFlags(0)"
+	}
+
+	var parts []string
+	if (f & GapFlagMissingData) != 0 {
+		parts = append(parts, "GapFlagMissingData")
+	}
+	return "GapFlags(" + strings.Join(parts, "|") + ")"
+}
+
 // LockFlags wraps GstLockFlags
 //
 // Flags used when locking miniobjects
@@ -3558,6 +4495,27 @@ func (f LockFlags) InitGoValue(v *gobject.Value) {
 	v.SetFlags(int(f))
 }
 
+func (f LockFlags) String() string {
+	if f == 0 {
+		return "LockFlags(0)"
+	}
+
+	var parts []string
+	if (f & LockFlagRead) != 0 {
+		parts = append(parts, "LockFlagRead")
+	}
+	if (f & LockFlagWrite) != 0 {
+		parts = append(parts, "LockFlagWrite")
+	}
+	if (f & LockFlagExclusive) != 0 {
+		parts = append(parts, "LockFlagExclusive")
+	}
+	if (f & LockFlagLast) != 0 {
+		parts = append(parts, "LockFlagLast")
+	}
+	return "LockFlags(" + strings.Join(parts, "|") + ")"
+}
+
 // MapFlags wraps GstMapFlags
 //
 // Flags used when mapping memory
@@ -3593,6 +4551,24 @@ func (f MapFlags) InitGoValue(v *gobject.Value) {
 	v.SetFlags(int(f))
 }
 
+func (f MapFlags) String() string {
+	if f == 0 {
+		return "MapFlags(0)"
+	}
+
+	var parts []string
+	if (f & MapRead) != 0 {
+		parts = append(parts, "MapRead")
+	}
+	if (f & MapWrite) != 0 {
+		parts = append(parts, "MapWrite")
+	}
+	if (f & MapFlagLast) != 0 {
+		parts = append(parts, "MapFlagLast")
+	}
+	return "MapFlags(" + strings.Join(parts, "|") + ")"
+}
+
 // MemoryFlags wraps GstMemoryFlags
 //
 // Flags for wrapped memory.
@@ -3651,6 +4627,36 @@ func (f MemoryFlags) InitGoValue(v *gobject.Value) {
 	v.SetFlags(int(f))
 }
 
+func (f MemoryFlags) String() string {
+	if f == 0 {
+		return "MemoryFlags(0)"
+	}
+
+	var parts []string
+	if (f & MemoryFlagReadonly) != 0 {
+		parts = append(parts, "MemoryFlagReadonly")
+	}
+	if (f & MemoryFlagNoShare) != 0 {
+		parts = append(parts, "MemoryFlagNoShare")
+	}
+	if (f & MemoryFlagZeroPrefixed) != 0 {
+		parts = append(parts, "MemoryFlagZeroPrefixed")
+	}
+	if (f & MemoryFlagZeroPadded) != 0 {
+		parts = append(parts, "MemoryFlagZeroPadded")
+	}
+	if (f & MemoryFlagPhysicallyContiguous) != 0 {
+		parts = append(parts, "MemoryFlagPhysicallyContiguous")
+	}
+	if (f & MemoryFlagNotMappable) != 0 {
+		parts = append(parts, "MemoryFlagNotMappable")
+	}
+	if (f & MemoryFlagLast) != 0 {
+		parts = append(parts, "MemoryFlagLast")
+	}
+	return "MemoryFlags(" + strings.Join(parts, "|") + ")"
+}
+
 // MessageType wraps GstMessageType
 //
 // The different message types that are available.
@@ -3897,6 +4903,141 @@ func (f MessageType) InitGoValue(v *gobject.Value) {
 	v.SetFlags(int(f))
 }
 
+func (f MessageType) String() string {
+	if f == 0 {
+		return "MessageType(0)"
+	}
+
+	var parts []string
+	if (f & MessageUnknown) != 0 {
+		parts = append(parts, "MessageUnknown")
+	}
+	if (f & MessageEos) != 0 {
+		parts = append(parts, "MessageEos")
+	}
+	if (f & MessageError) != 0 {
+		parts = append(parts, "MessageError")
+	}
+	if (f & MessageWarning) != 0 {
+		parts = append(parts, "MessageWarning")
+	}
+	if (f & MessageInfo) != 0 {
+		parts = append(parts, "MessageInfo")
+	}
+	if (f & MessageTag) != 0 {
+		parts = append(parts, "MessageTag")
+	}
+	if (f & MessageBuffering) != 0 {
+		parts = append(parts, "MessageBuffering")
+	}
+	if (f & MessageStateChanged) != 0 {
+		parts = append(parts, "MessageStateChanged")
+	}
+	if (f & MessageStateDirty) != 0 {
+		parts = append(parts, "MessageStateDirty")
+	}
+	if (f & MessageStepDone) != 0 {
+		parts = append(parts, "MessageStepDone")
+	}
+	if (f & MessageClockProvide) != 0 {
+		parts = append(parts, "MessageClockProvide")
+	}
+	if (f & MessageClockLost) != 0 {
+		parts = append(parts, "MessageClockLost")
+	}
+	if (f & MessageNewClock) != 0 {
+		parts = append(parts, "MessageNewClock")
+	}
+	if (f & MessageStructureChange) != 0 {
+		parts = append(parts, "MessageStructureChange")
+	}
+	if (f & MessageStreamStatus) != 0 {
+		parts = append(parts, "MessageStreamStatus")
+	}
+	if (f & MessageApplication) != 0 {
+		parts = append(parts, "MessageApplication")
+	}
+	if (f & MessageElement) != 0 {
+		parts = append(parts, "MessageElement")
+	}
+	if (f & MessageSegmentStart) != 0 {
+		parts = append(parts, "MessageSegmentStart")
+	}
+	if (f & MessageSegmentDone) != 0 {
+		parts = append(parts, "MessageSegmentDone")
+	}
+	if (f & MessageDurationChanged) != 0 {
+		parts = append(parts, "MessageDurationChanged")
+	}
+	if (f & MessageLatency) != 0 {
+		parts = append(parts, "MessageLatency")
+	}
+	if (f & MessageAsyncStart) != 0 {
+		parts = append(parts, "MessageAsyncStart")
+	}
+	if (f & MessageAsyncDone) != 0 {
+		parts = append(parts, "MessageAsyncDone")
+	}
+	if (f & MessageRequestState) != 0 {
+		parts = append(parts, "MessageRequestState")
+	}
+	if (f & MessageStepStart) != 0 {
+		parts = append(parts, "MessageStepStart")
+	}
+	if (f & MessageQos) != 0 {
+		parts = append(parts, "MessageQos")
+	}
+	if (f & MessageProgress) != 0 {
+		parts = append(parts, "MessageProgress")
+	}
+	if (f & MessageToc) != 0 {
+		parts = append(parts, "MessageToc")
+	}
+	if (f & MessageResetTime) != 0 {
+		parts = append(parts, "MessageResetTime")
+	}
+	if (f & MessageStreamStart) != 0 {
+		parts = append(parts, "MessageStreamStart")
+	}
+	if (f & MessageNeedContext) != 0 {
+		parts = append(parts, "MessageNeedContext")
+	}
+	if (f & MessageHaveContext) != 0 {
+		parts = append(parts, "MessageHaveContext")
+	}
+	if (f & MessageExtended) != 0 {
+		parts = append(parts, "MessageExtended")
+	}
+	if (f & MessageDeviceAdded) != 0 {
+		parts = append(parts, "MessageDeviceAdded")
+	}
+	if (f & MessageDeviceRemoved) != 0 {
+		parts = append(parts, "MessageDeviceRemoved")
+	}
+	if (f & MessagePropertyNotify) != 0 {
+		parts = append(parts, "MessagePropertyNotify")
+	}
+	if (f & MessageStreamCollection) != 0 {
+		parts = append(parts, "MessageStreamCollection")
+	}
+	if (f & MessageStreamsSelected) != 0 {
+		parts = append(parts, "MessageStreamsSelected")
+	}
+	if (f & MessageRedirect) != 0 {
+		parts = append(parts, "MessageRedirect")
+	}
+	if (f & MessageDeviceChanged) != 0 {
+		parts = append(parts, "MessageDeviceChanged")
+	}
+	if (f & MessageInstantRateRequest) != 0 {
+		parts = append(parts, "MessageInstantRateRequest")
+	}
+	if (f & MessageAny) != 0 {
+		parts = append(parts, "MessageAny")
+	}
+	return "MessageType(" + strings.Join(parts, "|") + ")"
+}
+
 // MetaFlags wraps GstMetaFlags
 //
 // Extra metadata flags.
@@ -3940,6 +5081,30 @@ func (f MetaFlags) InitGoValue(v *gobject.Value) {
 	v.SetFlags(int(f))
 }
 
+func (f MetaFlags) String() string {
+	if f == 0 {
+		return "MetaFlags(0)"
+	}
+
+	var parts []string
+	if (f & MetaFlagNone) != 0 {
+		parts = append(parts, "MetaFlagNone")
+	}
+	if (f & MetaFlagReadonly) != 0 {
+		parts = append(parts, "MetaFlagReadonly")
+	}
+	if (f & MetaFlagPooled) != 0 {
+		parts = append(parts, "MetaFlagPooled")
+	}
+	if (f & MetaFlagLocked) != 0 {
+		parts = append(parts, "MetaFlagLocked")
+	}
+	if (f & MetaFlagLast) != 0 {
+		parts = append(parts, "MetaFlagLast")
+	}
+	return "MetaFlags(" + strings.Join(parts, "|") + ")"
+}
+
 // MiniObjectFlags wraps GstMiniObjectFlags
 //
 // Flags for the mini object
@@ -3983,6 +5148,27 @@ func (f MiniObjectFlags) InitGoValue(v *gobject.Value) {
 	v.SetFlags(int(f))
 }
 
+func (f MiniObjectFlags) String() string {
+	if f == 0 {
+		return "MiniObjectFlags(0)"
+	}
+
+	var parts []string
+	if (f & MiniObjectFlagLockable) != 0 {
+		parts = append(parts, "MiniObjectFlagLockable")
+	}
+	if (f & MiniObjectFlagLockReadonly) != 0 {
+		parts = append(parts, "MiniObjectFlagLockReadonly")
+	}
+	if (f & MiniObjectFlagMayBeLeaked) != 0 {
+		parts = append(parts, "MiniObjectFlagMayBeLeaked")
+	}
+	if (f & MiniObjectFlagLast) != 0 {
+		parts = append(parts, "MiniObjectFlagLast")
+	}
+	return "MiniObjectFlags(" + strings.Join(parts, "|") + ")"
+}
+
 // ObjectFlags wraps GstObjectFlags
 //
 // The standard flags that an gstobject may have.
@@ -4025,6 +5211,24 @@ func (f ObjectFlags) InitGoValue(v *gobject.Value) {
 	v.SetFlags(int(f))
 }
 
+func (f ObjectFlags) String() string {
+	if f == 0 {
+		return "ObjectFlags(0)"
+	}
+
+	var parts []string
+	if (f & ObjectFlagMayBeLeaked) != 0 {
+		parts = append(parts, "ObjectFlagMayBeLeaked")
+	}
+	if (f & ObjectFlagConstructed) != 0 {
+		parts = append(parts, "ObjectFlagConstructed")
+	}
+	if (f & ObjectFlagLast) != 0 {
+		parts = append(parts, "ObjectFlagLast")
+	}
+	return "ObjectFlags(" + strings.Join(parts, "|") + ")"
+}
+
 // PadFlags wraps GstPadFlags
 //
 // Pad state flags
@@ -4121,6 +5325,57 @@ func (f PadFlags) InitGoValue(v *gobject.Value) {
 	v.SetFlags(int(f))
 }
 
+func (f PadFlags) String() string {
+	if f == 0 {
+		return "PadFlags(0)"
+	}
+
+	var parts []string
+	if (f & PadFlagBlocked) != 0 {
+		parts = append(parts, "PadFlagBlocked")
+	}
+	if (f & PadFlagFlushing) != 0 {
+		parts = append(parts, "PadFlagFlushing")
+	}
+	if (f & PadFlagEos) != 0 {
+		parts = append(parts, "PadFlagEos")
+	}
+	if (f & PadFlagBlocking) != 0 {
+		parts = append(parts, "PadFlagBlocking")
+	}
+	if (f & PadFlagNeedParent) != 0 {
+		parts = append(parts, "PadFlagNeedParent")
+	}
+	if (f & PadFlagNeedReconfigure) != 0 {
+		parts = append(parts, "PadFlagNeedReconfigure")
+	}
+	if (f & PadFlagPendingEvents) != 0 {
+		parts = append(parts, "PadFlagPendingEvents")
+	}
+	if (f & PadFlagFixedCaps) != 0 {
+		parts = append(parts, "PadFlagFixedCaps")
+	}
+	if (f & PadFlagProxyCaps) != 0 {
+		parts = append(parts, "PadFlagProxyCaps")
+	}
+	if (f & PadFlagProxyAllocation) != 0 {
+		parts = append(parts, "PadFlagProxyAllocation")
+	}
+	if (f & PadFlagProxyScheduling) != 0 {
+		parts = append(parts, "PadFlagProxyScheduling")
+	}
+	if (f & PadFlagAcceptIntersect) != 0 {
+		parts = append(parts, "PadFlagAcceptIntersect")
+	}
+	if (f & PadFlagAcceptTemplate) != 0 {
+		parts = append(parts, "PadFlagAcceptTemplate")
+	}
+	if (f & PadFlagLast) != 0 {
+		parts = append(parts, "PadFlagLast")
+	}
+	return "PadFlags(" + strings.Join(parts, "|") + ")"
+}
+
 // PadLinkCheck wraps GstPadLinkCheck
 //
 // The amount of checking to be done when linking pads. @GST_PAD_LINK_CHECK_CAPS
@@ -4182,6 +5437,33 @@ func (f PadLinkCheck) InitGoValue(v *gobject.Value) {
 	v.SetFlags(int(f))
 }
 
+func (f PadLinkCheck) String() string {
+	if f == 0 {
+		return "PadLinkCheck(0)"
+	}
+
+	var parts []string
+	if (f & PadLinkCheckNothing) != 0 {
+		parts = append(parts, "PadLinkCheckNothing")
+	}
+	if (f & PadLinkCheckHierarchy) != 0 {
+		parts = append(parts, "PadLinkCheckHierarchy")
+	}
+	if (f & PadLinkCheckTemplateCaps) != 0 {
+		parts = append(parts, "PadLinkCheckTemplateCaps")
+	}
+	if (f & PadLinkCheckCaps) != 0 {
+		parts = append(parts, "PadLinkCheckCaps")
+	}
+	if (f & PadLinkCheckNoReconfigure) != 0 {
+		parts = append(parts, "PadLinkCheckNoReconfigure")
+	}
+	if (f & PadLinkCheckDefault) != 0 {
+		parts = append(parts, "PadLinkCheckDefault")
+	}
+	return "PadLinkCheck(" + strings.Join(parts, "|") + ")"
+}
+
 // PadProbeType wraps GstPadProbeType
 //
 // The different probing types that can occur. When either one of
@@ -4298,6 +5580,81 @@ func (f PadProbeType) InitGoValue(v *gobject.Value) {
 	v.SetFlags(int(f))
 }
 
+func (f PadProbeType) String() string {
+	if f == 0 {
+		return "PadProbeType(0)"
+	}
+
+	var parts []string
+	if (f & PadProbeTypeInvalid) != 0 {
+		parts = append(parts, "PadProbeTypeInvalid")
+	}
+	if (f & PadProbeTypeIdle) != 0 {
+		parts = append(parts, "PadProbeTypeIdle")
+	}
+	if (f & PadProbeTypeBlock) != 0 {
+		parts = append(parts, "PadProbeTypeBlock")
+	}
+	if (f & PadProbeTypeBuffer) != 0 {
+		parts = append(parts, "PadProbeTypeBuffer")
+	}
+	if (f & PadProbeTypeBufferList) != 0 {
+		parts = append(parts, "PadProbeTypeBufferList")
+	}
+	if (f & PadProbeTypeEventDownstream) != 0 {
+		parts = append(parts, "PadProbeTypeEventDownstream")
+	}
+	if (f & PadProbeTypeEventUpstream) != 0 {
+		parts = append(parts, "PadProbeTypeEventUpstream")
+	}
+	if (f & PadProbeTypeEventFlush) != 0 {
+		parts = append(parts, "PadProbeTypeEventFlush")
+	}
+	if (f & PadProbeTypeQueryDownstream) != 0 {
+		parts = append(parts, "PadProbeTypeQueryDownstream")
+	}
+	if (f & PadProbeTypeQueryUpstream) != 0 {
+		parts = append(parts, "PadProbeTypeQueryUpstream")
+	}
+	if (f & PadProbeTypePush) != 0 {
+		parts = append(parts, "PadProbeTypePush")
+	}
+	if (f & PadProbeTypePull) != 0 {
+		parts = append(parts, "PadProbeTypePull")
+	}
+	if (f & PadProbeTypeBlocking) != 0 {
+		parts = append(parts, "PadProbeTypeBlocking")
+	}
+	if (f & PadProbeTypeDataDownstream) != 0 {
+		parts = append(parts, "PadProbeTypeDataDownstream")
+	}
+	if (f & PadProbeTypeDataUpstream) != 0 {
+		parts = append(parts, "PadProbeTypeDataUpstream")
+	}
+	if (f & PadProbeTypeDataBoth) != 0 {
+		parts = append(parts, "PadProbeTypeDataBoth")
+	}
+	if (f & PadProbeTypeBlockDownstream) != 0 {
+		parts = append(parts, "PadProbeTypeBlockDownstream")
+	}
+	if (f & PadProbeTypeBlockUpstream) != 0 {
+		parts = append(parts, "PadProbeTypeBlockUpstream")
+	}
+	if (f & PadProbeTypeEventBoth) != 0 {
+		parts = append(parts, "PadProbeTypeEventBoth")
+	}
+	if (f & PadProbeTypeQueryBoth) != 0 {
+		parts = append(parts, "PadProbeTypeQueryBoth")
+	}
+	if (f & PadProbeTypeAllBoth) != 0 {
+		parts = append(parts, "PadProbeTypeAllBoth")
+	}
+	if (f & PadProbeTypeScheduling) != 0 {
+		parts = append(parts, "PadProbeTypeScheduling")
+	}
+	return "PadProbeType(" + strings.Join(parts, "|") + ")"
+}
+
 // PadTemplateFlags wraps GstPadTemplateFlags
 //
 // Flags for the padtemplate
@@ -4325,6 +5682,18 @@ func (f PadTemplateFlags) InitGoValue(v *gobject.Value) {
 	v.SetFlags(int(f))
 }
 
+func (f PadTemplateFlags) String() string {
+	if f == 0 {
+		return "PadTemplateFlags(0)"
+	}
+
+	var parts []string
+	if (f & PadTemplateFlagLast) != 0 {
+		parts = append(parts, "PadTemplateFlagLast")
+	}
+	return "PadTemplateFlags(" + strings.Join(parts, "|") + ")"
+}
+
 // ParseFlags wraps GstParseFlags
 //
 // Parsing options.
@@ -4369,6 +5738,27 @@ func (f ParseFlags) InitGoValue(v *gobject.Value) {
 	v.SetFlags(int(f))
 }
 
+func (f ParseFlags) String() string {
+	if f == 0 {
+		return "ParseFlags(0)"
+	}
+
+	var parts []string
+	if (f & ParseFlagNone) != 0 {
+		parts = append(parts, "ParseFlagNone")
+	}
+	if (f & ParseFlagFatalErrors) != 0 {
+		parts = append(parts, "ParseFlagFatalErrors")
+	}
+	if (f & ParseFlagNoSingleElementBins) != 0 {
+		parts = append(parts, "ParseFlagNoSingleElementBins")
+	}
+	if (f & ParseFlagPlaceInBin) != 0 {
+		parts = append(parts, "ParseFlagPlaceInBin")
+	}
+	return "ParseFlags(" + strings.Join(parts, "|") + ")"
+}
+
 // PipelineFlags wraps GstPipelineFlags
 //
 // Pipeline flags
@@ -4400,6 +5790,21 @@ func (f PipelineFlags) InitGoValue(v *gobject.Value) {
 	v.SetFlags(int(f))
 }
 
+func (f PipelineFlags) String() string {
+	if f == 0 {
+		return "PipelineFlags(0)"
+	}
+
+	var parts []string
+	if (f & PipelineFlagFixedClock) != 0 {
+		parts = append(parts, "PipelineFlagFixedClock")
+	}
+	if (f & PipelineFlagLast) != 0 {
+		parts = append(parts, "PipelineFlagLast")
+	}
+	return "PipelineFlags(" + strings.Join(parts, "|") + ")"
+}
+
 // PluginAPIFlags wraps GstPluginAPIFlags
 type PluginAPIFlags C.gint
 
@@ -4427,6 +5832,18 @@ func (f PluginAPIFlags) InitGoValue(v *gobject.Value) {
 	v.SetFlags(int(f))
 }
 
+func (f PluginAPIFlags) String() string {
+	if f == 0 {
+		return "PluginAPIFlags(0)"
+	}
+
+	var parts []string
+	if (f & PluginApiFlagIgnoreEnumMembers) != 0 {
+		parts = append(parts, "PluginApiFlagIgnoreEnumMembers")
+	}
+	return "PluginAPIFlags(" + strings.Join(parts, "|") + ")"
+}
+
 // PluginDependencyFlags wraps GstPluginDependencyFlags
 //
 // Flags used in connection with gst_plugin_add_dependency().
@@ -4481,6 +5898,33 @@ func (f PluginDependencyFlags) InitGoValue(v *gobject.Value) {
 	v.SetFlags(int(f))
 }
 
+func (f PluginDependencyFlags) String() string {
+	if f == 0 {
+		return "PluginDependencyFlags(0)"
+	}
+
+	var parts []string
+	if (f & PluginDependencyFlagNone) != 0 {
+		parts = append(parts, "PluginDependencyFlagNone")
+	}
+	if (f & PluginDependencyFlagRecurse) != 0 {
+		parts = append(parts, "PluginDependencyFlagRecurse")
+	}
+	if (f & PluginDependencyFlagPathsAreDefaultOnly) != 0 {
+		parts = append(parts, "PluginDependencyFlagPathsAreDefaultOnly")
+	}
+	if (f & PluginDependencyFlagFileNameIsSuffix) != 0 {
+		parts = append(parts, "PluginDependencyFlagFileNameIsSuffix")
+	}
+	if (f & PluginDependencyFlagFileNameIsPrefix) != 0 {
+		parts = append(parts, "PluginDependencyFlagFileNameIsPrefix")
+	}
+	if (f & PluginDependencyFlagPathsAreRelativeToExe) != 0 {
+		parts = append(parts, "PluginDependencyFlagPathsAreRelativeToExe")
+	}
+	return "PluginDependencyFlags(" + strings.Join(parts, "|") + ")"
+}
+
 // PluginFlags wraps GstPluginFlags
 //
 // The plugin loading state
@@ -4512,6 +5956,21 @@ func (f PluginFlags) InitGoValue(v *gobject.Value) {
 	v.SetFlags(int(f))
 }
 
+func (f PluginFlags) String() string {
+	if f == 0 {
+		return "PluginFlags(0)"
+	}
+
+	var parts []string
+	if (f & PluginFlagCached) != 0 {
+		parts = append(parts, "PluginFlagCached")
+	}
+	if (f & PluginFlagBlacklisted) != 0 {
+		parts = append(parts, "PluginFlagBlacklisted")
+	}
+	return "PluginFlags(" + strings.Join(parts, "|") + ")"
+}
+
 // QueryTypeFlags wraps GstQueryTypeFlags
 //
 // #GstQueryTypeFlags indicate the aspects of the different #GstQueryType
@@ -4550,6 +6009,24 @@ func (f QueryTypeFlags) InitGoValue(v *gobject.Value) {
 	v.SetFlags(int(f))
 }
 
+func (f QueryTypeFlags) String() string {
+	if f == 0 {
+		return "QueryTypeFlags(0)"
+	}
+
+	var parts []string
+	if (f & QueryTypeUpstream) != 0 {
+		parts = append(parts, "QueryTypeUpstream")
+	}
+	if (f & QueryTypeDownstream) != 0 {
+		parts = append(parts, "QueryTypeDownstream")
+	}
+	if (f & QueryTypeSerialized) != 0 {
+		parts = append(parts, "QueryTypeSerialized")
+	}
+	return "QueryTypeFlags(" + strings.Join(parts, "|") + ")"
+}
+
 // SchedulingFlags wraps GstSchedulingFlags
 //
 // The different scheduling flags.
@@ -4585,6 +6062,24 @@ func (f SchedulingFlags) InitGoValue(v *gobject.Value) {
 	v.SetFlags(int(f))
 }
 
+func (f SchedulingFlags) String() string {
+	if f == 0 {
+		return "SchedulingFlags(0)"
+	}
+
+	var parts []string
+	if (f & SchedulingFlagSeekable) != 0 {
+		parts = append(parts, "SchedulingFlagSeekable")
+	}
+	if (f & SchedulingFlagSequential) != 0 {
+		parts = append(parts, "SchedulingFlagSequential")
+	}
+	if (f & SchedulingFlagBandwidthLimited) != 0 {
+		parts = append(parts, "SchedulingFlagBandwidthLimited")
+	}
+	return "SchedulingFlags(" + strings.Join(parts, "|") + ")"
+}
+
 // SeekFlags wraps GstSeekFlags
 //
 // Flags to be used with gst_element_seek() or gst_event_new_seek(). All flags
@@ -4738,6 +6233,57 @@ func (f SeekFlags) InitGoValue(v *gobject.Value) {
 	v.SetFlags(int(f))
 }
 
+func (f SeekFlags) String() string {
+	if f == 0 {
+		return "SeekFlags(0)"
+	}
+
+	var parts []string
+	if (f & SeekFlagNone) != 0 {
+		parts = append(parts, "SeekFlagNone")
+	}
+	if (f & SeekFlagFlush) != 0 {
+		parts = append(parts, "SeekFlagFlush")
+	}
+	if (f & SeekFlagAccurate) != 0 {
+		parts = append(parts, "SeekFlagAccurate")
+	}
+	if (f & SeekFlagKeyUnit) != 0 {
+		parts = append(parts, "SeekFlagKeyUnit")
+	}
+	if (f & SeekFlagSegment) != 0 {
+		parts = append(parts, "SeekFlagSegment")
+	}
+	if (f & SeekFlagTrickmode) != 0 {
+		parts = append(parts, "SeekFlagTrickmode")
+	}
+	if (f & SeekFlagSkip) != 0 {
+		parts = append(parts, "SeekFlagSkip")
+	}
+	if (f & SeekFlagSnapBefore) != 0 {
+		parts = append(parts, "SeekFlagSnapBefore")
+	}
+	if (f & SeekFlagSnapAfter) != 0 {
+		parts = append(parts, "SeekFlagSnapAfter")
+	}
+	if (f & SeekFlagSnapNearest) != 0 {
+		parts = append(parts, "SeekFlagSnapNearest")
+	}
+	if (f & SeekFlagTrickmodeKeyUnits) != 0 {
+		parts = append(parts, "SeekFlagTrickmodeKeyUnits")
+	}
+	if (f & SeekFlagTrickmodeNoAudio) != 0 {
+		parts = append(parts, "SeekFlagTrickmodeNoAudio")
+	}
+	if (f & SeekFlagTrickmodeForwardPredicted) != 0 {
+		parts = append(parts, "SeekFlagTrickmodeForwardPredicted")
+	}
+	if (f & SeekFlagInstantRateChange) != 0 {
+		parts = append(parts, "SeekFlagInstantRateChange")
+	}
+	return "SeekFlags(" + strings.Join(parts, "|") + ")"
+}
+
 // SegmentFlags wraps GstSegmentFlags
 //
 // Flags for the GstSegment structure. Currently mapped to the corresponding
@@ -4799,6 +6345,39 @@ func (f SegmentFlags) InitGoValue(v *gobject.Value) {
 	v.SetFlags(int(f))
 }
 
+func (f SegmentFlags) String() string {
+	if f == 0 {
+		return "SegmentFlags(0)"
+	}
+
+	var parts []string
+	if (f & SegmentFlagNone) != 0 {
+		parts = append(parts, "SegmentFlagNone")
+	}
+	if (f & SegmentFlagReset) != 0 {
+		parts = append(parts, "SegmentFlagReset")
+	}
+	if (f & SegmentFlagTrickmode) != 0 {
+		parts = append(parts, "SegmentFlagTrickmode")
+	}
+	if (f & SegmentFlagSkip) != 0 {
+		parts = append(parts, "SegmentFlagSkip")
+	}
+	if (f & SegmentFlagSegment) != 0 {
+		parts = append(parts, "SegmentFlagSegment")
+	}
+	if (f & SegmentFlagTrickmodeKeyUnits) != 0 {
+		parts = append(parts, "SegmentFlagTrickmodeKeyUnits")
+	}
+	if (f & SegmentFlagTrickmodeForwardPredicted) != 0 {
+		parts = append(parts, "SegmentFlagTrickmodeForwardPredicted")
+	}
+	if (f & SegmentFlagTrickmodeNoAudio) != 0 {
+		parts = append(parts, "SegmentFlagTrickmodeNoAudio")
+	}
+	return "SegmentFlags(" + strings.Join(parts, "|") + ")"
+}
+
 // SerializeFlags wraps GstSerializeFlags
 type SerializeFlags C.gint
 
@@ -4834,6 +6413,24 @@ func (f SerializeFlags) InitGoValue(v *gobject.Value) {
 	v.SetFlags(int(f))
 }
 
+func (f SerializeFlags) String() string {
+	if f == 0 {
+		return "SerializeFlags(0)"
+	}
+
+	var parts []string
+	if (f & SerializeFlagNone) != 0 {
+		parts = append(parts, "SerializeFlagNone")
+	}
+	if (f & SerializeFlagBackwardCompat) != 0 {
+		parts = append(parts, "SerializeFlagBackwardCompat")
+	}
+	if (f & SerializeFlagStrict) != 0 {
+		parts = append(parts, "SerializeFlagStrict")
+	}
+	return "SerializeFlags(" + strings.Join(parts, "|") + ")"
+}
+
 // StackTraceFlags wraps GstStackTraceFlags
 type StackTraceFlags C.gint
 
@@ -4867,6 +6464,21 @@ func (f StackTraceFlags) InitGoValue(v *gobject.Value) {
 	v.SetFlags(int(f))
 }
 
+func (f StackTraceFlags) String() string {
+	if f == 0 {
+		return "StackTraceFlags(0)"
+	}
+
+	var parts []string
+	if (f & StackTraceShowNone) != 0 {
+		parts = append(parts, "StackTraceShowNone")
+	}
+	if (f & StackTraceShowFull) != 0 {
+		parts = append(parts, "StackTraceShowFull")
+	}
+	return "StackTraceFlags(" + strings.Join(parts, "|") + ")"
+}
+
 // StreamFlags wraps GstStreamFlags
 type StreamFlags C.gint
 
@@ -4912,6 +6524,27 @@ func (f StreamFlags) InitGoValue(v *gobject.Value) {
 	v.SetFlags(int(f))
 }
 
+func (f StreamFlags) String() string {
+	if f == 0 {
+		return "StreamFlags(0)"
+	}
+
+	var parts []string
+	if (f & StreamFlagNone) != 0 {
+		parts = append(parts, "StreamFlagNone")
+	}
+	if (f & StreamFlagSparse) != 0 {
+		parts = append(parts, "StreamFlagSparse")
+	}
+	if (f & StreamFlagSelect) != 0 {
+		parts = append(parts, "StreamFlagSelect")
+	}
+	if (f & StreamFlagUnselect) != 0 {
+		parts = append(parts, "StreamFlagUnselect")
+	}
+	return "StreamFlags(" + strings.Join(parts, "|") + ")"
+}
+
 // StreamType wraps GstStreamType
 //
 // #GstStreamType describes a high level classification set for
@@ -4960,6 +6593,30 @@ func (f StreamType) InitGoValue(v *gobject.Value) {
 	v.SetFlags(int(f))
 }
 
+func (f StreamType) String() string {
+	if f == 0 {
+		return "StreamType(0)"
+	}
+
+	var parts []string
+	if (f & StreamTypeUnknown) != 0 {
+		parts = append(parts, "StreamTypeUnknown")
+	}
+	if (f & StreamTypeAudio) != 0 {
+		parts = append(parts, "StreamTypeAudio")
+	}
+	if (f & StreamTypeVideo) != 0 {
+		parts = append(parts, "StreamTypeVideo")
+	}
+	if (f & StreamTypeContainer) != 0 {
+		parts = append(parts, "StreamTypeContainer")
+	}
+	if (f & StreamTypeText) != 0 {
+		parts = append(parts, "StreamTypeText")
+	}
+	return "StreamType(" + strings.Join(parts, "|") + ")"
+}
+
 // TracerValueFlags wraps GstTracerValueFlags
 //
 // Flag that describe the value. These flags help applications processing the
@@ -4999,6 +6656,24 @@ func (f TracerValueFlags) InitGoValue(v *gobject.Value) {
 	v.SetFlags(int(f))
 }
 
+func (f TracerValueFlags) String() string {
+	if f == 0 {
+		return "TracerValueFlags(0)"
+	}
+
+	var parts []string
+	if (f & TracerValueFlagsNone) != 0 {
+		parts = append(parts, "TracerValueFlagsNone")
+	}
+	if (f & TracerValueFlagsOptional) != 0 {
+		parts = append(parts, "TracerValueFlagsOptional")
+	}
+	if (f & TracerValueFlagsAggregated) != 0 {
+		parts = append(parts, "TracerValueFlagsAggregated")
+	}
+	return "TracerValueFlags(" + strings.Join(parts, "|") + ")"
+}
+
 // BufferForEachMetaFunc wraps GstBufferForeachMetaFunc
 //
 // A function that will be called from gst_buffer_foreach_meta(). The @meta
@@ -9741,14 +11416,14 @@ func UnsafePresetToGlibFull(c Preset) unsafe.Pointer {
 	return gobject.UnsafeObjectToGlibFull(&i.Instance)
 }
 
-// PresetInstanceGetAppDir wraps gst_preset_get_app_dir
+// PresetGetAppDir wraps gst_preset_get_app_dir
 // The function returns the following values:
 // 
 // 	- goret string 
 //
 // Gets the directory for application specific presets if set by the
 // application.
-func PresetInstanceGetAppDir() string {
+func PresetGetAppDir() string {
 	var cret *C.gchar // return, none, string, casted *C.gchar
 
 	cret = C.gst_preset_get_app_dir()
@@ -9760,7 +11435,7 @@ func PresetInstanceGetAppDir() string {
 	return goret
 }
 
-// PresetInstanceSetAppDir wraps gst_preset_set_app_dir
+// PresetSetAppDir wraps gst_preset_set_app_dir
 // 
 // The function takes the following parameters:
 // 
@@ -9773,7 +11448,7 @@ func PresetInstanceGetAppDir() string {
 // Sets an extra directory as an absolute path that should be considered when
 // looking for presets. Any presets in the application dir will shadow the
 // system presets.
-func PresetInstanceSetAppDir(appDir string) bool {
+func PresetSetAppDir(appDir string) bool {
 	var carg1 *C.gchar   // in, none, string, casted *C.gchar
 	var cret  C.gboolean // return
 
@@ -12781,7 +14456,7 @@ func UnsafePadToGlibFull(c Pad) unsafe.Pointer {
 	return gobject.UnsafeObjectToGlibFull(c)
 }
 
-// NewPadInstance wraps gst_pad_new
+// NewPad wraps gst_pad_new
 // 
 // The function takes the following parameters:
 // 
@@ -12796,7 +14471,7 @@ func UnsafePadToGlibFull(c Pad) unsafe.Pointer {
 // If name is %NULL, a guaranteed unique name (across all pads)
 // will be assigned.
 // This function makes a copy of the name so you can safely free the name.
-func NewPadInstance(name string, direction PadDirection) Pad {
+func NewPad(name string, direction PadDirection) Pad {
 	var carg1 *C.gchar          // in, none, string, nullable-string
 	var carg2 C.GstPadDirection // in, none, casted
 	var cret  *C.GstPad         // return, none, converted
@@ -12818,7 +14493,7 @@ func NewPadInstance(name string, direction PadDirection) Pad {
 	return goret
 }
 
-// NewPadInstanceFromStaticTemplate wraps gst_pad_new_from_static_template
+// NewPadFromStaticTemplate wraps gst_pad_new_from_static_template
 // 
 // The function takes the following parameters:
 // 
@@ -12833,7 +14508,7 @@ func NewPadInstance(name string, direction PadDirection) Pad {
 // If name is %NULL, a guaranteed unique name (across all pads)
 // will be assigned.
 // This function makes a copy of the name so you can safely free the name.
-func NewPadInstanceFromStaticTemplate(templ *StaticPadTemplate, name string) Pad {
+func NewPadFromStaticTemplate(templ *StaticPadTemplate, name string) Pad {
 	var carg1 *C.GstStaticPadTemplate // in, none, converted
 	var carg2 *C.gchar                // in, none, string, casted *C.gchar
 	var cret  *C.GstPad               // return, none, converted
@@ -12853,7 +14528,7 @@ func NewPadInstanceFromStaticTemplate(templ *StaticPadTemplate, name string) Pad
 	return goret
 }
 
-// NewPadInstanceFromTemplate wraps gst_pad_new_from_template
+// NewPadFromTemplate wraps gst_pad_new_from_template
 // 
 // The function takes the following parameters:
 // 
@@ -12868,7 +14543,7 @@ func NewPadInstanceFromStaticTemplate(templ *StaticPadTemplate, name string) Pad
 // If name is %NULL, a guaranteed unique name (across all pads)
 // will be assigned.
 // This function makes a copy of the name so you can safely free the name.
-func NewPadInstanceFromTemplate(templ PadTemplate, name string) Pad {
+func NewPadFromTemplate(templ PadTemplate, name string) Pad {
 	var carg1 *C.GstPadTemplate // in, none, converted
 	var carg2 *C.gchar          // in, none, string, nullable-string
 	var cret  *C.GstPad         // return, none, converted
@@ -12890,7 +14565,7 @@ func NewPadInstanceFromTemplate(templ PadTemplate, name string) Pad {
 	return goret
 }
 
-// PadInstanceLinkGetName wraps gst_pad_link_get_name
+// PadLinkGetName wraps gst_pad_link_get_name
 // 
 // The function takes the following parameters:
 // 
@@ -12901,7 +14576,7 @@ func NewPadInstanceFromTemplate(templ PadTemplate, name string) Pad {
 // 	- goret string 
 //
 // Gets a string representing the given pad-link return.
-func PadInstanceLinkGetName(ret PadLinkReturn) string {
+func PadLinkGetName(ret PadLinkReturn) string {
 	var carg1 C.GstPadLinkReturn // in, none, casted
 	var cret  *C.gchar           // return, none, string, casted *C.gchar
 
@@ -15349,7 +17024,7 @@ func UnsafePadTemplateToGlibFull(c PadTemplate) unsafe.Pointer {
 	return gobject.UnsafeObjectToGlibFull(c)
 }
 
-// NewPadTemplateInstance wraps gst_pad_template_new
+// NewPadTemplate wraps gst_pad_template_new
 // 
 // The function takes the following parameters:
 // 
@@ -15364,7 +17039,7 @@ func UnsafePadTemplateToGlibFull(c PadTemplate) unsafe.Pointer {
 //
 // Creates a new pad template with a name according to the given template
 // and with the given arguments.
-func NewPadTemplateInstance(nameTemplate string, direction PadDirection, presence PadPresence, caps *Caps) PadTemplate {
+func NewPadTemplate(nameTemplate string, direction PadDirection, presence PadPresence, caps *Caps) PadTemplate {
 	var carg1 *C.gchar          // in, none, string, casted *C.gchar
 	var carg2 C.GstPadDirection // in, none, casted
 	var carg3 C.GstPadPresence  // in, none, casted
@@ -15390,7 +17065,7 @@ func NewPadTemplateInstance(nameTemplate string, direction PadDirection, presenc
 	return goret
 }
 
-// NewPadTemplateInstanceFromStaticPadTemplateWithGType wraps gst_pad_template_new_from_static_pad_template_with_gtype
+// NewPadTemplateFromStaticPadTemplateWithGType wraps gst_pad_template_new_from_static_pad_template_with_gtype
 // 
 // The function takes the following parameters:
 // 
@@ -15402,7 +17077,7 @@ func NewPadTemplateInstance(nameTemplate string, direction PadDirection, presenc
 // 	- goret PadTemplate 
 //
 // Converts a #GstStaticPadTemplate into a #GstPadTemplate with a type.
-func NewPadTemplateInstanceFromStaticPadTemplateWithGType(padTemplate *StaticPadTemplate, padType gobject.Type) PadTemplate {
+func NewPadTemplateFromStaticPadTemplateWithGType(padTemplate *StaticPadTemplate, padType gobject.Type) PadTemplate {
 	var carg1 *C.GstStaticPadTemplate // in, none, converted
 	var carg2 C.GType                 // in, none, casted, alias
 	var cret  *C.GstPadTemplate       // return, none, converted
@@ -15421,7 +17096,7 @@ func NewPadTemplateInstanceFromStaticPadTemplateWithGType(padTemplate *StaticPad
 	return goret
 }
 
-// NewPadTemplateInstanceWithGType wraps gst_pad_template_new_with_gtype
+// NewPadTemplateWithGType wraps gst_pad_template_new_with_gtype
 // 
 // The function takes the following parameters:
 // 
@@ -15437,7 +17112,7 @@ func NewPadTemplateInstanceFromStaticPadTemplateWithGType(padTemplate *StaticPad
 //
 // Creates a new pad template with a name according to the given template
 // and with the given arguments.
-func NewPadTemplateInstanceWithGType(nameTemplate string, direction PadDirection, presence PadPresence, caps *Caps, padType gobject.Type) PadTemplate {
+func NewPadTemplateWithGType(nameTemplate string, direction PadDirection, presence PadPresence, caps *Caps, padType gobject.Type) PadTemplate {
 	var carg1 *C.gchar          // in, none, string, casted *C.gchar
 	var carg2 C.GstPadDirection // in, none, casted
 	var carg3 C.GstPadPresence  // in, none, casted
@@ -15825,7 +17500,7 @@ func UnsafePluginToGlibFull(c Plugin) unsafe.Pointer {
 	return gobject.UnsafeObjectToGlibFull(c)
 }
 
-// PluginInstanceLoadByName wraps gst_plugin_load_by_name
+// PluginLoadByName wraps gst_plugin_load_by_name
 // 
 // The function takes the following parameters:
 // 
@@ -15836,7 +17511,7 @@ func UnsafePluginToGlibFull(c Plugin) unsafe.Pointer {
 // 	- goret Plugin 
 //
 // Load the named plugin. Refs the plugin.
-func PluginInstanceLoadByName(name string) Plugin {
+func PluginLoadByName(name string) Plugin {
 	var carg1 *C.gchar     // in, none, string, casted *C.gchar
 	var cret  *C.GstPlugin // return, full, converted
 
@@ -15853,7 +17528,7 @@ func PluginInstanceLoadByName(name string) Plugin {
 	return goret
 }
 
-// PluginInstanceLoadFile wraps gst_plugin_load_file
+// PluginLoadFile wraps gst_plugin_load_file
 // 
 // The function takes the following parameters:
 // 
@@ -15865,7 +17540,7 @@ func PluginInstanceLoadByName(name string) Plugin {
 // 	- _goerr error (nullable): an error 
 //
 // Loads the given plugin and refs it.  Caller needs to unref after use.
-func PluginInstanceLoadFile(filename string) (Plugin, error) {
+func PluginLoadFile(filename string) (Plugin, error) {
 	var carg1 *C.gchar     // in, none, string, casted *C.gchar
 	var cret  *C.GstPlugin // return, full, converted
 	var _cerr *C.GError    // out, full, converted, nullable
@@ -15887,7 +17562,7 @@ func PluginInstanceLoadFile(filename string) (Plugin, error) {
 	return goret, _goerr
 }
 
-// PluginInstanceRegisterStaticFull wraps gst_plugin_register_static_full
+// PluginRegisterStaticFull wraps gst_plugin_register_static_full
 // 
 // The function takes the following parameters:
 // 
@@ -15920,7 +17595,7 @@ func PluginInstanceLoadFile(filename string) (Plugin, error) {
 // 
 // You must make sure that GStreamer has been initialised (with gst_init() or
 // via gst_init_get_option_group()) before calling this function.
-func PluginInstanceRegisterStaticFull(majorVersion int, minorVersion int, name string, description string, initFullFunc PluginInitFullFunc, version string, license string, source string, pkg string, origin string) bool {
+func PluginRegisterStaticFull(majorVersion int, minorVersion int, name string, description string, initFullFunc PluginInitFullFunc, version string, license string, source string, pkg string, origin string) bool {
 	var carg1  C.gint                  // in, none, casted
 	var carg2  C.gint                  // in, none, casted
 	var carg3  *C.gchar                // in, none, string, casted *C.gchar
@@ -16634,7 +18309,7 @@ func UnsafePluginFeatureToGlibFull(c PluginFeature) unsafe.Pointer {
 	return gobject.UnsafeObjectToGlibFull(c)
 }
 
-// PluginFeatureInstanceRankCompareFunc wraps gst_plugin_feature_rank_compare_func
+// PluginFeatureRankCompareFunc wraps gst_plugin_feature_rank_compare_func
 // 
 // The function takes the following parameters:
 // 
@@ -16647,7 +18322,7 @@ func UnsafePluginFeatureToGlibFull(c PluginFeature) unsafe.Pointer {
 //
 // Compares the two given #GstPluginFeature instances. This function can be
 // used as a #GCompareFunc when sorting by rank and then by name.
-func PluginFeatureInstanceRankCompareFunc(p1 unsafe.Pointer, p2 unsafe.Pointer) int {
+func PluginFeatureRankCompareFunc(p1 unsafe.Pointer, p2 unsafe.Pointer) int {
 	var carg1 C.gconstpointer // in, none, casted, nullable
 	var carg2 C.gconstpointer // in, none, casted, nullable
 	var cret  C.gint          // return, none, casted
@@ -16900,7 +18575,7 @@ func UnsafeProxyPadToGlibFull(c ProxyPad) unsafe.Pointer {
 	return gobject.UnsafeObjectToGlibFull(c)
 }
 
-// ProxyPadInstanceChainDefault wraps gst_proxy_pad_chain_default
+// ProxyPadChainDefault wraps gst_proxy_pad_chain_default
 // 
 // The function takes the following parameters:
 // 
@@ -16914,7 +18589,7 @@ func UnsafeProxyPadToGlibFull(c ProxyPad) unsafe.Pointer {
 // 	- goret FlowReturn 
 //
 // Invoke the default chain function of the proxy pad.
-func ProxyPadInstanceChainDefault(pad Pad, parent Object, buffer *Buffer) FlowReturn {
+func ProxyPadChainDefault(pad Pad, parent Object, buffer *Buffer) FlowReturn {
 	var carg1 *C.GstPad       // in, none, converted
 	var carg2 *C.GstObject    // in, none, converted, nullable
 	var carg3 *C.GstBuffer    // in, full, converted
@@ -16938,7 +18613,7 @@ func ProxyPadInstanceChainDefault(pad Pad, parent Object, buffer *Buffer) FlowRe
 	return goret
 }
 
-// ProxyPadInstanceChainListDefault wraps gst_proxy_pad_chain_list_default
+// ProxyPadChainListDefault wraps gst_proxy_pad_chain_list_default
 // 
 // The function takes the following parameters:
 // 
@@ -16952,7 +18627,7 @@ func ProxyPadInstanceChainDefault(pad Pad, parent Object, buffer *Buffer) FlowRe
 // 	- goret FlowReturn 
 //
 // Invoke the default chain list function of the proxy pad.
-func ProxyPadInstanceChainListDefault(pad Pad, parent Object, list *BufferList) FlowReturn {
+func ProxyPadChainListDefault(pad Pad, parent Object, list *BufferList) FlowReturn {
 	var carg1 *C.GstPad        // in, none, converted
 	var carg2 *C.GstObject     // in, none, converted, nullable
 	var carg3 *C.GstBufferList // in, full, converted
@@ -16976,7 +18651,7 @@ func ProxyPadInstanceChainListDefault(pad Pad, parent Object, list *BufferList)
 	return goret
 }
 
-// ProxyPadInstanceGetrangeDefault wraps gst_proxy_pad_getrange_default
+// ProxyPadGetrangeDefault wraps gst_proxy_pad_getrange_default
 // 
 // The function takes the following parameters:
 // 
@@ -16992,7 +18667,7 @@ func ProxyPadInstanceChainListDefault(pad Pad, parent Object, list *BufferList)
 // 	- goret FlowReturn 
 //
 // Invoke the default getrange function of the proxy pad.
-func ProxyPadInstanceGetrangeDefault(pad Pad, parent Object, offset uint64, size uint) (*Buffer, FlowReturn) {
+func ProxyPadGetrangeDefault(pad Pad, parent Object, offset uint64, size uint) (*Buffer, FlowReturn) {
 	var carg1 *C.GstPad       // in, none, converted
 	var carg2 *C.GstObject    // in, none, converted
 	var carg3 C.guint64       // in, none, casted
@@ -17020,7 +18695,7 @@ func ProxyPadInstanceGetrangeDefault(pad Pad, parent Object, offset uint64, size
 	return buffer, goret
 }
 
-// ProxyPadInstanceIterateInternalLinksDefault wraps gst_proxy_pad_iterate_internal_links_default
+// ProxyPadIterateInternalLinksDefault wraps gst_proxy_pad_iterate_internal_links_default
 // 
 // The function takes the following parameters:
 // 
@@ -17032,7 +18707,7 @@ func ProxyPadInstanceGetrangeDefault(pad Pad, parent Object, offset uint64, size
 // 	- goret *Iterator 
 //
 // Invoke the default iterate internal links function of the proxy pad.
-func ProxyPadInstanceIterateInternalLinksDefault(pad Pad, parent Object) *Iterator {
+func ProxyPadIterateInternalLinksDefault(pad Pad, parent Object) *Iterator {
 	var carg1 *C.GstPad      // in, none, converted
 	var carg2 *C.GstObject   // in, none, converted, nullable
 	var cret  *C.GstIterator // return, full, converted
@@ -17329,7 +19004,7 @@ func UnsafeRegistryToGlibFull(c Registry) unsafe.Pointer {
 	return gobject.UnsafeObjectToGlibFull(c)
 }
 
-// RegistryInstanceForkIsEnabled wraps gst_registry_fork_is_enabled
+// RegistryForkIsEnabled wraps gst_registry_fork_is_enabled
 // The function returns the following values:
 // 
 // 	- goret bool 
@@ -17340,7 +19015,7 @@ func UnsafeRegistryToGlibFull(c Registry) unsafe.Pointer {
 // Applications might want to disable this behaviour with the
 // gst_registry_fork_set_enabled() function, in which case new plugins
 // are scanned (and loaded) into the application process.
-func RegistryInstanceForkIsEnabled() bool {
+func RegistryForkIsEnabled() bool {
 	var cret C.gboolean // return
 
 	cret = C.gst_registry_fork_is_enabled()
@@ -17354,7 +19029,7 @@ func RegistryInstanceForkIsEnabled() bool {
 	return goret
 }
 
-// RegistryInstanceForkSetEnabled wraps gst_registry_fork_set_enabled
+// RegistryForkSetEnabled wraps gst_registry_fork_set_enabled
 // 
 // The function takes the following parameters:
 // 
@@ -17363,7 +19038,7 @@ func RegistryInstanceForkIsEnabled() bool {
 // Applications might want to disable/enable spawning of a child helper process
 // when rebuilding the registry. See gst_registry_fork_is_enabled() for more
 // information.
-func RegistryInstanceForkSetEnabled(enabled bool) {
+func RegistryForkSetEnabled(enabled bool) {
 	var carg1 C.gboolean // in
 
 	if enabled {
@@ -17374,7 +19049,7 @@ func RegistryInstanceForkSetEnabled(enabled bool) {
 	runtime.KeepAlive(enabled)
 }
 
-// RegistryInstanceGet wraps gst_registry_get
+// RegistryGet wraps gst_registry_get
 // The function returns the following values:
 // 
 // 	- goret Registry 
@@ -17382,7 +19057,7 @@ func RegistryInstanceForkSetEnabled(enabled bool) {
 // Retrieves the singleton plugin registry. The caller does not own a
 // reference on the registry, as it is alive as long as GStreamer is
 // initialized.
-func RegistryInstanceGet() Registry {
+func RegistryGet() Registry {
 	var cret *C.GstRegistry // return, none, converted
 
 	cret = C.gst_registry_get()
@@ -17873,7 +19548,7 @@ func UnsafeStreamToGlibFull(c Stream) unsafe.Pointer {
 	return gobject.UnsafeObjectToGlibFull(c)
 }
 
-// NewStreamInstance wraps gst_stream_new
+// NewStream wraps gst_stream_new
 // 
 // The function takes the following parameters:
 // 
@@ -17889,7 +19564,7 @@ func UnsafeStreamToGlibFull(c Stream) unsafe.Pointer {
 //
 // Create a new #GstStream for the given @stream_id, @caps, @type
 // and @flags
-func NewStreamInstance(streamId string, caps *Caps, typ StreamType, flags StreamFlags) Stream {
+func NewStream(streamId string, caps *Caps, typ StreamType, flags StreamFlags) Stream {
 	var carg1 *C.gchar         // in, none, string, nullable-string
 	var carg2 *C.GstCaps       // in, none, converted, nullable
 	var carg3 C.GstStreamType  // in, none, casted
@@ -18219,7 +19894,7 @@ func UnsafeStreamCollectionToGlibFull(c StreamCollection) unsafe.Pointer {
 	return gobject.UnsafeObjectToGlibFull(c)
 }
 
-// NewStreamCollectionInstance wraps gst_stream_collection_new
+// NewStreamCollection wraps gst_stream_collection_new
 // 
 // The function takes the following parameters:
 // 
@@ -18230,7 +19905,7 @@ func UnsafeStreamCollectionToGlibFull(c StreamCollection) unsafe.Pointer {
 // 	- goret StreamCollection 
 //
 // Create a new #GstStreamCollection.
-func NewStreamCollectionInstance(upstreamId string) StreamCollection {
+func NewStreamCollection(upstreamId string) StreamCollection {
 	var carg1 *C.gchar               // in, none, string, nullable-string
 	var cret  *C.GstStreamCollection // return, full, converted
 
@@ -18545,7 +20220,7 @@ func UnsafeTaskToGlibFull(c Task) unsafe.Pointer {
 	return gobject.UnsafeObjectToGlibFull(c)
 }
 
-// NewTaskInstance wraps gst_task_new
+// NewTask wraps gst_task_new
 // 
 // The function takes the following parameters:
 // 
@@ -18568,7 +20243,7 @@ func UnsafeTaskToGlibFull(c Task) unsafe.Pointer {
 // Before the task can be used, a #GRecMutex must be configured using the
 // gst_task_set_lock() function. This lock will always be acquired while
 // @func is called.
-func NewTaskInstance(fn TaskFunction) Task {
+func NewTask(fn TaskFunction) Task {
 	var carg1 C.GstTaskFunction // callback, scope: notified, closure: carg2, destroy: carg3
 	var carg2 C.gpointer        // implicit
 	var carg3 C.GDestroyNotify  // implicit
@@ -18588,13 +20263,13 @@ func NewTaskInstance(fn TaskFunction) Task {
 	return goret
 }
 
-// TaskInstanceCleanupAll wraps gst_task_cleanup_all
+// TaskCleanupAll wraps gst_task_cleanup_all
 //
 // Wait for all tasks to be stopped. This is mainly used internally
 // to ensure proper cleanup of internal data structures in test suites.
 // 
 // MT safe.
-func TaskInstanceCleanupAll() {
+func TaskCleanupAll() {
 
 	C.gst_task_cleanup_all()
 }
@@ -18956,14 +20631,14 @@ func UnsafeTaskPoolToGlibFull(c TaskPool) unsafe.Pointer {
 	return gobject.UnsafeObjectToGlibFull(c)
 }
 
-// NewTaskPoolInstance wraps gst_task_pool_new
+// NewTaskPool wraps gst_task_pool_new
 // The function returns the following values:
 // 
 // 	- goret TaskPool 
 //
 // Create a new default task pool. The default task pool will use a regular
 // GThreadPool for threads.
-func NewTaskPoolInstance() TaskPool {
+func NewTaskPool() TaskPool {
 	var cret *C.GstTaskPool // return, full, converted
 
 	cret = C.gst_task_pool_new()
@@ -19166,7 +20841,7 @@ func UnsafeTracerToGlibFull(c Tracer) unsafe.Pointer {
 	return gobject.UnsafeObjectToGlibFull(c)
 }
 
-// TracerInstanceRegister wraps gst_tracer_register
+// TracerRegister wraps gst_tracer_register
 // 
 // The function takes the following parameters:
 // 
@@ -19180,7 +20855,7 @@ func UnsafeTracerToGlibFull(c Tracer) unsafe.Pointer {
 //
 // Create a new tracer-factory  capable of instantiating objects of the
 // @type and add the factory to @plugin.
-func TracerInstanceRegister(plugin Plugin, name string, typ gobject.Type) bool {
+func TracerRegister(plugin Plugin, name string, typ gobject.Type) bool {
 	var carg1 *C.GstPlugin // in, none, converted, nullable
 	var carg2 *C.gchar     // in, none, string, casted *C.gchar
 	var carg3 C.GType      // in, none, casted, alias
@@ -19692,7 +21367,7 @@ func UnsafeAllocatorToGlibFull(c Allocator) unsafe.Pointer {
 	return gobject.UnsafeObjectToGlibFull(c)
 }
 
-// AllocatorInstanceFind wraps gst_allocator_find
+// AllocatorFind wraps gst_allocator_find
 // 
 // The function takes the following parameters:
 // 
@@ -19704,7 +21379,7 @@ func UnsafeAllocatorToGlibFull(c Allocator) unsafe.Pointer {
 //
 // Find a previously registered allocator with @name. When @name is %NULL, the
 // default allocator will be returned.
-func AllocatorInstanceFind(name string) Allocator {
+func AllocatorFind(name string) Allocator {
 	var carg1 *C.gchar        // in, none, string, nullable-string
 	var cret  *C.GstAllocator // return, full, converted
 
@@ -19723,7 +21398,7 @@ func AllocatorInstanceFind(name string) Allocator {
 	return goret
 }
 
-// AllocatorInstanceRegister wraps gst_allocator_register
+// AllocatorRegister wraps gst_allocator_register
 // 
 // The function takes the following parameters:
 // 
@@ -19731,7 +21406,7 @@ func AllocatorInstanceFind(name string) Allocator {
 // 	- allocator Allocator: #GstAllocator 
 //
 // Registers the memory @allocator with @name.
-func AllocatorInstanceRegister(name string, allocator Allocator) {
+func AllocatorRegister(name string, allocator Allocator) {
 	var carg1 *C.gchar        // in, none, string, casted *C.gchar
 	var carg2 *C.GstAllocator // in, full, converted
 
@@ -20036,13 +21711,13 @@ func UnsafeBufferPoolToGlibFull(c BufferPool) unsafe.Pointer {
 	return gobject.UnsafeObjectToGlibFull(c)
 }
 
-// NewBufferPoolInstance wraps gst_buffer_pool_new
+// NewBufferPool wraps gst_buffer_pool_new
 // The function returns the following values:
 // 
 // 	- goret BufferPool 
 //
 // Creates a new #GstBufferPool instance.
-func NewBufferPoolInstance() BufferPool {
+func NewBufferPool() BufferPool {
 	var cret *C.GstBufferPool // return, full, converted
 
 	cret = C.gst_buffer_pool_new()
@@ -20054,7 +21729,7 @@ func NewBufferPoolInstance() BufferPool {
 	return goret
 }
 
-// BufferPoolInstanceConfigAddOption wraps gst_buffer_pool_config_add_option
+// BufferPoolConfigAddOption wraps gst_buffer_pool_config_add_option
 // 
 // The function takes the following parameters:
 // 
@@ -20065,7 +21740,7 @@ func NewBufferPoolInstance() BufferPool {
 // the specified option on the buffers that it allocates.
 // 
 // The options supported by @pool can be retrieved with gst_buffer_pool_get_options().
-func BufferPoolInstanceConfigAddOption(config *Structure, option string) {
+func BufferPoolConfigAddOption(config *Structure, option string) {
 	var carg1 *C.GstStructure // in, none, converted
 	var carg2 *C.gchar        // in, none, string, casted *C.gchar
 
@@ -20078,7 +21753,7 @@ func BufferPoolInstanceConfigAddOption(config *Structure, option string) {
 	runtime.KeepAlive(option)
 }
 
-// BufferPoolInstanceConfigGetAllocator wraps gst_buffer_pool_config_get_allocator
+// BufferPoolConfigGetAllocator wraps gst_buffer_pool_config_get_allocator
 // 
 // The function takes the following parameters:
 // 
@@ -20091,7 +21766,7 @@ func BufferPoolInstanceConfigAddOption(config *Structure, option string) {
 // 	- goret bool 
 //
 // Gets the @allocator and @params from @config.
-func BufferPoolInstanceConfigGetAllocator(config *Structure) (Allocator, AllocationParams, bool) {
+func BufferPoolConfigGetAllocator(config *Structure) (Allocator, AllocationParams, bool) {
 	var carg1 *C.GstStructure       // in, none, converted
 	var carg2 *C.GstAllocator       // out, none, converted, nullable
 	var carg3 C.GstAllocationParams // out, transfer: none, C Pointers: 0, Name: AllocationParams, optional, caller-allocates
@@ -20119,7 +21794,7 @@ func BufferPoolInstanceConfigGetAllocator(config *Structure) (Allocator, Allocat
 	return allocator, params, goret
 }
 
-// BufferPoolInstanceConfigGetOption wraps gst_buffer_pool_config_get_option
+// BufferPoolConfigGetOption wraps gst_buffer_pool_config_get_option
 // 
 // The function takes the following parameters:
 // 
@@ -20132,7 +21807,7 @@ func BufferPoolInstanceConfigGetAllocator(config *Structure) (Allocator, Allocat
 //
 // Parses an available @config and gets the option at @index of the options API
 // array.
-func BufferPoolInstanceConfigGetOption(config *Structure, index uint) string {
+func BufferPoolConfigGetOption(config *Structure, index uint) string {
 	var carg1 *C.GstStructure // in, none, converted
 	var carg2 C.guint         // in, none, casted
 	var cret  *C.gchar        // return, none, string, casted *C.gchar
@@ -20151,7 +21826,7 @@ func BufferPoolInstanceConfigGetOption(config *Structure, index uint) string {
 	return goret
 }
 
-// BufferPoolInstanceConfigGetParams wraps gst_buffer_pool_config_get_params
+// BufferPoolConfigGetParams wraps gst_buffer_pool_config_get_params
 // 
 // The function takes the following parameters:
 // 
@@ -20166,7 +21841,7 @@ func BufferPoolInstanceConfigGetOption(config *Structure, index uint) string {
 // 	- goret bool 
 //
 // Gets the configuration values from @config.
-func BufferPoolInstanceConfigGetParams(config *Structure) (*Caps, uint, uint, uint, bool) {
+func BufferPoolConfigGetParams(config *Structure) (*Caps, uint, uint, uint, bool) {
 	var carg1 *C.GstStructure // in, none, converted
 	var carg2 *C.GstCaps      // out, none, converted, nullable
 	var carg3 C.guint         // out, full, casted
@@ -20198,7 +21873,7 @@ func BufferPoolInstanceConfigGetParams(config *Structure) (*Caps, uint, uint, ui
 	return caps, size, minBuffers, maxBuffers, goret
 }
 
-// BufferPoolInstanceConfigHasOption wraps gst_buffer_pool_config_has_option
+// BufferPoolConfigHasOption wraps gst_buffer_pool_config_has_option
 // 
 // The function takes the following parameters:
 // 
@@ -20210,7 +21885,7 @@ func BufferPoolInstanceConfigGetParams(config *Structure) (*Caps, uint, uint, ui
 // 	- goret bool 
 //
 // Checks if @config contains @option.
-func BufferPoolInstanceConfigHasOption(config *Structure, option string) bool {
+func BufferPoolConfigHasOption(config *Structure, option string) bool {
 	var carg1 *C.GstStructure // in, none, converted
 	var carg2 *C.gchar        // in, none, string, casted *C.gchar
 	var cret  C.gboolean      // return
@@ -20232,7 +21907,7 @@ func BufferPoolInstanceConfigHasOption(config *Structure, option string) bool {
 	return goret
 }
 
-// BufferPoolInstanceConfigNOptions wraps gst_buffer_pool_config_n_options
+// BufferPoolConfigNOptions wraps gst_buffer_pool_config_n_options
 // 
 // The function takes the following parameters:
 // 
@@ -20244,7 +21919,7 @@ func BufferPoolInstanceConfigHasOption(config *Structure, option string) bool {
 //
 // Retrieves the number of values currently stored in the options array of the
 // @config structure.
-func BufferPoolInstanceConfigNOptions(config *Structure) uint {
+func BufferPoolConfigNOptions(config *Structure) uint {
 	var carg1 *C.GstStructure // in, none, converted
 	var cret  C.guint         // return, none, casted
 
@@ -20260,7 +21935,7 @@ func BufferPoolInstanceConfigNOptions(config *Structure) uint {
 	return goret
 }
 
-// BufferPoolInstanceConfigSetAllocator wraps gst_buffer_pool_config_set_allocator
+// BufferPoolConfigSetAllocator wraps gst_buffer_pool_config_set_allocator
 // 
 // The function takes the following parameters:
 // 
@@ -20280,7 +21955,7 @@ func BufferPoolInstanceConfigNOptions(config *Structure) uint {
 // to operate with different allocators or cannot allocate with the values
 // specified in @params. Use gst_buffer_pool_get_config() to get the currently
 // used values.
-func BufferPoolInstanceConfigSetAllocator(config *Structure, allocator Allocator, params *AllocationParams) {
+func BufferPoolConfigSetAllocator(config *Structure, allocator Allocator, params *AllocationParams) {
 	var carg1 *C.GstStructure        // in, none, converted
 	var carg2 *C.GstAllocator        // in, none, converted, nullable
 	var carg3 *C.GstAllocationParams // in, none, converted, nullable
@@ -20299,7 +21974,7 @@ func BufferPoolInstanceConfigSetAllocator(config *Structure, allocator Allocator
 	runtime.KeepAlive(params)
 }
 
-// BufferPoolInstanceConfigSetParams wraps gst_buffer_pool_config_set_params
+// BufferPoolConfigSetParams wraps gst_buffer_pool_config_set_params
 // 
 // The function takes the following parameters:
 // 
@@ -20310,7 +21985,7 @@ func BufferPoolInstanceConfigSetAllocator(config *Structure, allocator Allocator
 // 	- maxBuffers uint: the maximum amount of buffers to allocate or 0 for unlimited. 
 //
 // Configures @config with the given parameters.
-func BufferPoolInstanceConfigSetParams(config *Structure, caps *Caps, size uint, minBuffers uint, maxBuffers uint) {
+func BufferPoolConfigSetParams(config *Structure, caps *Caps, size uint, minBuffers uint, maxBuffers uint) {
 	var carg1 *C.GstStructure // in, none, converted
 	var carg2 *C.GstCaps      // in, none, converted, nullable
 	var carg3 C.guint         // in, none, casted
@@ -20333,7 +22008,7 @@ func BufferPoolInstanceConfigSetParams(config *Structure, caps *Caps, size uint,
 	runtime.KeepAlive(maxBuffers)
 }
 
-// BufferPoolInstanceConfigValidateParams wraps gst_buffer_pool_config_validate_params
+// BufferPoolConfigValidateParams wraps gst_buffer_pool_config_validate_params
 // 
 // The function takes the following parameters:
 // 
@@ -20355,7 +22030,7 @@ func BufferPoolInstanceConfigSetParams(config *Structure, caps *Caps, size uint,
 // This does not check if options or allocator parameters are still valid,
 // won't check if size have changed, since changing the size is valid to adapt
 // padding.
-func BufferPoolInstanceConfigValidateParams(config *Structure, caps *Caps, size uint, minBuffers uint, maxBuffers uint) bool {
+func BufferPoolConfigValidateParams(config *Structure, caps *Caps, size uint, minBuffers uint, maxBuffers uint) bool {
 	var carg1 *C.GstStructure // in, none, converted
 	var carg2 *C.GstCaps      // in, none, converted, nullable
 	var carg3 C.guint         // in, none, casted
@@ -20721,6 +22396,7 @@ var _ Bus = (*BusInstance)(nil)
 // Note that a #GstPipeline will set its bus into flushing state when changing
 // from READY to NULL state.
 type Bus interface {
+	BusExtManual // handwritten functions
 	Object
 	upcastToGstBus() *BusInstance
 
@@ -21089,13 +22765,13 @@ func UnsafeBusToGlibFull(c Bus) unsafe.Pointer {
 	return gobject.UnsafeObjectToGlibFull(c)
 }
 
-// NewBusInstance wraps gst_bus_new
+// NewBus wraps gst_bus_new
 // The function returns the following values:
 // 
 // 	- goret Bus 
 //
 // Creates a new #GstBus instance.
-func NewBusInstance() Bus {
+func NewBus() Bus {
 	var cret *C.GstBus // return, full, converted
 
 	cret = C.gst_bus_new()
@@ -22251,7 +23927,7 @@ func UnsafeClockToGlibFull(c Clock) unsafe.Pointer {
 	return gobject.UnsafeObjectToGlibFull(c)
 }
 
-// ClockInstanceIDCompareFunc wraps gst_clock_id_compare_func
+// ClockIDCompareFunc wraps gst_clock_id_compare_func
 // 
 // The function takes the following parameters:
 // 
@@ -22264,7 +23940,7 @@ func UnsafeClockToGlibFull(c Clock) unsafe.Pointer {
 //
 // Compares the two #GstClockID instances. This function can be used
 // as a GCompareFunc when sorting ids.
-func ClockInstanceIDCompareFunc(id1 unsafe.Pointer, id2 unsafe.Pointer) int {
+func ClockIDCompareFunc(id1 unsafe.Pointer, id2 unsafe.Pointer) int {
 	var carg1 C.gconstpointer // in, none, casted, nullable
 	var carg2 C.gconstpointer // in, none, casted, nullable
 	var cret  C.gint          // return, none, casted
@@ -22287,7 +23963,7 @@ func ClockInstanceIDCompareFunc(id1 unsafe.Pointer, id2 unsafe.Pointer) int {
 	return goret
 }
 
-// ClockInstanceIDGetClock wraps gst_clock_id_get_clock
+// ClockIDGetClock wraps gst_clock_id_get_clock
 // 
 // The function takes the following parameters:
 // 
@@ -22298,7 +23974,7 @@ func ClockInstanceIDCompareFunc(id1 unsafe.Pointer, id2 unsafe.Pointer) int {
 // 	- goret Clock 
 //
 // This function returns the underlying clock.
-func ClockInstanceIDGetClock(id ClockID) Clock {
+func ClockIDGetClock(id ClockID) Clock {
 	var carg1 C.GstClockID // in, none, casted, alias
 	var cret  *C.GstClock  // return, full, converted
 
@@ -22314,7 +23990,7 @@ func ClockInstanceIDGetClock(id ClockID) Clock {
 	return goret
 }
 
-// ClockInstanceIDGetTime wraps gst_clock_id_get_time
+// ClockIDGetTime wraps gst_clock_id_get_time
 // 
 // The function takes the following parameters:
 // 
@@ -22325,7 +24001,7 @@ func ClockInstanceIDGetClock(id ClockID) Clock {
 // 	- goret ClockTime 
 //
 // Gets the time of the clock ID
-func ClockInstanceIDGetTime(id ClockID) ClockTime {
+func ClockIDGetTime(id ClockID) ClockTime {
 	var carg1 C.GstClockID   // in, none, casted, alias
 	var cret  C.GstClockTime // return, none, casted, alias
 
@@ -22341,7 +24017,7 @@ func ClockInstanceIDGetTime(id ClockID) ClockTime {
 	return goret
 }
 
-// ClockInstanceIDRef wraps gst_clock_id_ref
+// ClockIDRef wraps gst_clock_id_ref
 // 
 // The function takes the following parameters:
 // 
@@ -22352,7 +24028,7 @@ func ClockInstanceIDGetTime(id ClockID) ClockTime {
 // 	- goret ClockID 
 //
 // Increases the refcount of given @id.
-func ClockInstanceIDRef(id ClockID) ClockID {
+func ClockIDRef(id ClockID) ClockID {
 	var carg1 C.GstClockID // in, none, casted, alias
 	var cret  C.GstClockID // return, full, casted, alias
 
@@ -22368,7 +24044,7 @@ func ClockInstanceIDRef(id ClockID) ClockID {
 	return goret
 }
 
-// ClockInstanceIDUnref wraps gst_clock_id_unref
+// ClockIDUnref wraps gst_clock_id_unref
 // 
 // The function takes the following parameters:
 // 
@@ -22376,7 +24052,7 @@ func ClockInstanceIDRef(id ClockID) ClockID {
 //
 // Unrefs given @id. When the refcount reaches 0 the
 // #GstClockID will be freed.
-func ClockInstanceIDUnref(id ClockID) {
+func ClockIDUnref(id ClockID) {
 	var carg1 C.GstClockID // in, full, casted, alias
 
 	carg1 = C.GstClockID(id)
@@ -22385,7 +24061,7 @@ func ClockInstanceIDUnref(id ClockID) {
 	runtime.KeepAlive(id)
 }
 
-// ClockInstanceIDUnschedule wraps gst_clock_id_unschedule
+// ClockIDUnschedule wraps gst_clock_id_unschedule
 // 
 // The function takes the following parameters:
 // 
@@ -22395,7 +24071,7 @@ func ClockInstanceIDUnref(id ClockID) {
 // be an outstanding async notification or a pending sync notification.
 // After this call, @id cannot be used anymore to receive sync or
 // async notifications, you need to create a new #GstClockID.
-func ClockInstanceIDUnschedule(id ClockID) {
+func ClockIDUnschedule(id ClockID) {
 	var carg1 C.GstClockID // in, none, casted, alias
 
 	carg1 = C.GstClockID(id)
@@ -22404,7 +24080,7 @@ func ClockInstanceIDUnschedule(id ClockID) {
 	runtime.KeepAlive(id)
 }
 
-// ClockInstanceIDUsesClock wraps gst_clock_id_uses_clock
+// ClockIDUsesClock wraps gst_clock_id_uses_clock
 // 
 // The function takes the following parameters:
 // 
@@ -22419,7 +24095,7 @@ func ClockInstanceIDUnschedule(id ClockID) {
 // @clock can be NULL, in which case the return value indicates whether
 // the underlying clock has been freed.  If this is the case, the @id is
 // no longer usable and should be freed.
-func ClockInstanceIDUsesClock(id ClockID, clock Clock) bool {
+func ClockIDUsesClock(id ClockID, clock Clock) bool {
 	var carg1 C.GstClockID // in, none, casted, alias
 	var carg2 *C.GstClock  // in, none, converted
 	var cret  C.gboolean   // return
@@ -22440,7 +24116,7 @@ func ClockInstanceIDUsesClock(id ClockID, clock Clock) bool {
 	return goret
 }
 
-// ClockInstanceIDWait wraps gst_clock_id_wait
+// ClockIDWait wraps gst_clock_id_wait
 // 
 // The function takes the following parameters:
 // 
@@ -22465,7 +24141,7 @@ func ClockInstanceIDUsesClock(id ClockID, clock Clock) bool {
 // (in which case this function will return #GST_CLOCK_EARLY).
 // Negative values indicate how much time was spent waiting on the clock
 // before this function returned.
-func ClockInstanceIDWait(id ClockID) (ClockTimeDiff, ClockReturn) {
+func ClockIDWait(id ClockID) (ClockTimeDiff, ClockReturn) {
 	var carg1 C.GstClockID       // in, none, casted, alias
 	var carg2 C.GstClockTimeDiff // out, full, casted, alias
 	var cret  C.GstClockReturn   // return, none, casted
@@ -22484,7 +24160,7 @@ func ClockInstanceIDWait(id ClockID) (ClockTimeDiff, ClockReturn) {
 	return jitter, goret
 }
 
-// ClockInstanceIDWaitAsync wraps gst_clock_id_wait_async
+// ClockIDWaitAsync wraps gst_clock_id_wait_async
 // 
 // The function takes the following parameters:
 // 
@@ -22503,7 +24179,7 @@ func ClockInstanceIDWait(id ClockID) (ClockTimeDiff, ClockReturn) {
 // 
 // The callback @func can be invoked from any thread, either provided by the
 // core or from a streaming thread. The application should be prepared for this.
-func ClockInstanceIDWaitAsync(id ClockID, fn ClockCallback) ClockReturn {
+func ClockIDWaitAsync(id ClockID, fn ClockCallback) ClockReturn {
 	var carg1 C.GstClockID       // in, none, casted, alias
 	var carg2 C.GstClockCallback // callback, scope: notified, closure: carg3, destroy: carg4
 	var carg3 C.gpointer         // implicit
@@ -24284,13 +25960,13 @@ func UnsafeDeviceMonitorToGlibFull(c DeviceMonitor) unsafe.Pointer {
 	return gobject.UnsafeObjectToGlibFull(c)
 }
 
-// NewDeviceMonitorInstance wraps gst_device_monitor_new
+// NewDeviceMonitor wraps gst_device_monitor_new
 // The function returns the following values:
 // 
 // 	- goret DeviceMonitor 
 //
 // Create a new #GstDeviceMonitor
-func NewDeviceMonitorInstance() DeviceMonitor {
+func NewDeviceMonitor() DeviceMonitor {
 	var cret *C.GstDeviceMonitor // return, full, converted
 
 	cret = C.gst_device_monitor_new()
@@ -24713,7 +26389,7 @@ func UnsafeDeviceProviderToGlibFull(c DeviceProvider) unsafe.Pointer {
 	return gobject.UnsafeObjectToGlibFull(c)
 }
 
-// DeviceProviderInstanceRegister wraps gst_device_provider_register
+// DeviceProviderRegister wraps gst_device_provider_register
 // 
 // The function takes the following parameters:
 // 
@@ -24729,7 +26405,7 @@ func UnsafeDeviceProviderToGlibFull(c DeviceProvider) unsafe.Pointer {
 //
 // Create a new device providerfactory capable of instantiating objects of the
 // @type and add the factory to @plugin.
-func DeviceProviderInstanceRegister(plugin Plugin, name string, rank uint, typ gobject.Type) bool {
+func DeviceProviderRegister(plugin Plugin, name string, rank uint, typ gobject.Type) bool {
 	var carg1 *C.GstPlugin // in, none, converted, nullable
 	var carg2 *C.gchar     // in, none, string, casted *C.gchar
 	var carg3 C.guint      // in, none, casted
@@ -25203,7 +26879,7 @@ func UnsafeDeviceProviderFactoryToGlibFull(c DeviceProviderFactory) unsafe.Point
 	return gobject.UnsafeObjectToGlibFull(c)
 }
 
-// DeviceProviderFactoryInstanceFind wraps gst_device_provider_factory_find
+// DeviceProviderFactoryFind wraps gst_device_provider_factory_find
 // 
 // The function takes the following parameters:
 // 
@@ -25215,7 +26891,7 @@ func UnsafeDeviceProviderFactoryToGlibFull(c DeviceProviderFactory) unsafe.Point
 //
 // Search for an device provider factory of the given name. Refs the returned
 // device provider factory; caller is responsible for unreffing.
-func DeviceProviderFactoryInstanceFind(name string) DeviceProviderFactory {
+func DeviceProviderFactoryFind(name string) DeviceProviderFactory {
 	var carg1 *C.gchar                    // in, none, string, casted *C.gchar
 	var cret  *C.GstDeviceProviderFactory // return, full, converted
 
@@ -25232,7 +26908,7 @@ func DeviceProviderFactoryInstanceFind(name string) DeviceProviderFactory {
 	return goret
 }
 
-// DeviceProviderFactoryInstanceGetByName wraps gst_device_provider_factory_get_by_name
+// DeviceProviderFactoryGetByName wraps gst_device_provider_factory_get_by_name
 // 
 // The function takes the following parameters:
 // 
@@ -25244,7 +26920,7 @@ func DeviceProviderFactoryInstanceFind(name string) DeviceProviderFactory {
 //
 // Returns the device provider of the type defined by the given device
 // provider factory.
-func DeviceProviderFactoryInstanceGetByName(factoryname string) DeviceProvider {
+func DeviceProviderFactoryGetByName(factoryname string) DeviceProvider {
 	var carg1 *C.gchar             // in, none, string, casted *C.gchar
 	var cret  *C.GstDeviceProvider // return, full, converted
 
@@ -25508,7 +27184,7 @@ func UnsafeDynamicTypeFactoryToGlibFull(c DynamicTypeFactory) unsafe.Pointer {
 	return gobject.UnsafeObjectToGlibFull(c)
 }
 
-// DynamicTypeFactoryInstanceLoad wraps gst_dynamic_type_factory_load
+// DynamicTypeFactoryLoad wraps gst_dynamic_type_factory_load
 // 
 // The function takes the following parameters:
 // 
@@ -25517,7 +27193,7 @@ func UnsafeDynamicTypeFactoryToGlibFull(c DynamicTypeFactory) unsafe.Pointer {
 // The function returns the following values:
 // 
 // 	- goret gobject.Type 
-func DynamicTypeFactoryInstanceLoad(factoryname string) gobject.Type {
+func DynamicTypeFactoryLoad(factoryname string) gobject.Type {
 	var carg1 *C.gchar // in, none, string, casted *C.gchar
 	var cret  C.GType  // return, none, casted, alias
 
@@ -26673,7 +28349,7 @@ func UnsafeElementToGlibFull(c Element) unsafe.Pointer {
 	return gobject.UnsafeObjectToGlibFull(c)
 }
 
-// ElementInstanceMakeFromURI wraps gst_element_make_from_uri
+// ElementMakeFromURI wraps gst_element_make_from_uri
 // 
 // The function takes the following parameters:
 // 
@@ -26687,7 +28363,7 @@ func UnsafeElementToGlibFull(c Element) unsafe.Pointer {
 // 	- _goerr error (nullable): an error 
 //
 // Creates an element for handling the given URI.
-func ElementInstanceMakeFromURI(typ URIType, uri string, elementname string) (Element, error) {
+func ElementMakeFromURI(typ URIType, uri string, elementname string) (Element, error) {
 	var carg1 C.GstURIType  // in, none, casted
 	var carg2 *C.gchar      // in, none, string, casted *C.gchar
 	var carg3 *C.gchar      // in, none, string, nullable-string
@@ -26718,7 +28394,7 @@ func ElementInstanceMakeFromURI(typ URIType, uri string, elementname string) (El
 	return goret, _goerr
 }
 
-// ElementInstanceRegister wraps gst_element_register
+// ElementRegister wraps gst_element_register
 // 
 // The function takes the following parameters:
 // 
@@ -26734,7 +28410,7 @@ func ElementInstanceMakeFromURI(typ URIType, uri string, elementname string) (El
 //
 // Create a new elementfactory capable of instantiating objects of the
 // @type and add the factory to @plugin.
-func ElementInstanceRegister(plugin Plugin, name string, rank uint, typ gobject.Type) bool {
+func ElementRegister(plugin Plugin, name string, rank uint, typ gobject.Type) bool {
 	var carg1 *C.GstPlugin // in, none, converted, nullable
 	var carg2 *C.gchar     // in, none, string, casted *C.gchar
 	var carg3 C.guint      // in, none, casted
@@ -26764,7 +28440,7 @@ func ElementInstanceRegister(plugin Plugin, name string, rank uint, typ gobject.
 	return goret
 }
 
-// ElementInstanceStateChangeReturnGetName wraps gst_element_state_change_return_get_name
+// ElementStateChangeReturnGetName wraps gst_element_state_change_return_get_name
 // 
 // The function takes the following parameters:
 // 
@@ -26775,7 +28451,7 @@ func ElementInstanceRegister(plugin Plugin, name string, rank uint, typ gobject.
 // 	- goret string 
 //
 // Gets a string representing the given state change result.
-func ElementInstanceStateChangeReturnGetName(stateRet StateChangeReturn) string {
+func ElementStateChangeReturnGetName(stateRet StateChangeReturn) string {
 	var carg1 C.GstStateChangeReturn // in, none, casted
 	var cret  *C.gchar               // return, none, string, casted *C.gchar
 
@@ -26791,7 +28467,7 @@ func ElementInstanceStateChangeReturnGetName(stateRet StateChangeReturn) string
 	return goret
 }
 
-// ElementInstanceStateGetName wraps gst_element_state_get_name
+// ElementStateGetName wraps gst_element_state_get_name
 // 
 // The function takes the following parameters:
 // 
@@ -26802,7 +28478,7 @@ func ElementInstanceStateChangeReturnGetName(stateRet StateChangeReturn) string
 // 	- goret string 
 //
 // Gets a string representing the given state.
-func ElementInstanceStateGetName(state State) string {
+func ElementStateGetName(state State) string {
 	var carg1 C.GstState // in, none, casted
 	var cret  *C.gchar   // return, none, string, casted *C.gchar
 
@@ -26818,7 +28494,7 @@ func ElementInstanceStateGetName(state State) string {
 	return goret
 }
 
-// ElementInstanceTypeSetSkipDocumentation wraps gst_element_type_set_skip_documentation
+// ElementTypeSetSkipDocumentation wraps gst_element_type_set_skip_documentation
 // 
 // The function takes the following parameters:
 // 
@@ -26841,7 +28517,7 @@ func ElementInstanceStateGetName(state State) string {
 // gst_element_type_set_skip_documentation (my_type);
 // gst_element_register (plugin, "my-plugin-feature-name", rank, my_type);
 // ```
-func ElementInstanceTypeSetSkipDocumentation(typ gobject.Type) {
+func ElementTypeSetSkipDocumentation(typ gobject.Type) {
 	var carg1 C.GType // in, none, casted, alias
 
 	carg1 = C.GType(typ)
@@ -29404,7 +31080,7 @@ func UnsafeElementFactoryToGlibFull(c ElementFactory) unsafe.Pointer {
 	return gobject.UnsafeObjectToGlibFull(c)
 }
 
-// ElementFactoryInstanceFind wraps gst_element_factory_find
+// ElementFactoryFind wraps gst_element_factory_find
 // 
 // The function takes the following parameters:
 // 
@@ -29416,7 +31092,7 @@ func UnsafeElementFactoryToGlibFull(c ElementFactory) unsafe.Pointer {
 //
 // Search for an element factory of the given name. Refs the returned
 // element factory; caller is responsible for unreffing.
-func ElementFactoryInstanceFind(name string) ElementFactory {
+func ElementFactoryFind(name string) ElementFactory {
 	var carg1 *C.gchar             // in, none, string, casted *C.gchar
 	var cret  *C.GstElementFactory // return, full, converted
 
@@ -29433,7 +31109,7 @@ func ElementFactoryInstanceFind(name string) ElementFactory {
 	return goret
 }
 
-// ElementFactoryInstanceMake wraps gst_element_factory_make
+// ElementFactoryMake wraps gst_element_factory_make
 // 
 // The function takes the following parameters:
 // 
@@ -29449,7 +31125,7 @@ func ElementFactoryInstanceFind(name string) ElementFactory {
 // If name is %NULL, then the element will receive a guaranteed unique name,
 // consisting of the element factory name and a number.
 // If name is given, it will be given the name supplied.
-func ElementFactoryInstanceMake(factoryname string, name string) Element {
+func ElementFactoryMake(factoryname string, name string) Element {
 	var carg1 *C.gchar      // in, none, string, casted *C.gchar
 	var carg2 *C.gchar      // in, none, string, nullable-string
 	var cret  *C.GstElement // return, none, converted
@@ -30025,7 +31701,7 @@ func UnsafeGhostPadToGlibFull(c GhostPad) unsafe.Pointer {
 	return gobject.UnsafeObjectToGlibFull(c)
 }
 
-// NewGhostPadInstance wraps gst_ghost_pad_new
+// NewGhostPad wraps gst_ghost_pad_new
 // 
 // The function takes the following parameters:
 // 
@@ -30040,7 +31716,7 @@ func UnsafeGhostPadToGlibFull(c GhostPad) unsafe.Pointer {
 // from the target pad. @target must be unlinked.
 // 
 // Will ref the target.
-func NewGhostPadInstance(name string, target Pad) Pad {
+func NewGhostPad(name string, target Pad) Pad {
 	var carg1 *C.gchar  // in, none, string, nullable-string
 	var carg2 *C.GstPad // in, none, converted
 	var cret  *C.GstPad // return, none, converted
@@ -30062,7 +31738,7 @@ func NewGhostPadInstance(name string, target Pad) Pad {
 	return goret
 }
 
-// NewGhostPadInstanceFromTemplate wraps gst_ghost_pad_new_from_template
+// NewGhostPadFromTemplate wraps gst_ghost_pad_new_from_template
 // 
 // The function takes the following parameters:
 // 
@@ -30078,7 +31754,7 @@ func NewGhostPadInstance(name string, target Pad) Pad {
 // from the target pad. The template used on the ghostpad will be @template.
 // 
 // Will ref the target.
-func NewGhostPadInstanceFromTemplate(name string, target Pad, templ PadTemplate) Pad {
+func NewGhostPadFromTemplate(name string, target Pad, templ PadTemplate) Pad {
 	var carg1 *C.gchar          // in, none, string, nullable-string
 	var carg2 *C.GstPad         // in, none, converted
 	var carg3 *C.GstPadTemplate // in, none, converted
@@ -30103,7 +31779,7 @@ func NewGhostPadInstanceFromTemplate(name string, target Pad, templ PadTemplate)
 	return goret
 }
 
-// NewGhostPadInstanceNoTarget wraps gst_ghost_pad_new_no_target
+// NewGhostPadNoTarget wraps gst_ghost_pad_new_no_target
 // 
 // The function takes the following parameters:
 // 
@@ -30119,7 +31795,7 @@ func NewGhostPadInstanceFromTemplate(name string, target Pad, templ PadTemplate)
 // gst_ghost_pad_set_target() function.
 // 
 // The created ghostpad will not have a padtemplate.
-func NewGhostPadInstanceNoTarget(name string, dir PadDirection) Pad {
+func NewGhostPadNoTarget(name string, dir PadDirection) Pad {
 	var carg1 *C.gchar          // in, none, string, nullable-string
 	var carg2 C.GstPadDirection // in, none, casted
 	var cret  *C.GstPad         // return, none, converted
@@ -30141,7 +31817,7 @@ func NewGhostPadInstanceNoTarget(name string, dir PadDirection) Pad {
 	return goret
 }
 
-// NewGhostPadInstanceNoTargetFromTemplate wraps gst_ghost_pad_new_no_target_from_template
+// NewGhostPadNoTargetFromTemplate wraps gst_ghost_pad_new_no_target_from_template
 // 
 // The function takes the following parameters:
 // 
@@ -30154,7 +31830,7 @@ func NewGhostPadInstanceNoTarget(name string, dir PadDirection) Pad {
 //
 // Create a new ghostpad based on @templ, without setting a target. The
 // direction will be taken from the @templ.
-func NewGhostPadInstanceNoTargetFromTemplate(name string, templ PadTemplate) Pad {
+func NewGhostPadNoTargetFromTemplate(name string, templ PadTemplate) Pad {
 	var carg1 *C.gchar          // in, none, string, nullable-string
 	var carg2 *C.GstPadTemplate // in, none, converted
 	var cret  *C.GstPad         // return, none, converted
@@ -30176,7 +31852,7 @@ func NewGhostPadInstanceNoTargetFromTemplate(name string, templ PadTemplate) Pad
 	return goret
 }
 
-// GhostPadInstanceActivateModeDefault wraps gst_ghost_pad_activate_mode_default
+// GhostPadActivateModeDefault wraps gst_ghost_pad_activate_mode_default
 // 
 // The function takes the following parameters:
 // 
@@ -30190,7 +31866,7 @@ func NewGhostPadInstanceNoTargetFromTemplate(name string, templ PadTemplate) Pad
 // 	- goret bool 
 //
 // Invoke the default activate mode function of a ghost pad.
-func GhostPadInstanceActivateModeDefault(pad Pad, parent Object, mode PadMode, active bool) bool {
+func GhostPadActivateModeDefault(pad Pad, parent Object, mode PadMode, active bool) bool {
 	var carg1 *C.GstPad    // in, none, converted
 	var carg2 *C.GstObject // in, none, converted, nullable
 	var carg3 C.GstPadMode // in, none, casted
@@ -30221,7 +31897,7 @@ func GhostPadInstanceActivateModeDefault(pad Pad, parent Object, mode PadMode, a
 	return goret
 }
 
-// GhostPadInstanceInternalActivateModeDefault wraps gst_ghost_pad_internal_activate_mode_default
+// GhostPadInternalActivateModeDefault wraps gst_ghost_pad_internal_activate_mode_default
 // 
 // The function takes the following parameters:
 // 
@@ -30236,7 +31912,7 @@ func GhostPadInstanceActivateModeDefault(pad Pad, parent Object, mode PadMode, a
 //
 // Invoke the default activate mode function of a proxy pad that is
 // owned by a ghost pad.
-func GhostPadInstanceInternalActivateModeDefault(pad Pad, parent Object, mode PadMode, active bool) bool {
+func GhostPadInternalActivateModeDefault(pad Pad, parent Object, mode PadMode, active bool) bool {
 	var carg1 *C.GstPad    // in, none, converted
 	var carg2 *C.GstObject // in, none, converted, nullable
 	var carg3 C.GstPadMode // in, none, casted
@@ -30431,7 +32107,7 @@ func UnsafeSharedTaskPoolToGlibFull(c SharedTaskPool) unsafe.Pointer {
 	return gobject.UnsafeObjectToGlibFull(c)
 }
 
-// NewSharedTaskPoolInstance wraps gst_shared_task_pool_new
+// NewSharedTaskPool wraps gst_shared_task_pool_new
 // The function returns the following values:
 // 
 // 	- goret TaskPool 
@@ -30442,7 +32118,7 @@ func UnsafeSharedTaskPoolToGlibFull(c SharedTaskPool) unsafe.Pointer {
 // Do not use a #GstSharedTaskPool to manage potentially inter-dependent tasks such
 // as pad tasks, as having one task waiting on another to return before returning
 // would cause obvious deadlocks if they happen to share the same thread.
-func NewSharedTaskPoolInstance() TaskPool {
+func NewSharedTaskPool() TaskPool {
 	var cret *C.GstTaskPool // return, full, converted
 
 	cret = C.gst_shared_task_pool_new()
@@ -30561,7 +32237,7 @@ func UnsafeSystemClockToGlibFull(c SystemClock) unsafe.Pointer {
 	return gobject.UnsafeObjectToGlibFull(c)
 }
 
-// SystemClockInstanceObtain wraps gst_system_clock_obtain
+// SystemClockObtain wraps gst_system_clock_obtain
 // The function returns the following values:
 // 
 // 	- goret Clock 
@@ -30569,7 +32245,7 @@ func UnsafeSystemClockToGlibFull(c SystemClock) unsafe.Pointer {
 // Get a handle to the default system clock. The refcount of the
 // clock will be increased so you need to unref the clock after
 // usage.
-func SystemClockInstanceObtain() Clock {
+func SystemClockObtain() Clock {
 	var cret *C.GstClock // return, full, converted
 
 	cret = C.gst_system_clock_obtain()
@@ -30581,7 +32257,7 @@ func SystemClockInstanceObtain() Clock {
 	return goret
 }
 
-// SystemClockInstanceSetDefault wraps gst_system_clock_set_default
+// SystemClockSetDefault wraps gst_system_clock_set_default
 // 
 // The function takes the following parameters:
 // 
@@ -30595,7 +32271,7 @@ func SystemClockInstanceObtain() Clock {
 // clock.
 // 
 // MT safe.
-func SystemClockInstanceSetDefault(newClock Clock) {
+func SystemClockSetDefault(newClock Clock) {
 	var carg1 *C.GstClock // in, none, converted, nullable
 
 	if newClock != nil {
@@ -30983,7 +32659,7 @@ func UnsafeBinToGlibFull(c Bin) unsafe.Pointer {
 	return gobject.UnsafeObjectToGlibFull(c)
 }
 
-// NewBinInstance wraps gst_bin_new
+// NewBin wraps gst_bin_new
 // 
 // The function takes the following parameters:
 // 
@@ -30994,7 +32670,7 @@ func UnsafeBinToGlibFull(c Bin) unsafe.Pointer {
 // 	- goret Element 
 //
 // Creates a new bin with the given name.
-func NewBinInstance(name string) Element {
+func NewBin(name string) Element {
 	var carg1 *C.gchar      // in, none, string, nullable-string
 	var cret  *C.GstElement // return, none, converted
 
@@ -31753,7 +33429,7 @@ func UnsafePipelineToGlibFull(c Pipeline) unsafe.Pointer {
 	return gobject.UnsafeObjectToGlibFull(c)
 }
 
-// NewPipelineInstance wraps gst_pipeline_new
+// NewPipeline wraps gst_pipeline_new
 // 
 // The function takes the following parameters:
 // 
@@ -31764,7 +33440,7 @@ func UnsafePipelineToGlibFull(c Pipeline) unsafe.Pointer {
 // 	- goret Element 
 //
 // Create a new pipeline with the given name.
-func NewPipelineInstance(name string) Element {
+func NewPipeline(name string) Element {
 	var carg1 *C.gchar      // in, none, string, nullable-string
 	var cret  *C.GstElement // return, none, converted
 
@@ -44494,6 +46170,28 @@ func (message *Message) AddRedirectEntry(location string, tagList *TagList, entr
 	runtime.KeepAlive(entryStruct)
 }
 
+// Copy wraps gst_message_copy
+// The function returns the following values:
+// 
+// 	- goret *Message 
+//
+// Creates a copy of the message. Returns a copy of the message.
+func (msg *Message) Copy() *Message {
+	var carg0 *C.GstMessage // in, none, converted
+	var cret  *C.GstMessage // return, full, converted
+
+	carg0 = (*C.GstMessage)(UnsafeMessageToGlibNone(msg))
+
+	cret = C.gst_message_copy(carg0)
+	runtime.KeepAlive(msg)
+
+	var goret *Message
+
+	goret = UnsafeMessageFromGlibFull(unsafe.Pointer(cret))
+
+	return goret
+}
+
 // GetNumRedirectEntries wraps gst_message_get_num_redirect_entries
 // The function returns the following values:
 // 
diff --git a/pkg/gst/init.go b/pkg/gst/init.go
new file mode 100644
index 0000000..6af72a1
--- /dev/null
+++ b/pkg/gst/init.go
@@ -0,0 +1,12 @@
+package gst
+
+// #cgo pkg-config: gstreamer-1.0
+// #cgo CFLAGS: -Wno-deprecated-declarations
+// #include <gst/gst.h>
+import "C"
+
+// Init binds to the gst_init() function. Argument parsing is not
+// supported.
+func Init() {
+	C.gst_init(nil, nil)
+}
diff --git a/pkg/gst/message.go b/pkg/gst/message.go
index 27fcaff..12ce592 100644
--- a/pkg/gst/message.go
+++ b/pkg/gst/message.go
@@ -1,7 +1,9 @@
 package gst
 
 import (
+	"fmt"
 	"runtime"
+	"strings"
 	"unsafe"
 
 	"github.com/diamondburned/gotk4/pkg/gobject/v2"
@@ -108,3 +110,206 @@ func (message *Message) GetStreamStatusObject() any {
 
 	return goret
 }
+
+// Type returns the MessageType of the message.
+func (message *Message) Type() MessageType {
+	return MessageType(message.message.native._type)
+}
+
+// Source returns the source object of the message.
+func (message *Message) Source() Object {
+	return UnsafeObjectFromGlibNone(unsafe.Pointer(message.message.native.src))
+}
+
+// String implements a stringer on the message. It iterates over the type of the message
+// and applies the correct parser, then dumps a string of the basic contents of the
+// message. This function can be expensive and should only be used for debugging purposes
+// or in routines where latency is not a concern.
+//
+// This stringer really just helps in keeping track of making sure all message types are
+// accounted for in some way. It's the devil, writing it was the devil, and I hope you
+// enjoy being able to `fmt.Println(msg)`.
+func (m *Message) String() string {
+	msg := fmt.Sprintf("[%s] %s - ", m.Source().GetName(), m.Type().String())
+	switch m.Type() {
+
+	case MessageEos:
+		msg += "End-of-stream reached in the pipeline"
+
+	case MessageInfo:
+		info, err := m.ParseInfo()
+		msg += fmt.Sprintf("Info: %s, err: %v", info, err)
+
+	case MessageWarning:
+		info, err := m.ParseWarning()
+		msg += fmt.Sprintf("Warning: %s, err: %v", info, err)
+
+	case MessageError:
+		info, err := m.ParseError()
+		msg += fmt.Sprintf("Error: %s, err: %v", info, err)
+
+	case MessageTag:
+		tags := m.ParseTag()
+
+		_ = tags // TODO
+		msg += "Tags: TODO"
+
+	case MessageBuffering:
+		mode, avgIn, avgOut, bufferingLeft := m.ParseBufferingStats()
+		msg += fmt.Sprintf(
+			"Buffering %s - %d%% complete (avg in %d/sec, avg out %d/sec, time left %s)",
+			mode,
+			m.ParseBuffering(),
+			avgIn,
+			avgOut,
+			bufferingLeft,
+		)
+
+	case MessageStateChanged:
+		oldstate, newstate, pending := m.ParseStateChanged()
+
+		msg += fmt.Sprintf("State changed from %s to %s (pending %s)", oldstate, newstate, pending)
+
+	case MessageStateDirty:
+		msg += "(DEPRECATED MESSAGE) An element changed state in a streaming thread"
+
+	case MessageStepDone:
+		format, amount, rate, flush, intermediate, duration, eos := m.ParseStepDone()
+
+		msg += fmt.Sprintf(
+			"Step done with format %s, amount %d, rate %f, flush %v, intermediate %v, duration %d, eos %v",
+			format.String(),
+			amount,
+			rate,
+			flush,
+			intermediate,
+			duration,
+			eos,
+		)
+
+	case MessageClockProvide:
+		msg += "Element has clock provide capability"
+
+	case MessageClockLost:
+		msg += "Lost a clock"
+
+	case MessageNewClock:
+		msg += "Got a new clock"
+
+	case MessageStructureChange:
+		chgType, elem, busy := m.ParseStructureChange()
+		msg += fmt.Sprintf("Structure change of type %s from %s. (in progress: %v)", chgType.String(), elem.GetName(), busy)
+
+	case MessageStreamStatus:
+		statusType, elem := m.ParseStreamStatus()
+		msg += fmt.Sprintf("Stream status from %s: %s", elem.GetName(), statusType.String())
+
+	case MessageApplication:
+		msg += "Message posted by the application, possibly via an application-specific element."
+
+	case MessageElement:
+		msg += "Internal element message posted"
+
+	case MessageSegmentStart:
+		format, pos := m.ParseSegmentStart()
+		msg += fmt.Sprintf("Segment started at %d %s", pos, format.String())
+
+	case MessageSegmentDone:
+		format, pos := m.ParseSegmentDone()
+		msg += fmt.Sprintf("Segment started at %d %s", pos, format.String())
+
+	case MessageDurationChanged:
+		msg += "The duration of the pipeline changed"
+
+	case MessageLatency:
+		msg += "Element's latency has changed"
+
+	case MessageAsyncStart:
+		msg += "Async task started"
+
+	case MessageAsyncDone:
+		msg += "Async task completed"
+		if dur := m.ParseAsyncDone(); dur > 0 {
+			msg += fmt.Sprintf(" in %d", dur)
+		}
+
+	case MessageRequestState:
+		msg += fmt.Sprintf("State change request to %s", m.ParseRequestState().String())
+
+	case MessageStepStart:
+		active, format, amount, rate, flush, intermediate := m.ParseStepStart()
+
+		msg += fmt.Sprintf("Step started with active %v, format %s, amount %d, rate %f, flush %v, intermediate %v",
+			active, format.String(), amount, rate, flush, intermediate,
+		)
+
+	case MessageQos:
+		format, processed, dropped := m.ParseQosStats()
+
+		msg += fmt.Sprintf("Qos stats: format %s, processed %d, dropped %d", format.String(), processed, dropped)
+
+	case MessageProgress:
+		progressType, code, text := m.ParseProgress()
+		msg += fmt.Sprintf("%s - %s - %s", strings.ToUpper(progressType.String()), code, text)
+
+	case MessageToc:
+		// TODO
+		msg += fmt.Sprintf("Message toc TODO")
+
+	case MessageResetTime:
+		msg += fmt.Sprintf("Running time: %s", m.ParseResetTime())
+
+	case MessageStreamStart:
+		msg += "Pipeline stream is starting"
+
+	case MessageNeedContext:
+		msg += "Element needs context"
+
+	case MessageHaveContext:
+		ctx := m.ParseHaveContext()
+		_ = ctx // TODO
+		msg += fmt.Sprintf("Received context of type %s", "ctx.GetType()")
+
+	case MessageExtended:
+		msg += "Extended message type"
+
+	case MessageDeviceAdded:
+		if device := m.ParseDeviceAdded(); device != nil {
+			msg += fmt.Sprintf("Device %s added", device.GetDisplayName())
+		}
+
+	case MessageDeviceRemoved:
+		if device := m.ParseDeviceRemoved(); device != nil {
+			msg += fmt.Sprintf("Device %s removed", device.GetDisplayName())
+		}
+
+	case MessageDeviceChanged:
+		if device, _ := m.ParseDeviceChanged(); device != nil {
+			msg += fmt.Sprintf("Device %s had its properties updated", device.GetDisplayName())
+		}
+
+	case MessagePropertyNotify:
+		obj, propName, propVal := m.ParsePropertyNotify()
+		if obj != nil && propVal != nil {
+			msg += fmt.Sprintf("Object %s had property '%s' changed to %+v", obj.GetName(), propName, propVal)
+		}
+
+	case MessageStreamCollection:
+		collection := m.ParseStreamCollection()
+		msg += fmt.Sprintf("New stream collection with upstream id: %s", collection.GetUpstreamID())
+
+	case MessageStreamsSelected:
+		collection := m.ParseStreamsSelected()
+		msg += fmt.Sprintf("Stream with upstream id '%s' has selected new streams", collection.GetUpstreamID())
+
+	case MessageRedirect:
+		msg += fmt.Sprintf("Received redirect message with %d entries", m.GetNumRedirectEntries())
+
+	case MessageUnknown:
+		msg += "Unknown message type"
+
+	case MessageAny:
+		msg += "Message did not match any known types"
+	}
+	return msg
+}
diff --git a/pkg/gstallocators/gstallocators.gen.go b/pkg/gstallocators/gstallocators.gen.go
index 98682f2..4566c09 100644
--- a/pkg/gstallocators/gstallocators.gen.go
+++ b/pkg/gstallocators/gstallocators.gen.go
@@ -4,6 +4,7 @@ package gstallocators
 
 import (
 	"runtime"
+	"strings"
 	"unsafe"
 
 	"github.com/diamondburned/gotk4/pkg/gobject/v2"
@@ -66,6 +67,27 @@ func (f FdMemoryFlags) Has(other FdMemoryFlags) bool {
 	return (f & other) == other
 }
 
+func (f FdMemoryFlags) String() string {
+	if f == 0 {
+		return "FdMemoryFlags(0)"
+	}
+
+	var parts []string
+	if (f & FdMemoryFlagNone) != 0 {
+		parts = append(parts, "FdMemoryFlagNone")
+	}
+	if (f & FdMemoryFlagKeepMapped) != 0 {
+		parts = append(parts, "FdMemoryFlagKeepMapped")
+	}
+	if (f & FdMemoryFlagMapPrivate) != 0 {
+		parts = append(parts, "FdMemoryFlagMapPrivate")
+	}
+	if (f & FdMemoryFlagDontClose) != 0 {
+		parts = append(parts, "FdMemoryFlagDontClose")
+	}
+	return "FdMemoryFlags(" + strings.Join(parts, "|") + ")"
+}
+
 // DmabufMemoryGetFd wraps gst_dmabuf_memory_get_fd
 // 
 // The function takes the following parameters:
@@ -446,7 +468,7 @@ func UnsafeDRMDumbAllocatorToGlibFull(c DRMDumbAllocator) unsafe.Pointer {
 	return gobject.UnsafeObjectToGlibFull(c)
 }
 
-// NewDRMDumbAllocatorInstanceWithDevicePath wraps gst_drm_dumb_allocator_new_with_device_path
+// NewDRMDumbAllocatorWithDevicePath wraps gst_drm_dumb_allocator_new_with_device_path
 // 
 // The function takes the following parameters:
 // 
@@ -459,7 +481,7 @@ func UnsafeDRMDumbAllocatorToGlibFull(c DRMDumbAllocator) unsafe.Pointer {
 // Creates a new #GstDRMDumbAllocator for the specific device path. This
 // function can fail if the path does not exist, is not a DRM device or if
 // the DRM device doesnot support DUMB allocation.
-func NewDRMDumbAllocatorInstanceWithDevicePath(drmDevicePath string) gst.Allocator {
+func NewDRMDumbAllocatorWithDevicePath(drmDevicePath string) gst.Allocator {
 	var carg1 *C.gchar        // in, none, string, casted *C.gchar
 	var cret  *C.GstAllocator // return, full, converted
 
@@ -476,7 +498,7 @@ func NewDRMDumbAllocatorInstanceWithDevicePath(drmDevicePath string) gst.Allocat
 	return goret
 }
 
-// NewDRMDumbAllocatorInstanceWithFd wraps gst_drm_dumb_allocator_new_with_fd
+// NewDRMDumbAllocatorWithFd wraps gst_drm_dumb_allocator_new_with_fd
 // 
 // The function takes the following parameters:
 // 
@@ -489,7 +511,7 @@ func NewDRMDumbAllocatorInstanceWithDevicePath(drmDevicePath string) gst.Allocat
 // Creates a new #GstDRMDumbAllocator for the specific file desciptor. This
 // function can fail if the file descriptor is not a DRM device or if
 // the DRM device does not support DUMB allocation.
-func NewDRMDumbAllocatorInstanceWithFd(drmFd int) gst.Allocator {
+func NewDRMDumbAllocatorWithFd(drmFd int) gst.Allocator {
 	var carg1 C.gint          // in, none, casted
 	var cret  *C.GstAllocator // return, full, converted
 
@@ -630,13 +652,13 @@ func UnsafeFdAllocatorToGlibFull(c FdAllocator) unsafe.Pointer {
 	return gobject.UnsafeObjectToGlibFull(c)
 }
 
-// NewFdAllocatorInstance wraps gst_fd_allocator_new
+// NewFdAllocator wraps gst_fd_allocator_new
 // The function returns the following values:
 // 
 // 	- goret gst.Allocator 
 //
 // Return a new fd allocator.
-func NewFdAllocatorInstance() gst.Allocator {
+func NewFdAllocator() gst.Allocator {
 	var cret *C.GstAllocator // return, full, converted
 
 	cret = C.gst_fd_allocator_new()
@@ -648,7 +670,7 @@ func NewFdAllocatorInstance() gst.Allocator {
 	return goret
 }
 
-// FdAllocatorInstanceAlloc wraps gst_fd_allocator_alloc
+// FdAllocatorAlloc wraps gst_fd_allocator_alloc
 // 
 // The function takes the following parameters:
 // 
@@ -662,7 +684,7 @@ func NewFdAllocatorInstance() gst.Allocator {
 // 	- goret *gst.Memory 
 //
 // Return a %GstMemory that wraps a generic file descriptor.
-func FdAllocatorInstanceAlloc(allocator gst.Allocator, fd int, size uint, flags FdMemoryFlags) *gst.Memory {
+func FdAllocatorAlloc(allocator gst.Allocator, fd int, size uint, flags FdMemoryFlags) *gst.Memory {
 	var carg1 *C.GstAllocator    // in, none, converted
 	var carg2 C.gint             // in, none, casted
 	var carg3 C.gsize            // in, none, casted
@@ -753,14 +775,14 @@ func UnsafeShmAllocatorToGlibFull(c ShmAllocator) unsafe.Pointer {
 	return gobject.UnsafeObjectToGlibFull(c)
 }
 
-// ShmAllocatorInstanceGet wraps gst_shm_allocator_get
+// ShmAllocatorGet wraps gst_shm_allocator_get
 // The function returns the following values:
 // 
 // 	- goret gst.Allocator 
 //
 // Get the #GstShmAllocator singleton previously registered with
 // gst_shm_allocator_init_once().
-func ShmAllocatorInstanceGet() gst.Allocator {
+func ShmAllocatorGet() gst.Allocator {
 	var cret *C.GstAllocator // return, full, converted
 
 	cret = C.gst_shm_allocator_get()
@@ -772,11 +794,11 @@ func ShmAllocatorInstanceGet() gst.Allocator {
 	return goret
 }
 
-// ShmAllocatorInstanceInitOnce wraps gst_shm_allocator_init_once
+// ShmAllocatorInitOnce wraps gst_shm_allocator_init_once
 //
 // Register a #GstShmAllocator using gst_allocator_register() with the name
 // %GST_ALLOCATOR_SHM. This is no-op after the first call.
-func ShmAllocatorInstanceInitOnce() {
+func ShmAllocatorInitOnce() {
 
 	C.gst_shm_allocator_init_once()
 }
@@ -839,13 +861,13 @@ func UnsafeDmaBufAllocatorToGlibFull(c DmaBufAllocator) unsafe.Pointer {
 	return gobject.UnsafeObjectToGlibFull(c)
 }
 
-// NewDmaBufAllocatorInstance wraps gst_dmabuf_allocator_new
+// NewDmaBufAllocator wraps gst_dmabuf_allocator_new
 // The function returns the following values:
 // 
 // 	- goret gst.Allocator 
 //
 // Return a new dmabuf allocator.
-func NewDmaBufAllocatorInstance() gst.Allocator {
+func NewDmaBufAllocator() gst.Allocator {
 	var cret *C.GstAllocator // return, full, converted
 
 	cret = C.gst_dmabuf_allocator_new()
@@ -857,7 +879,7 @@ func NewDmaBufAllocatorInstance() gst.Allocator {
 	return goret
 }
 
-// DmaBufAllocatorInstanceAlloc wraps gst_dmabuf_allocator_alloc
+// DmaBufAllocatorAlloc wraps gst_dmabuf_allocator_alloc
 // 
 // The function takes the following parameters:
 // 
@@ -870,7 +892,7 @@ func NewDmaBufAllocatorInstance() gst.Allocator {
 // 	- goret *gst.Memory 
 //
 // Return a %GstMemory that wraps a dmabuf file descriptor.
-func DmaBufAllocatorInstanceAlloc(allocator gst.Allocator, fd int, size uint) *gst.Memory {
+func DmaBufAllocatorAlloc(allocator gst.Allocator, fd int, size uint) *gst.Memory {
 	var carg1 *C.GstAllocator // in, none, converted
 	var carg2 C.gint          // in, none, casted
 	var carg3 C.gsize         // in, none, casted
@@ -892,7 +914,7 @@ func DmaBufAllocatorInstanceAlloc(allocator gst.Allocator, fd int, size uint) *g
 	return goret
 }
 
-// DmaBufAllocatorInstanceAllocWithFlags wraps gst_dmabuf_allocator_alloc_with_flags
+// DmaBufAllocatorAllocWithFlags wraps gst_dmabuf_allocator_alloc_with_flags
 // 
 // The function takes the following parameters:
 // 
@@ -906,7 +928,7 @@ func DmaBufAllocatorInstanceAlloc(allocator gst.Allocator, fd int, size uint) *g
 // 	- goret *gst.Memory 
 //
 // Return a %GstMemory that wraps a dmabuf file descriptor.
-func DmaBufAllocatorInstanceAllocWithFlags(allocator gst.Allocator, fd int, size uint, flags FdMemoryFlags) *gst.Memory {
+func DmaBufAllocatorAllocWithFlags(allocator gst.Allocator, fd int, size uint, flags FdMemoryFlags) *gst.Memory {
 	var carg1 *C.GstAllocator    // in, none, converted
 	var carg2 C.gint             // in, none, casted
 	var carg3 C.gsize            // in, none, casted
diff --git a/pkg/gstapp/gstapp.gen.go b/pkg/gstapp/gstapp.gen.go
index 81be8e8..334d9f1 100644
--- a/pkg/gstapp/gstapp.gen.go
+++ b/pkg/gstapp/gstapp.gen.go
@@ -3,6 +3,7 @@
 package gstapp
 
 import (
+	"fmt"
 	"runtime"
 	"unsafe"
 
@@ -65,6 +66,15 @@ func (e AppLeakyType) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e AppLeakyType) String() string {
+	switch e {
+		case AppLeakyTypeDownstream: return "AppLeakyTypeDownstream"
+		case AppLeakyTypeNone: return "AppLeakyTypeNone"
+		case AppLeakyTypeUpstream: return "AppLeakyTypeUpstream"
+		default: return fmt.Sprintf("AppLeakyType(%d)", e)
+	}
+}
+
 // AppStreamType wraps GstAppStreamType
 //
 // The stream type.
@@ -99,6 +109,15 @@ func (e AppStreamType) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e AppStreamType) String() string {
+	switch e {
+		case AppStreamTypeSeekable: return "AppStreamTypeSeekable"
+		case AppStreamTypeRandomAccess: return "AppStreamTypeRandomAccess"
+		case AppStreamTypeStream: return "AppStreamTypeStream"
+		default: return fmt.Sprintf("AppStreamType(%d)", e)
+	}
+}
+
 // AppSinkInstance is the instance type used by all types extending GstAppSink. It is used internally by the bindings. Users should use the interface [AppSink] instead.
 type AppSinkInstance struct {
 	_ [0]func() // equal guard
diff --git a/pkg/gstaudio/gstaudio.gen.go b/pkg/gstaudio/gstaudio.gen.go
index a410c00..e807d03 100644
--- a/pkg/gstaudio/gstaudio.gen.go
+++ b/pkg/gstaudio/gstaudio.gen.go
@@ -3,7 +3,9 @@
 package gstaudio
 
 import (
+	"fmt"
 	"runtime"
+	"strings"
 	"unsafe"
 
 	"github.com/diamondburned/gotk4/pkg/core/userdata"
@@ -183,6 +185,18 @@ func (e AudioBaseSinkDiscontReason) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e AudioBaseSinkDiscontReason) String() string {
+	switch e {
+		case AudioBaseSinkDiscontReasonNewCaps: return "AudioBaseSinkDiscontReasonNewCaps"
+		case AudioBaseSinkDiscontReasonFlush: return "AudioBaseSinkDiscontReasonFlush"
+		case AudioBaseSinkDiscontReasonSyncLatency: return "AudioBaseSinkDiscontReasonSyncLatency"
+		case AudioBaseSinkDiscontReasonAlignment: return "AudioBaseSinkDiscontReasonAlignment"
+		case AudioBaseSinkDiscontReasonDeviceFailure: return "AudioBaseSinkDiscontReasonDeviceFailure"
+		case AudioBaseSinkDiscontReasonNoDiscont: return "AudioBaseSinkDiscontReasonNoDiscont"
+		default: return fmt.Sprintf("AudioBaseSinkDiscontReason(%d)", e)
+	}
+}
+
 // AudioBaseSinkSlaveMethod wraps GstAudioBaseSinkSlaveMethod
 //
 // Different possible clock slaving algorithms used when the internal audio
@@ -220,6 +234,16 @@ func (e AudioBaseSinkSlaveMethod) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e AudioBaseSinkSlaveMethod) String() string {
+	switch e {
+		case AudioBaseSinkSlaveResample: return "AudioBaseSinkSlaveResample"
+		case AudioBaseSinkSlaveSkew: return "AudioBaseSinkSlaveSkew"
+		case AudioBaseSinkSlaveNone: return "AudioBaseSinkSlaveNone"
+		case AudioBaseSinkSlaveCustom: return "AudioBaseSinkSlaveCustom"
+		default: return fmt.Sprintf("AudioBaseSinkSlaveMethod(%d)", e)
+	}
+}
+
 // AudioBaseSrcSlaveMethod wraps GstAudioBaseSrcSlaveMethod
 //
 // Different possible clock slaving algorithms when the internal audio clock was
@@ -258,6 +282,16 @@ func (e AudioBaseSrcSlaveMethod) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e AudioBaseSrcSlaveMethod) String() string {
+	switch e {
+		case AudioBaseSrcSlaveResample: return "AudioBaseSrcSlaveResample"
+		case AudioBaseSrcSlaveReTimestamp: return "AudioBaseSrcSlaveReTimestamp"
+		case AudioBaseSrcSlaveSkew: return "AudioBaseSrcSlaveSkew"
+		case AudioBaseSrcSlaveNone: return "AudioBaseSrcSlaveNone"
+		default: return fmt.Sprintf("AudioBaseSrcSlaveMethod(%d)", e)
+	}
+}
+
 // AudioCdSrcMode wraps GstAudioCdSrcMode
 //
 // Mode in which the CD audio source operates. Influences timestamping,
@@ -286,6 +320,14 @@ func (e AudioCdSrcMode) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e AudioCdSrcMode) String() string {
+	switch e {
+		case AudioCdSrcModeNormal: return "AudioCdSrcModeNormal"
+		case AudioCdSrcModeContinuous: return "AudioCdSrcModeContinuous"
+		default: return fmt.Sprintf("AudioCdSrcMode(%d)", e)
+	}
+}
+
 // AudioChannelPosition wraps GstAudioChannelPosition
 //
 // Audio channel positions.
@@ -455,6 +497,43 @@ func (e AudioChannelPosition) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e AudioChannelPosition) String() string {
+	switch e {
+		case AudioChannelPositionFrontLeft: return "AudioChannelPositionFrontLeft"
+		case AudioChannelPositionFrontCenter: return "AudioChannelPositionFrontCenter"
+		case AudioChannelPositionTopFrontRight: return "AudioChannelPositionTopFrontRight"
+		case AudioChannelPositionWideRight: return "AudioChannelPositionWideRight"
+		case AudioChannelPositionTopSideRight: return "AudioChannelPositionTopSideRight"
+		case AudioChannelPositionInvalid: return "AudioChannelPositionInvalid"
+		case AudioChannelPositionRearLeft: return "AudioChannelPositionRearLeft"
+		case AudioChannelPositionRearRight: return "AudioChannelPositionRearRight"
+		case AudioChannelPositionFrontLeftOfCenter: return "AudioChannelPositionFrontLeftOfCenter"
+		case AudioChannelPositionSideRight: return "AudioChannelPositionSideRight"
+		case AudioChannelPositionTopRearLeft: return "AudioChannelPositionTopRearLeft"
+		case AudioChannelPositionTopSideLeft: return "AudioChannelPositionTopSideLeft"
+		case AudioChannelPositionRearCenter: return "AudioChannelPositionRearCenter"
+		case AudioChannelPositionLfe2: return "AudioChannelPositionLfe2"
+		case AudioChannelPositionFrontRight: return "AudioChannelPositionFrontRight"
+		case AudioChannelPositionLfe1: return "AudioChannelPositionLfe1"
+		case AudioChannelPositionTopFrontLeft: return "AudioChannelPositionTopFrontLeft"
+		case AudioChannelPositionBottomFrontRight: return "AudioChannelPositionBottomFrontRight"
+		case AudioChannelPositionSurroundRight: return "AudioChannelPositionSurroundRight"
+		case AudioChannelPositionTopFrontCenter: return "AudioChannelPositionTopFrontCenter"
+		case AudioChannelPositionTopCenter: return "AudioChannelPositionTopCenter"
+		case AudioChannelPositionBottomFrontCenter: return "AudioChannelPositionBottomFrontCenter"
+		case AudioChannelPositionWideLeft: return "AudioChannelPositionWideLeft"
+		case AudioChannelPositionSurroundLeft: return "AudioChannelPositionSurroundLeft"
+		case AudioChannelPositionTopRearCenter: return "AudioChannelPositionTopRearCenter"
+		case AudioChannelPositionBottomFrontLeft: return "AudioChannelPositionBottomFrontLeft"
+		case AudioChannelPositionSideLeft: return "AudioChannelPositionSideLeft"
+		case AudioChannelPositionTopRearRight: return "AudioChannelPositionTopRearRight"
+		case AudioChannelPositionMono: return "AudioChannelPositionMono"
+		case AudioChannelPositionFrontRightOfCenter: return "AudioChannelPositionFrontRightOfCenter"
+		case AudioChannelPositionNone: return "AudioChannelPositionNone"
+		default: return fmt.Sprintf("AudioChannelPosition(%d)", e)
+	}
+}
+
 // AudioDitherMethod wraps GstAudioDitherMethod
 //
 // Set of available dithering methods.
@@ -490,6 +569,16 @@ func (e AudioDitherMethod) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e AudioDitherMethod) String() string {
+	switch e {
+		case AudioDitherNone: return "AudioDitherNone"
+		case AudioDitherRpdf: return "AudioDitherRpdf"
+		case AudioDitherTpdf: return "AudioDitherTpdf"
+		case AudioDitherTpdfHf: return "AudioDitherTpdfHf"
+		default: return fmt.Sprintf("AudioDitherMethod(%d)", e)
+	}
+}
+
 // AudioFormat wraps GstAudioFormat
 //
 // Enum value describing the most common audio formats.
@@ -693,6 +782,44 @@ func (e AudioFormat) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e AudioFormat) String() string {
+	switch e {
+		case AudioFormatU2432LE: return "AudioFormatU2432LE"
+		case AudioFormatS20Be: return "AudioFormatS20Be"
+		case AudioFormatS18LE: return "AudioFormatS18LE"
+		case AudioFormatF32LE: return "AudioFormatF32LE"
+		case AudioFormatS8: return "AudioFormatS8"
+		case AudioFormatU8: return "AudioFormatU8"
+		case AudioFormatU2432Be: return "AudioFormatU2432Be"
+		case AudioFormatF64LE: return "AudioFormatF64LE"
+		case AudioFormatUnknown: return "AudioFormatUnknown"
+		case AudioFormatS32Be: return "AudioFormatS32Be"
+		case AudioFormatU16LE: return "AudioFormatU16LE"
+		case AudioFormatU32Be: return "AudioFormatU32Be"
+		case AudioFormatF32Be: return "AudioFormatF32Be"
+		case AudioFormatS16Be: return "AudioFormatS16Be"
+		case AudioFormatS2432LE: return "AudioFormatS2432LE"
+		case AudioFormatS2432Be: return "AudioFormatS2432Be"
+		case AudioFormatS24LE: return "AudioFormatS24LE"
+		case AudioFormatU24LE: return "AudioFormatU24LE"
+		case AudioFormatU20Be: return "AudioFormatU20Be"
+		case AudioFormatF64Be: return "AudioFormatF64Be"
+		case AudioFormatEncoded: return "AudioFormatEncoded"
+		case AudioFormatS32LE: return "AudioFormatS32LE"
+		case AudioFormatS20LE: return "AudioFormatS20LE"
+		case AudioFormatS18Be: return "AudioFormatS18Be"
+		case AudioFormatS16LE: return "AudioFormatS16LE"
+		case AudioFormatU16Be: return "AudioFormatU16Be"
+		case AudioFormatU32LE: return "AudioFormatU32LE"
+		case AudioFormatS24Be: return "AudioFormatS24Be"
+		case AudioFormatU24Be: return "AudioFormatU24Be"
+		case AudioFormatU18Be: return "AudioFormatU18Be"
+		case AudioFormatU20LE: return "AudioFormatU20LE"
+		case AudioFormatU18LE: return "AudioFormatU18LE"
+		default: return fmt.Sprintf("AudioFormat(%d)", e)
+	}
+}
+
 // AudioLayout wraps GstAudioLayout
 //
 // Layout of the audio samples for the different channels.
@@ -720,6 +847,14 @@ func (e AudioLayout) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e AudioLayout) String() string {
+	switch e {
+		case AudioLayoutInterleaved: return "AudioLayoutInterleaved"
+		case AudioLayoutNonInterleaved: return "AudioLayoutNonInterleaved"
+		default: return fmt.Sprintf("AudioLayout(%d)", e)
+	}
+}
+
 // AudioNoiseShapingMethod wraps GstAudioNoiseShapingMethod
 //
 // Set of available noise shaping methods
@@ -759,6 +894,17 @@ func (e AudioNoiseShapingMethod) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e AudioNoiseShapingMethod) String() string {
+	switch e {
+		case AudioNoiseShapingMedium: return "AudioNoiseShapingMedium"
+		case AudioNoiseShapingHigh: return "AudioNoiseShapingHigh"
+		case AudioNoiseShapingNone: return "AudioNoiseShapingNone"
+		case AudioNoiseShapingErrorFeedback: return "AudioNoiseShapingErrorFeedback"
+		case AudioNoiseShapingSimple: return "AudioNoiseShapingSimple"
+		default: return fmt.Sprintf("AudioNoiseShapingMethod(%d)", e)
+	}
+}
+
 // AudioResamplerFilterInterpolation wraps GstAudioResamplerFilterInterpolation
 //
 // The different filter interpolation methods.
@@ -792,6 +938,15 @@ func (e AudioResamplerFilterInterpolation) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e AudioResamplerFilterInterpolation) String() string {
+	switch e {
+		case AudioResamplerFilterInterpolationNone: return "AudioResamplerFilterInterpolationNone"
+		case AudioResamplerFilterInterpolationLinear: return "AudioResamplerFilterInterpolationLinear"
+		case AudioResamplerFilterInterpolationCubic: return "AudioResamplerFilterInterpolationCubic"
+		default: return fmt.Sprintf("AudioResamplerFilterInterpolation(%d)", e)
+	}
+}
+
 // AudioResamplerFilterMode wraps GstAudioResamplerFilterMode
 //
 // Select for the filter tables should be set up.
@@ -827,6 +982,15 @@ func (e AudioResamplerFilterMode) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e AudioResamplerFilterMode) String() string {
+	switch e {
+		case AudioResamplerFilterModeFull: return "AudioResamplerFilterModeFull"
+		case AudioResamplerFilterModeAuto: return "AudioResamplerFilterModeAuto"
+		case AudioResamplerFilterModeInterpolated: return "AudioResamplerFilterModeInterpolated"
+		default: return fmt.Sprintf("AudioResamplerFilterMode(%d)", e)
+	}
+}
+
 // AudioResamplerMethod wraps GstAudioResamplerMethod
 //
 // Different subsampling and upsampling methods
@@ -868,6 +1032,17 @@ func (e AudioResamplerMethod) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e AudioResamplerMethod) String() string {
+	switch e {
+		case AudioResamplerMethodKaiser: return "AudioResamplerMethodKaiser"
+		case AudioResamplerMethodNearest: return "AudioResamplerMethodNearest"
+		case AudioResamplerMethodLinear: return "AudioResamplerMethodLinear"
+		case AudioResamplerMethodCubic: return "AudioResamplerMethodCubic"
+		case AudioResamplerMethodBlackmanNuttall: return "AudioResamplerMethodBlackmanNuttall"
+		default: return fmt.Sprintf("AudioResamplerMethod(%d)", e)
+	}
+}
+
 // AudioRingBufferFormatType wraps GstAudioRingBufferFormatType
 //
 // The format of the samples in the ringbuffer.
@@ -951,6 +1126,28 @@ func (e AudioRingBufferFormatType) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e AudioRingBufferFormatType) String() string {
+	switch e {
+		case AudioRingBufferFormatTypeMuLaw: return "AudioRingBufferFormatTypeMuLaw"
+		case AudioRingBufferFormatTypeALaw: return "AudioRingBufferFormatTypeALaw"
+		case AudioRingBufferFormatTypeMpeg2Aac: return "AudioRingBufferFormatTypeMpeg2Aac"
+		case AudioRingBufferFormatTypeDsd: return "AudioRingBufferFormatTypeDsd"
+		case AudioRingBufferFormatTypeMpeg: return "AudioRingBufferFormatTypeMpeg"
+		case AudioRingBufferFormatTypeGsm: return "AudioRingBufferFormatTypeGsm"
+		case AudioRingBufferFormatTypeDts: return "AudioRingBufferFormatTypeDts"
+		case AudioRingBufferFormatTypeMpeg4Aac: return "AudioRingBufferFormatTypeMpeg4Aac"
+		case AudioRingBufferFormatTypeMpeg4AacRaw: return "AudioRingBufferFormatTypeMpeg4AacRaw"
+		case AudioRingBufferFormatTypeFlac: return "AudioRingBufferFormatTypeFlac"
+		case AudioRingBufferFormatTypeRaw: return "AudioRingBufferFormatTypeRaw"
+		case AudioRingBufferFormatTypeImaAdpcm: return "AudioRingBufferFormatTypeImaAdpcm"
+		case AudioRingBufferFormatTypeAc3: return "AudioRingBufferFormatTypeAc3"
+		case AudioRingBufferFormatTypeEac3: return "AudioRingBufferFormatTypeEac3"
+		case AudioRingBufferFormatTypeIec958: return "AudioRingBufferFormatTypeIec958"
+		case AudioRingBufferFormatTypeMpeg2AacRaw: return "AudioRingBufferFormatTypeMpeg2AacRaw"
+		default: return fmt.Sprintf("AudioRingBufferFormatType(%d)", e)
+	}
+}
+
 // AudioRingBufferState wraps GstAudioRingBufferState
 //
 // The state of the ringbuffer.
@@ -988,6 +1185,16 @@ func (e AudioRingBufferState) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e AudioRingBufferState) String() string {
+	switch e {
+		case AudioRingBufferStateStopped: return "AudioRingBufferStateStopped"
+		case AudioRingBufferStatePaused: return "AudioRingBufferStatePaused"
+		case AudioRingBufferStateStarted: return "AudioRingBufferStateStarted"
+		case AudioRingBufferStateError: return "AudioRingBufferStateError"
+		default: return fmt.Sprintf("AudioRingBufferState(%d)", e)
+	}
+}
+
 // DsdFormat wraps GstDsdFormat
 //
 // Enum value describing how DSD bits are grouped.
@@ -1043,6 +1250,19 @@ func (e DsdFormat) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e DsdFormat) String() string {
+	switch e {
+		case DsdFormatU16LE: return "DsdFormatU16LE"
+		case DsdFormatU16Be: return "DsdFormatU16Be"
+		case DsdFormatU32LE: return "DsdFormatU32LE"
+		case DsdFormatU32Be: return "DsdFormatU32Be"
+		case NumDsdFormats: return "NumDsdFormats"
+		case DsdFormatUnknown: return "DsdFormatUnknown"
+		case DsdFormatU8: return "DsdFormatU8"
+		default: return fmt.Sprintf("DsdFormat(%d)", e)
+	}
+}
+
 // StreamVolumeFormat wraps GstStreamVolumeFormat
 //
 // Different representations of a stream volume. gst_stream_volume_convert_volume()
@@ -1068,6 +1288,15 @@ const (
 )
 
 
+func (e StreamVolumeFormat) String() string {
+	switch e {
+		case StreamVolumeFormatLinear: return "StreamVolumeFormatLinear"
+		case StreamVolumeFormatCubic: return "StreamVolumeFormatCubic"
+		case StreamVolumeFormatDb: return "StreamVolumeFormatDb"
+		default: return fmt.Sprintf("StreamVolumeFormat(%d)", e)
+	}
+}
+
 // AudioChannelMixerFlags wraps GstAudioChannelMixerFlags
 //
 // Flags passed to gst_audio_channel_mixer_new()
@@ -1111,6 +1340,30 @@ func (f AudioChannelMixerFlags) InitGoValue(v *gobject.Value) {
 	v.SetFlags(int(f))
 }
 
+func (f AudioChannelMixerFlags) String() string {
+	if f == 0 {
+		return "AudioChannelMixerFlags(0)"
+	}
+
+	var parts []string
+	if (f & AudioChannelMixerFlagsNone) != 0 {
+		parts = append(parts, "AudioChannelMixerFlagsNone")
+	}
+	if (f & AudioChannelMixerFlagsNonInterleavedIn) != 0 {
+		parts = append(parts, "AudioChannelMixerFlagsNonInterleavedIn")
+	}
+	if (f & AudioChannelMixerFlagsNonInterleavedOut) != 0 {
+		parts = append(parts, "AudioChannelMixerFlagsNonInterleavedOut")
+	}
+	if (f & AudioChannelMixerFlagsUnpositionedIn) != 0 {
+		parts = append(parts, "AudioChannelMixerFlagsUnpositionedIn")
+	}
+	if (f & AudioChannelMixerFlagsUnpositionedOut) != 0 {
+		parts = append(parts, "AudioChannelMixerFlagsUnpositionedOut")
+	}
+	return "AudioChannelMixerFlags(" + strings.Join(parts, "|") + ")"
+}
+
 // AudioConverterFlags wraps GstAudioConverterFlags
 //
 // Extra flags passed to gst_audio_converter_new() and gst_audio_converter_samples().
@@ -1148,6 +1401,24 @@ func (f AudioConverterFlags) InitGoValue(v *gobject.Value) {
 	v.SetFlags(int(f))
 }
 
+func (f AudioConverterFlags) String() string {
+	if f == 0 {
+		return "AudioConverterFlags(0)"
+	}
+
+	var parts []string
+	if (f & AudioConverterFlagNone) != 0 {
+		parts = append(parts, "AudioConverterFlagNone")
+	}
+	if (f & AudioConverterFlagInWritable) != 0 {
+		parts = append(parts, "AudioConverterFlagInWritable")
+	}
+	if (f & AudioConverterFlagVariableRate) != 0 {
+		parts = append(parts, "AudioConverterFlagVariableRate")
+	}
+	return "AudioConverterFlags(" + strings.Join(parts, "|") + ")"
+}
+
 // AudioFlags wraps GstAudioFlags
 //
 // Extra audio flags
@@ -1180,6 +1451,21 @@ func (f AudioFlags) InitGoValue(v *gobject.Value) {
 	v.SetFlags(int(f))
 }
 
+func (f AudioFlags) String() string {
+	if f == 0 {
+		return "AudioFlags(0)"
+	}
+
+	var parts []string
+	if (f & AudioFlagNone) != 0 {
+		parts = append(parts, "AudioFlagNone")
+	}
+	if (f & AudioFlagUnpositioned) != 0 {
+		parts = append(parts, "AudioFlagUnpositioned")
+	}
+	return "AudioFlags(" + strings.Join(parts, "|") + ")"
+}
+
 // AudioFormatFlags wraps GstAudioFormatFlags
 //
 // The different audio flags that a format info can have.
@@ -1224,6 +1510,30 @@ func (f AudioFormatFlags) InitGoValue(v *gobject.Value) {
 	v.SetFlags(int(f))
 }
 
+func (f AudioFormatFlags) String() string {
+	if f == 0 {
+		return "AudioFormatFlags(0)"
+	}
+
+	var parts []string
+	if (f & AudioFormatFlagInteger) != 0 {
+		parts = append(parts, "AudioFormatFlagInteger")
+	}
+	if (f & AudioFormatFlagFloat) != 0 {
+		parts = append(parts, "AudioFormatFlagFloat")
+	}
+	if (f & AudioFormatFlagSigned) != 0 {
+		parts = append(parts, "AudioFormatFlagSigned")
+	}
+	if (f & AudioFormatFlagComplex) != 0 {
+		parts = append(parts, "AudioFormatFlagComplex")
+	}
+	if (f & AudioFormatFlagUnpack) != 0 {
+		parts = append(parts, "AudioFormatFlagUnpack")
+	}
+	return "AudioFormatFlags(" + strings.Join(parts, "|") + ")"
+}
+
 // AudioPackFlags wraps GstAudioPackFlags
 //
 // The different flags that can be used when packing and unpacking.
@@ -1259,6 +1569,21 @@ func (f AudioPackFlags) InitGoValue(v *gobject.Value) {
 	v.SetFlags(int(f))
 }
 
+func (f AudioPackFlags) String() string {
+	if f == 0 {
+		return "AudioPackFlags(0)"
+	}
+
+	var parts []string
+	if (f & AudioPackFlagNone) != 0 {
+		parts = append(parts, "AudioPackFlagNone")
+	}
+	if (f & AudioPackFlagTruncateRange) != 0 {
+		parts = append(parts, "AudioPackFlagTruncateRange")
+	}
+	return "AudioPackFlags(" + strings.Join(parts, "|") + ")"
+}
+
 // AudioQuantizeFlags wraps GstAudioQuantizeFlags
 //
 // Extra flags that can be passed to gst_audio_quantize_new()
@@ -1290,6 +1615,21 @@ func (f AudioQuantizeFlags) InitGoValue(v *gobject.Value) {
 	v.SetFlags(int(f))
 }
 
+func (f AudioQuantizeFlags) String() string {
+	if f == 0 {
+		return "AudioQuantizeFlags(0)"
+	}
+
+	var parts []string
+	if (f & AudioQuantizeFlagNone) != 0 {
+		parts = append(parts, "AudioQuantizeFlagNone")
+	}
+	if (f & AudioQuantizeFlagNonInterleaved) != 0 {
+		parts = append(parts, "AudioQuantizeFlagNonInterleaved")
+	}
+	return "AudioQuantizeFlags(" + strings.Join(parts, "|") + ")"
+}
+
 // AudioResamplerFlags wraps GstAudioResamplerFlags
 //
 // Different resampler flags.
@@ -1335,6 +1675,27 @@ func (f AudioResamplerFlags) InitGoValue(v *gobject.Value) {
 	v.SetFlags(int(f))
 }
 
+func (f AudioResamplerFlags) String() string {
+	if f == 0 {
+		return "AudioResamplerFlags(0)"
+	}
+
+	var parts []string
+	if (f & AudioResamplerFlagNone) != 0 {
+		parts = append(parts, "AudioResamplerFlagNone")
+	}
+	if (f & AudioResamplerFlagNonInterleavedIn) != 0 {
+		parts = append(parts, "AudioResamplerFlagNonInterleavedIn")
+	}
+	if (f & AudioResamplerFlagNonInterleavedOut) != 0 {
+		parts = append(parts, "AudioResamplerFlagNonInterleavedOut")
+	}
+	if (f & AudioResamplerFlagVariableRate) != 0 {
+		parts = append(parts, "AudioResamplerFlagVariableRate")
+	}
+	return "AudioResamplerFlags(" + strings.Join(parts, "|") + ")"
+}
+
 // AudioBaseSinkCustomSlavingCallback wraps GstAudioBaseSinkCustomSlavingCallback
 //
 // This function is set with gst_audio_base_sink_set_custom_slaving_callback()
@@ -2383,7 +2744,7 @@ func UnsafeStreamVolumeToGlibFull(c StreamVolume) unsafe.Pointer {
 	return gobject.UnsafeObjectToGlibFull(&i.Instance)
 }
 
-// StreamVolumeInstanceConvertVolume wraps gst_stream_volume_convert_volume
+// StreamVolumeConvertVolume wraps gst_stream_volume_convert_volume
 // 
 // The function takes the following parameters:
 // 
@@ -2394,7 +2755,7 @@ func UnsafeStreamVolumeToGlibFull(c StreamVolume) unsafe.Pointer {
 // The function returns the following values:
 // 
 // 	- goret float64 
-func StreamVolumeInstanceConvertVolume(from StreamVolumeFormat, to StreamVolumeFormat, val float64) float64 {
+func StreamVolumeConvertVolume(from StreamVolumeFormat, to StreamVolumeFormat, val float64) float64 {
 	var carg1 C.GstStreamVolumeFormat // in, none, casted
 	var carg2 C.GstStreamVolumeFormat // in, none, casted
 	var carg3 C.gdouble               // in, none, casted
@@ -3628,7 +3989,7 @@ func UnsafeAudioClockToGlibFull(c AudioClock) unsafe.Pointer {
 	return gobject.UnsafeObjectToGlibFull(c)
 }
 
-// NewAudioClockInstance wraps gst_audio_clock_new
+// NewAudioClock wraps gst_audio_clock_new
 // 
 // The function takes the following parameters:
 // 
@@ -3642,7 +4003,7 @@ func UnsafeAudioClockToGlibFull(c AudioClock) unsafe.Pointer {
 // Create a new #GstAudioClock instance. Whenever the clock time should be
 // calculated it will call @func with @user_data. When @func returns
 // #GST_CLOCK_TIME_NONE, the clock will return the last reported time.
-func NewAudioClockInstance(name string, fn AudioClockGetTimeFunc) gst.Clock {
+func NewAudioClock(name string, fn AudioClockGetTimeFunc) gst.Clock {
 	var carg1 *C.gchar                   // in, none, string, casted *C.gchar
 	var carg2 C.GstAudioClockGetTimeFunc // callback, scope: notified, closure: carg3, destroy: carg4
 	var carg3 C.gpointer                 // implicit
@@ -6735,14 +7096,14 @@ func UnsafeAudioRingBufferToGlibFull(c AudioRingBuffer) unsafe.Pointer {
 	return gobject.UnsafeObjectToGlibFull(c)
 }
 
-// AudioRingBufferInstanceDebugSpecBuff wraps gst_audio_ring_buffer_debug_spec_buff
+// AudioRingBufferDebugSpecBuff wraps gst_audio_ring_buffer_debug_spec_buff
 // 
 // The function takes the following parameters:
 // 
 // 	- spec *AudioRingBufferSpec: the spec to debug 
 //
 // Print debug info about the buffer sized in @spec to the debug log.
-func AudioRingBufferInstanceDebugSpecBuff(spec *AudioRingBufferSpec) {
+func AudioRingBufferDebugSpecBuff(spec *AudioRingBufferSpec) {
 	var carg1 *C.GstAudioRingBufferSpec // in, none, converted
 
 	carg1 = (*C.GstAudioRingBufferSpec)(UnsafeAudioRingBufferSpecToGlibNone(spec))
@@ -6751,14 +7112,14 @@ func AudioRingBufferInstanceDebugSpecBuff(spec *AudioRingBufferSpec) {
 	runtime.KeepAlive(spec)
 }
 
-// AudioRingBufferInstanceDebugSpecCaps wraps gst_audio_ring_buffer_debug_spec_caps
+// AudioRingBufferDebugSpecCaps wraps gst_audio_ring_buffer_debug_spec_caps
 // 
 // The function takes the following parameters:
 // 
 // 	- spec *AudioRingBufferSpec: the spec to debug 
 //
 // Print debug info about the parsed caps in @spec to the debug log.
-func AudioRingBufferInstanceDebugSpecCaps(spec *AudioRingBufferSpec) {
+func AudioRingBufferDebugSpecCaps(spec *AudioRingBufferSpec) {
 	var carg1 *C.GstAudioRingBufferSpec // in, none, converted
 
 	carg1 = (*C.GstAudioRingBufferSpec)(UnsafeAudioRingBufferSpecToGlibNone(spec))
@@ -6767,7 +7128,7 @@ func AudioRingBufferInstanceDebugSpecCaps(spec *AudioRingBufferSpec) {
 	runtime.KeepAlive(spec)
 }
 
-// AudioRingBufferInstanceParseCaps wraps gst_audio_ring_buffer_parse_caps
+// AudioRingBufferParseCaps wraps gst_audio_ring_buffer_parse_caps
 // 
 // The function takes the following parameters:
 // 
@@ -6779,7 +7140,7 @@ func AudioRingBufferInstanceDebugSpecCaps(spec *AudioRingBufferSpec) {
 // 	- goret bool 
 //
 // Parse @caps into @spec.
-func AudioRingBufferInstanceParseCaps(spec *AudioRingBufferSpec, caps *gst.Caps) bool {
+func AudioRingBufferParseCaps(spec *AudioRingBufferSpec, caps *gst.Caps) bool {
 	var carg1 *C.GstAudioRingBufferSpec // in, none, converted
 	var carg2 *C.GstCaps                // in, none, converted
 	var cret  C.gboolean                // return
diff --git a/pkg/gstbase/gstbase.gen.go b/pkg/gstbase/gstbase.gen.go
index b20b6bd..525c859 100644
--- a/pkg/gstbase/gstbase.gen.go
+++ b/pkg/gstbase/gstbase.gen.go
@@ -3,7 +3,9 @@
 package gstbase
 
 import (
+	"fmt"
 	"runtime"
+	"strings"
 	"unsafe"
 
 	"github.com/diamondburned/gotk4/pkg/core/userdata"
@@ -94,6 +96,15 @@ func (e AggregatorStartTimeSelection) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e AggregatorStartTimeSelection) String() string {
+	switch e {
+		case AggregatorStartTimeSelectionFirst: return "AggregatorStartTimeSelectionFirst"
+		case AggregatorStartTimeSelectionSet: return "AggregatorStartTimeSelectionSet"
+		case AggregatorStartTimeSelectionZero: return "AggregatorStartTimeSelectionZero"
+		default: return fmt.Sprintf("AggregatorStartTimeSelection(%d)", e)
+	}
+}
+
 // BaseParseFrameFlags wraps GstBaseParseFrameFlags
 //
 // Flags to be used in a #GstBaseParseFrame.
@@ -141,6 +152,33 @@ func (b BaseParseFrameFlags) Has(other BaseParseFrameFlags) bool {
 	return (b & other) == other
 }
 
+func (f BaseParseFrameFlags) String() string {
+	if f == 0 {
+		return "BaseParseFrameFlags(0)"
+	}
+
+	var parts []string
+	if (f & BaseParseFrameFlagNone) != 0 {
+		parts = append(parts, "BaseParseFrameFlagNone")
+	}
+	if (f & BaseParseFrameFlagNewFrame) != 0 {
+		parts = append(parts, "BaseParseFrameFlagNewFrame")
+	}
+	if (f & BaseParseFrameFlagNoFrame) != 0 {
+		parts = append(parts, "BaseParseFrameFlagNoFrame")
+	}
+	if (f & BaseParseFrameFlagClip) != 0 {
+		parts = append(parts, "BaseParseFrameFlagClip")
+	}
+	if (f & BaseParseFrameFlagDrop) != 0 {
+		parts = append(parts, "BaseParseFrameFlagDrop")
+	}
+	if (f & BaseParseFrameFlagQueue) != 0 {
+		parts = append(parts, "BaseParseFrameFlagQueue")
+	}
+	return "BaseParseFrameFlags(" + strings.Join(parts, "|") + ")"
+}
+
 // BaseSrcFlags wraps GstBaseSrcFlags
 //
 // The #GstElement flags that a basesrc element may have.
@@ -166,6 +204,24 @@ func (b BaseSrcFlags) Has(other BaseSrcFlags) bool {
 	return (b & other) == other
 }
 
+func (f BaseSrcFlags) String() string {
+	if f == 0 {
+		return "BaseSrcFlags(0)"
+	}
+
+	var parts []string
+	if (f & BaseSrcFlagStarting) != 0 {
+		parts = append(parts, "BaseSrcFlagStarting")
+	}
+	if (f & BaseSrcFlagStarted) != 0 {
+		parts = append(parts, "BaseSrcFlagStarted")
+	}
+	if (f & BaseSrcFlagLast) != 0 {
+		parts = append(parts, "BaseSrcFlagLast")
+	}
+	return "BaseSrcFlags(" + strings.Join(parts, "|") + ")"
+}
+
 // CollectPadsStateFlags wraps GstCollectPadsStateFlags
 type CollectPadsStateFlags C.gint
 
@@ -201,6 +257,30 @@ func (c CollectPadsStateFlags) Has(other CollectPadsStateFlags) bool {
 	return (c & other) == other
 }
 
+func (f CollectPadsStateFlags) String() string {
+	if f == 0 {
+		return "CollectPadsStateFlags(0)"
+	}
+
+	var parts []string
+	if (f & CollectPadsStateEos) != 0 {
+		parts = append(parts, "CollectPadsStateEos")
+	}
+	if (f & CollectPadsStateFlushing) != 0 {
+		parts = append(parts, "CollectPadsStateFlushing")
+	}
+	if (f & CollectPadsStateNewSegment) != 0 {
+		parts = append(parts, "CollectPadsStateNewSegment")
+	}
+	if (f & CollectPadsStateWaiting) != 0 {
+		parts = append(parts, "CollectPadsStateWaiting")
+	}
+	if (f & CollectPadsStateLocked) != 0 {
+		parts = append(parts, "CollectPadsStateLocked")
+	}
+	return "CollectPadsStateFlags(" + strings.Join(parts, "|") + ")"
+}
+
 // CollectPadsBufferFunction wraps GstCollectPadsBufferFunction
 //
 // A function that will be called when a (considered oldest) buffer can be muxed.
@@ -1184,13 +1264,13 @@ func UnsafeAdapterToGlibFull(c Adapter) unsafe.Pointer {
 	return gobject.UnsafeObjectToGlibFull(c)
 }
 
-// NewAdapterInstance wraps gst_adapter_new
+// NewAdapter wraps gst_adapter_new
 // The function returns the following values:
 // 
 // 	- goret Adapter 
 //
 // Creates a new #GstAdapter. Free with g_object_unref().
-func NewAdapterInstance() Adapter {
+func NewAdapter() Adapter {
 	var cret *C.GstAdapter // return, full, converted
 
 	cret = C.gst_adapter_new()
@@ -7536,7 +7616,7 @@ func UnsafeCollectPadsToGlibFull(c CollectPads) unsafe.Pointer {
 	return gobject.UnsafeObjectToGlibFull(c)
 }
 
-// NewCollectPadsInstance wraps gst_collect_pads_new
+// NewCollectPads wraps gst_collect_pads_new
 // The function returns the following values:
 // 
 // 	- goret CollectPads 
@@ -7544,7 +7624,7 @@ func UnsafeCollectPadsToGlibFull(c CollectPads) unsafe.Pointer {
 // Create a new instance of #GstCollectPads.
 // 
 // MT safe.
-func NewCollectPadsInstance() CollectPads {
+func NewCollectPads() CollectPads {
 	var cret *C.GstCollectPads // return, full, converted
 
 	cret = C.gst_collect_pads_new()
diff --git a/pkg/gstcheck/gstcheck.gen.go b/pkg/gstcheck/gstcheck.gen.go
index b990e48..5411715 100644
--- a/pkg/gstcheck/gstcheck.gen.go
+++ b/pkg/gstcheck/gstcheck.gen.go
@@ -1225,7 +1225,7 @@ func UnsafeTestClockToGlibFull(c TestClock) unsafe.Pointer {
 	return gobject.UnsafeObjectToGlibFull(c)
 }
 
-// NewTestClockInstance wraps gst_test_clock_new
+// NewTestClock wraps gst_test_clock_new
 // The function returns the following values:
 // 
 // 	- goret gst.Clock 
@@ -1233,7 +1233,7 @@ func UnsafeTestClockToGlibFull(c TestClock) unsafe.Pointer {
 // Creates a new test clock with its time set to zero.
 // 
 // MT safe.
-func NewTestClockInstance() gst.Clock {
+func NewTestClock() gst.Clock {
 	var cret *C.GstClock // return, full, converted
 
 	cret = C.gst_test_clock_new()
@@ -1245,7 +1245,7 @@ func NewTestClockInstance() gst.Clock {
 	return goret
 }
 
-// NewTestClockInstanceWithStartTime wraps gst_test_clock_new_with_start_time
+// NewTestClockWithStartTime wraps gst_test_clock_new_with_start_time
 // 
 // The function takes the following parameters:
 // 
@@ -1258,7 +1258,7 @@ func NewTestClockInstance() gst.Clock {
 // Creates a new test clock with its time set to the specified time.
 // 
 // MT safe.
-func NewTestClockInstanceWithStartTime(startTime gst.ClockTime) gst.Clock {
+func NewTestClockWithStartTime(startTime gst.ClockTime) gst.Clock {
 	var carg1 C.GstClockTime // in, none, casted, alias
 	var cret  *C.GstClock    // return, full, converted
 
diff --git a/pkg/gstcontroller/gstcontroller.gen.go b/pkg/gstcontroller/gstcontroller.gen.go
index fa5252b..432920b 100644
--- a/pkg/gstcontroller/gstcontroller.gen.go
+++ b/pkg/gstcontroller/gstcontroller.gen.go
@@ -3,6 +3,7 @@
 package gstcontroller
 
 import (
+	"fmt"
 	"runtime"
 	"unsafe"
 
@@ -83,6 +84,16 @@ func (e InterpolationMode) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e InterpolationMode) String() string {
+	switch e {
+		case InterpolationModeNone: return "InterpolationModeNone"
+		case InterpolationModeLinear: return "InterpolationModeLinear"
+		case InterpolationModeCubic: return "InterpolationModeCubic"
+		case InterpolationModeCubicMonotonic: return "InterpolationModeCubicMonotonic"
+		default: return fmt.Sprintf("InterpolationMode(%d)", e)
+	}
+}
+
 // LFOWaveform wraps GstLFOWaveform
 //
 // The various waveform modes available.
@@ -122,6 +133,17 @@ func (e LFOWaveform) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e LFOWaveform) String() string {
+	switch e {
+		case LfoWaveformReverseSaw: return "LfoWaveformReverseSaw"
+		case LfoWaveformTriangle: return "LfoWaveformTriangle"
+		case LfoWaveformSine: return "LfoWaveformSine"
+		case LfoWaveformSquare: return "LfoWaveformSquare"
+		case LfoWaveformSaw: return "LfoWaveformSaw"
+		default: return fmt.Sprintf("LFOWaveform(%d)", e)
+	}
+}
+
 // TimedValueControlInvalidateCache wraps gst_timed_value_control_invalidate_cache
 // 
 // The function takes the following parameters:
@@ -196,7 +218,7 @@ func UnsafeARGBControlBindingToGlibFull(c ARGBControlBinding) unsafe.Pointer {
 	return gobject.UnsafeObjectToGlibFull(c)
 }
 
-// NewARGBControlBindingInstance wraps gst_argb_control_binding_new
+// NewARGBControlBinding wraps gst_argb_control_binding_new
 // 
 // The function takes the following parameters:
 // 
@@ -213,7 +235,7 @@ func UnsafeARGBControlBindingToGlibFull(c ARGBControlBinding) unsafe.Pointer {
 //
 // Create a new control-binding that attaches the given #GstControlSource to the
 // #GObject property.
-func NewARGBControlBindingInstance(object gst.Object, propertyName string, csA gst.ControlSource, csR gst.ControlSource, csG gst.ControlSource, csB gst.ControlSource) gst.ControlBinding {
+func NewARGBControlBinding(object gst.Object, propertyName string, csA gst.ControlSource, csR gst.ControlSource, csG gst.ControlSource, csB gst.ControlSource) gst.ControlBinding {
 	var carg1 *C.GstObject         // in, none, converted
 	var carg2 *C.gchar             // in, none, string, casted *C.gchar
 	var carg3 *C.GstControlSource  // in, none, converted
@@ -306,7 +328,7 @@ func UnsafeDirectControlBindingToGlibFull(c DirectControlBinding) unsafe.Pointer
 	return gobject.UnsafeObjectToGlibFull(c)
 }
 
-// NewDirectControlBindingInstance wraps gst_direct_control_binding_new
+// NewDirectControlBinding wraps gst_direct_control_binding_new
 // 
 // The function takes the following parameters:
 // 
@@ -321,7 +343,7 @@ func UnsafeDirectControlBindingToGlibFull(c DirectControlBinding) unsafe.Pointer
 // Create a new control-binding that attaches the #GstControlSource to the
 // #GObject property. It will map the control source range [0.0 ... 1.0] to
 // the full target property range, and clip all values outside this range.
-func NewDirectControlBindingInstance(object gst.Object, propertyName string, cs gst.ControlSource) gst.ControlBinding {
+func NewDirectControlBinding(object gst.Object, propertyName string, cs gst.ControlSource) gst.ControlBinding {
 	var carg1 *C.GstObject         // in, none, converted
 	var carg2 *C.gchar             // in, none, string, casted *C.gchar
 	var carg3 *C.GstControlSource  // in, none, converted
@@ -344,7 +366,7 @@ func NewDirectControlBindingInstance(object gst.Object, propertyName string, cs
 	return goret
 }
 
-// NewDirectControlBindingInstanceAbsolute wraps gst_direct_control_binding_new_absolute
+// NewDirectControlBindingAbsolute wraps gst_direct_control_binding_new_absolute
 // 
 // The function takes the following parameters:
 // 
@@ -359,7 +381,7 @@ func NewDirectControlBindingInstance(object gst.Object, propertyName string, cs
 // Create a new control-binding that attaches the #GstControlSource to the
 // #GObject property. It will directly map the control source values to the
 // target property range without any transformations.
-func NewDirectControlBindingInstanceAbsolute(object gst.Object, propertyName string, cs gst.ControlSource) gst.ControlBinding {
+func NewDirectControlBindingAbsolute(object gst.Object, propertyName string, cs gst.ControlSource) gst.ControlBinding {
 	var carg1 *C.GstObject         // in, none, converted
 	var carg2 *C.gchar             // in, none, string, casted *C.gchar
 	var carg3 *C.GstControlSource  // in, none, converted
@@ -445,13 +467,13 @@ func UnsafeLFOControlSourceToGlibFull(c LFOControlSource) unsafe.Pointer {
 	return gobject.UnsafeObjectToGlibFull(c)
 }
 
-// NewLFOControlSourceInstance wraps gst_lfo_control_source_new
+// NewLFOControlSource wraps gst_lfo_control_source_new
 // The function returns the following values:
 // 
 // 	- goret gst.ControlSource 
 //
 // This returns a new, unbound #GstLFOControlSource.
-func NewLFOControlSourceInstance() gst.ControlSource {
+func NewLFOControlSource() gst.ControlSource {
 	var cret *C.GstControlSource // return, full, converted
 
 	cret = C.gst_lfo_control_source_new()
@@ -519,7 +541,7 @@ func UnsafeProxyControlBindingToGlibFull(c ProxyControlBinding) unsafe.Pointer {
 	return gobject.UnsafeObjectToGlibFull(c)
 }
 
-// NewProxyControlBindingInstance wraps gst_proxy_control_binding_new
+// NewProxyControlBinding wraps gst_proxy_control_binding_new
 // 
 // The function takes the following parameters:
 // 
@@ -536,7 +558,7 @@ func UnsafeProxyControlBindingToGlibFull(c ProxyControlBinding) unsafe.Pointer {
 // #GstProxyControlBinding forwards all access to data or `sync_values()`
 // requests from @property_name on @object to the control binding at
 // @ref_property_name on @ref_object.
-func NewProxyControlBindingInstance(object gst.Object, propertyName string, refObject gst.Object, refPropertyName string) gst.ControlBinding {
+func NewProxyControlBinding(object gst.Object, propertyName string, refObject gst.Object, refPropertyName string) gst.ControlBinding {
 	var carg1 *C.GstObject         // in, none, converted
 	var carg2 *C.gchar             // in, none, string, casted *C.gchar
 	var carg3 *C.GstObject         // in, none, converted
@@ -880,13 +902,13 @@ func UnsafeTriggerControlSourceToGlibFull(c TriggerControlSource) unsafe.Pointer
 	return gobject.UnsafeObjectToGlibFull(c)
 }
 
-// NewTriggerControlSourceInstance wraps gst_trigger_control_source_new
+// NewTriggerControlSource wraps gst_trigger_control_source_new
 // The function returns the following values:
 // 
 // 	- goret gst.ControlSource 
 //
 // This returns a new, unbound #GstTriggerControlSource.
-func NewTriggerControlSourceInstance() gst.ControlSource {
+func NewTriggerControlSource() gst.ControlSource {
 	var cret *C.GstControlSource // return, full, converted
 
 	cret = C.gst_trigger_control_source_new()
@@ -963,13 +985,13 @@ func UnsafeInterpolationControlSourceToGlibFull(c InterpolationControlSource) un
 	return gobject.UnsafeObjectToGlibFull(c)
 }
 
-// NewInterpolationControlSourceInstance wraps gst_interpolation_control_source_new
+// NewInterpolationControlSource wraps gst_interpolation_control_source_new
 // The function returns the following values:
 // 
 // 	- goret gst.ControlSource 
 //
 // This returns a new, unbound #GstInterpolationControlSource.
-func NewInterpolationControlSourceInstance() gst.ControlSource {
+func NewInterpolationControlSource() gst.ControlSource {
 	var cret *C.GstControlSource // return, full, converted
 
 	cret = C.gst_interpolation_control_source_new()
diff --git a/pkg/gstgl/gstgl.gen.go b/pkg/gstgl/gstgl.gen.go
index 2e511f2..a21e0d3 100644
--- a/pkg/gstgl/gstgl.gen.go
+++ b/pkg/gstgl/gstgl.gen.go
@@ -3,7 +3,9 @@
 package gstgl
 
 import (
+	"fmt"
 	"runtime"
+	"strings"
 	"unsafe"
 
 	"github.com/diamondburned/gotk4/pkg/core/userdata"
@@ -191,6 +193,15 @@ func (e GLBaseMemoryError) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e GLBaseMemoryError) String() string {
+	switch e {
+		case GLBaseMemoryErrorFailed: return "GLBaseMemoryErrorFailed"
+		case GLBaseMemoryErrorOldLibs: return "GLBaseMemoryErrorOldLibs"
+		case GLBaseMemoryErrorResourceUnavailable: return "GLBaseMemoryErrorResourceUnavailable"
+		default: return fmt.Sprintf("GLBaseMemoryError(%d)", e)
+	}
+}
+
 // GLConfigCaveat wraps GstGLConfigCaveat
 type GLConfigCaveat C.int
 
@@ -220,6 +231,15 @@ func (e GLConfigCaveat) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e GLConfigCaveat) String() string {
+	switch e {
+		case GLConfigCaveatNone: return "GLConfigCaveatNone"
+		case GLConfigCaveatSlow: return "GLConfigCaveatSlow"
+		case GLConfigCaveatNonConformant: return "GLConfigCaveatNonConformant"
+		default: return fmt.Sprintf("GLConfigCaveat(%d)", e)
+	}
+}
+
 // GLContextError wraps GstGLContextError
 //
 // OpenGL context errors.
@@ -263,6 +283,18 @@ func (e GLContextError) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e GLContextError) String() string {
+	switch e {
+		case GLContextErrorCreateContext: return "GLContextErrorCreateContext"
+		case GLContextErrorResourceUnavailable: return "GLContextErrorResourceUnavailable"
+		case GLContextErrorFailed: return "GLContextErrorFailed"
+		case GLContextErrorWrongConfig: return "GLContextErrorWrongConfig"
+		case GLContextErrorWrongApi: return "GLContextErrorWrongApi"
+		case GLContextErrorOldLibs: return "GLContextErrorOldLibs"
+		default: return fmt.Sprintf("GLContextError(%d)", e)
+	}
+}
+
 // GLFormat wraps GstGLFormat
 type GLFormat C.int
 
@@ -362,6 +394,31 @@ func (e GLFormat) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e GLFormat) String() string {
+	switch e {
+		case GLAlpha: return "GLAlpha"
+		case GLRed: return "GLRed"
+		case GLRGB: return "GLRGB"
+		case GLRGBA: return "GLRGBA"
+		case GLDepth24Stencil8: return "GLDepth24Stencil8"
+		case GLLuminance: return "GLLuminance"
+		case GLLuminanceAlpha: return "GLLuminanceAlpha"
+		case GLRg: return "GLRg"
+		case GLRGB8: return "GLRGB8"
+		case GLRGBA8: return "GLRGBA8"
+		case GLRGB10A2: return "GLRGB10A2"
+		case GLR8: return "GLR8"
+		case GLRg8: return "GLRg8"
+		case GLRGB565: return "GLRGB565"
+		case GLDepthComponent16: return "GLDepthComponent16"
+		case GLR16: return "GLR16"
+		case GLRg16: return "GLRg16"
+		case GLRGB16: return "GLRGB16"
+		case GLRGBA16: return "GLRGBA16"
+		default: return fmt.Sprintf("GLFormat(%d)", e)
+	}
+}
+
 // GLQueryType wraps GstGLQueryType
 type GLQueryType C.int
 
@@ -391,6 +448,15 @@ func (e GLQueryType) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e GLQueryType) String() string {
+	switch e {
+		case GLQueryNone: return "GLQueryNone"
+		case GLQueryTimeElapsed: return "GLQueryTimeElapsed"
+		case GLQueryTimestamp: return "GLQueryTimestamp"
+		default: return fmt.Sprintf("GLQueryType(%d)", e)
+	}
+}
+
 // GLSLError wraps GstGLSLError
 //
 // Compilation stage that caused an error
@@ -422,6 +488,15 @@ func (e GLSLError) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e GLSLError) String() string {
+	switch e {
+		case GlslErrorCompile: return "GlslErrorCompile"
+		case GlslErrorLink: return "GlslErrorLink"
+		case GlslErrorProgram: return "GlslErrorProgram"
+		default: return fmt.Sprintf("GLSLError(%d)", e)
+	}
+}
+
 // GLSLVersion wraps GstGLSLVersion
 //
 // GLSL version list
@@ -509,6 +584,29 @@ func (e GLSLVersion) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e GLSLVersion) String() string {
+	switch e {
+		case GlslVersion440: return "GlslVersion440"
+		case GlslVersion110: return "GlslVersion110"
+		case GlslVersionNone: return "GlslVersionNone"
+		case GlslVersion130: return "GlslVersion130"
+		case GlslVersion410: return "GlslVersion410"
+		case GlslVersion140: return "GlslVersion140"
+		case GlslVersion150: return "GlslVersion150"
+		case GlslVersion310: return "GlslVersion310"
+		case GlslVersion320: return "GlslVersion320"
+		case GlslVersion330: return "GlslVersion330"
+		case GlslVersion400: return "GlslVersion400"
+		case GlslVersion430: return "GlslVersion430"
+		case GlslVersion450: return "GlslVersion450"
+		case GlslVersion100: return "GlslVersion100"
+		case GlslVersion120: return "GlslVersion120"
+		case GlslVersion300: return "GlslVersion300"
+		case GlslVersion420: return "GlslVersion420"
+		default: return fmt.Sprintf("GLSLVersion(%d)", e)
+	}
+}
+
 // GLStereoDownmix wraps GstGLStereoDownmix
 //
 // Output anaglyph type to generate when downmixing to mono
@@ -540,6 +638,15 @@ func (e GLStereoDownmix) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e GLStereoDownmix) String() string {
+	switch e {
+		case GLStereoDownmixAnaglyphGreenMagentaDubois: return "GLStereoDownmixAnaglyphGreenMagentaDubois"
+		case GLStereoDownmixAnaglyphRedCyanDubois: return "GLStereoDownmixAnaglyphRedCyanDubois"
+		case GLStereoDownmixAnaglyphAmberBlueDubois: return "GLStereoDownmixAnaglyphAmberBlueDubois"
+		default: return fmt.Sprintf("GLStereoDownmix(%d)", e)
+	}
+}
+
 // GLTextureTarget wraps GstGLTextureTarget
 //
 // The OpenGL texture target that an OpenGL texture can be bound to.  The
@@ -581,6 +688,16 @@ func (e GLTextureTarget) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e GLTextureTarget) String() string {
+	switch e {
+		case GLTextureTargetNone: return "GLTextureTargetNone"
+		case GLTextureTarget2D: return "GLTextureTarget2D"
+		case GLTextureTargetRectangle: return "GLTextureTargetRectangle"
+		case GLTextureTargetExternalOes: return "GLTextureTargetExternalOes"
+		default: return fmt.Sprintf("GLTextureTarget(%d)", e)
+	}
+}
+
 // GLUploadReturn wraps GstGLUploadReturn
 type GLUploadReturn C.int
 
@@ -618,6 +735,17 @@ func (e GLUploadReturn) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e GLUploadReturn) String() string {
+	switch e {
+		case GLUploadReconfigure: return "GLUploadReconfigure"
+		case GLUploadUnsharedGLContext: return "GLUploadUnsharedGLContext"
+		case GLUploadDone: return "GLUploadDone"
+		case GLUploadError: return "GLUploadError"
+		case GLUploadUnsupported: return "GLUploadUnsupported"
+		default: return fmt.Sprintf("GLUploadReturn(%d)", e)
+	}
+}
+
 // GLWindowError wraps GstGLWindowError
 type GLWindowError C.int
 
@@ -647,6 +775,15 @@ func (e GLWindowError) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e GLWindowError) String() string {
+	switch e {
+		case GLWindowErrorFailed: return "GLWindowErrorFailed"
+		case GLWindowErrorOldLibs: return "GLWindowErrorOldLibs"
+		case GLWindowErrorResourceUnavailable: return "GLWindowErrorResourceUnavailable"
+		default: return fmt.Sprintf("GLWindowError(%d)", e)
+	}
+}
+
 // GLAPI wraps GstGLAPI
 type GLAPI C.gint
 
@@ -693,6 +830,33 @@ func (f GLAPI) InitGoValue(v *gobject.Value) {
 	v.SetFlags(int(f))
 }
 
+func (f GLAPI) String() string {
+	if f == 0 {
+		return "GLAPI(0)"
+	}
+
+	var parts []string
+	if (f & GLApiNone) != 0 {
+		parts = append(parts, "GLApiNone")
+	}
+	if (f & GLApiOpengl) != 0 {
+		parts = append(parts, "GLApiOpengl")
+	}
+	if (f & GLApiOpengl3) != 0 {
+		parts = append(parts, "GLApiOpengl3")
+	}
+	if (f & GLApiGles1) != 0 {
+		parts = append(parts, "GLApiGles1")
+	}
+	if (f & GLApiGles2) != 0 {
+		parts = append(parts, "GLApiGles2")
+	}
+	if (f & GLApiAny) != 0 {
+		parts = append(parts, "GLApiAny")
+	}
+	return "GLAPI(" + strings.Join(parts, "|") + ")"
+}
+
 // GLBaseMemoryTransfer wraps GstGLBaseMemoryTransfer
 type GLBaseMemoryTransfer C.gint
 
@@ -724,6 +888,21 @@ func (f GLBaseMemoryTransfer) InitGoValue(v *gobject.Value) {
 	v.SetFlags(int(f))
 }
 
+func (f GLBaseMemoryTransfer) String() string {
+	if f == 0 {
+		return "GLBaseMemoryTransfer(0)"
+	}
+
+	var parts []string
+	if (f & GLBaseMemoryTransferNeedDownload) != 0 {
+		parts = append(parts, "GLBaseMemoryTransferNeedDownload")
+	}
+	if (f & GLBaseMemoryTransferNeedUpload) != 0 {
+		parts = append(parts, "GLBaseMemoryTransferNeedUpload")
+	}
+	return "GLBaseMemoryTransfer(" + strings.Join(parts, "|") + ")"
+}
+
 // GLConfigSurfaceType wraps GstGLConfigSurfaceType
 type GLConfigSurfaceType C.gint
 
@@ -761,6 +940,27 @@ func (f GLConfigSurfaceType) InitGoValue(v *gobject.Value) {
 	v.SetFlags(int(f))
 }
 
+func (f GLConfigSurfaceType) String() string {
+	if f == 0 {
+		return "GLConfigSurfaceType(0)"
+	}
+
+	var parts []string
+	if (f & GLConfigSurfaceTypeNone) != 0 {
+		parts = append(parts, "GLConfigSurfaceTypeNone")
+	}
+	if (f & GLConfigSurfaceTypeWindow) != 0 {
+		parts = append(parts, "GLConfigSurfaceTypeWindow")
+	}
+	if (f & GLConfigSurfaceTypePbuffer) != 0 {
+		parts = append(parts, "GLConfigSurfaceTypePbuffer")
+	}
+	if (f & GLConfigSurfaceTypePixmap) != 0 {
+		parts = append(parts, "GLConfigSurfaceTypePixmap")
+	}
+	return "GLConfigSurfaceType(" + strings.Join(parts, "|") + ")"
+}
+
 // GLDisplayType wraps GstGLDisplayType
 type GLDisplayType C.gint
 
@@ -843,6 +1043,60 @@ func (f GLDisplayType) InitGoValue(v *gobject.Value) {
 	v.SetFlags(int(f))
 }
 
+func (f GLDisplayType) String() string {
+	if f == 0 {
+		return "GLDisplayType(0)"
+	}
+
+	var parts []string
+	if (f & GLDisplayTypeNone) != 0 {
+		parts = append(parts, "GLDisplayTypeNone")
+	}
+	if (f & GLDisplayTypeX11) != 0 {
+		parts = append(parts, "GLDisplayTypeX11")
+	}
+	if (f & GLDisplayTypeWayland) != 0 {
+		parts = append(parts, "GLDisplayTypeWayland")
+	}
+	if (f & GLDisplayTypeCocoa) != 0 {
+		parts = append(parts, "GLDisplayTypeCocoa")
+	}
+	if (f & GLDisplayTypeWin32) != 0 {
+		parts = append(parts, "GLDisplayTypeWin32")
+	}
+	if (f & GLDisplayTypeDispmanx) != 0 {
+		parts = append(parts, "GLDisplayTypeDispmanx")
+	}
+	if (f & GLDisplayTypeEgl) != 0 {
+		parts = append(parts, "GLDisplayTypeEgl")
+	}
+	if (f & GLDisplayTypeVivFb) != 0 {
+		parts = append(parts, "GLDisplayTypeVivFb")
+	}
+	if (f & GLDisplayTypeGbm) != 0 {
+		parts = append(parts, "GLDisplayTypeGbm")
+	}
+	if (f & GLDisplayTypeEglDevice) != 0 {
+		parts = append(parts, "GLDisplayTypeEglDevice")
+	}
+	if (f & GLDisplayTypeEagl) != 0 {
+		parts = append(parts, "GLDisplayTypeEagl")
+	}
+	if (f & GLDisplayTypeWinrt) != 0 {
+		parts = append(parts, "GLDisplayTypeWinrt")
+	}
+	if (f & GLDisplayTypeAndroid) != 0 {
+		parts = append(parts, "GLDisplayTypeAndroid")
+	}
+	if (f & GLDisplayTypeEglSurfaceless) != 0 {
+		parts = append(parts, "GLDisplayTypeEglSurfaceless")
+	}
+	if (f & GLDisplayTypeAny) != 0 {
+		parts = append(parts, "GLDisplayTypeAny")
+	}
+	return "GLDisplayType(" + strings.Join(parts, "|") + ")"
+}
+
 // GLPlatform wraps GstGLPlatform
 type GLPlatform C.gint
 
@@ -893,6 +1147,36 @@ func (f GLPlatform) InitGoValue(v *gobject.Value) {
 	v.SetFlags(int(f))
 }
 
+func (f GLPlatform) String() string {
+	if f == 0 {
+		return "GLPlatform(0)"
+	}
+
+	var parts []string
+	if (f & GLPlatformNone) != 0 {
+		parts = append(parts, "GLPlatformNone")
+	}
+	if (f & GLPlatformEgl) != 0 {
+		parts = append(parts, "GLPlatformEgl")
+	}
+	if (f & GLPlatformGLX) != 0 {
+		parts = append(parts, "GLPlatformGLX")
+	}
+	if (f & GLPlatformWgl) != 0 {
+		parts = append(parts, "GLPlatformWgl")
+	}
+	if (f & GLPlatformCgl) != 0 {
+		parts = append(parts, "GLPlatformCgl")
+	}
+	if (f & GLPlatformEagl) != 0 {
+		parts = append(parts, "GLPlatformEagl")
+	}
+	if (f & GLPlatformAny) != 0 {
+		parts = append(parts, "GLPlatformAny")
+	}
+	return "GLPlatform(" + strings.Join(parts, "|") + ")"
+}
+
 // GLSLProfile wraps GstGLSLProfile
 //
 // GLSL profiles
@@ -936,6 +1220,30 @@ func (f GLSLProfile) InitGoValue(v *gobject.Value) {
 	v.SetFlags(int(f))
 }
 
+func (f GLSLProfile) String() string {
+	if f == 0 {
+		return "GLSLProfile(0)"
+	}
+
+	var parts []string
+	if (f & GlslProfileNone) != 0 {
+		parts = append(parts, "GlslProfileNone")
+	}
+	if (f & GlslProfileES) != 0 {
+		parts = append(parts, "GlslProfileES")
+	}
+	if (f & GlslProfileCore) != 0 {
+		parts = append(parts, "GlslProfileCore")
+	}
+	if (f & GlslProfileCompatibility) != 0 {
+		parts = append(parts, "GlslProfileCompatibility")
+	}
+	if (f & GlslProfileAny) != 0 {
+		parts = append(parts, "GlslProfileAny")
+	}
+	return "GLSLProfile(" + strings.Join(parts, "|") + ")"
+}
+
 // GLAsyncDebugLogGetMessage wraps GstGLAsyncDebugLogGetMessage
 type GLAsyncDebugLogGetMessage func() (goret string)
 
@@ -2276,7 +2584,7 @@ func UnsafeGLBufferPoolToGlibFull(c GLBufferPool) unsafe.Pointer {
 	return gobject.UnsafeObjectToGlibFull(c)
 }
 
-// NewGLBufferPoolInstance wraps gst_gl_buffer_pool_new
+// NewGLBufferPool wraps gst_gl_buffer_pool_new
 // 
 // The function takes the following parameters:
 // 
@@ -2285,7 +2593,7 @@ func UnsafeGLBufferPoolToGlibFull(c GLBufferPool) unsafe.Pointer {
 // The function returns the following values:
 // 
 // 	- goret gst.BufferPool 
-func NewGLBufferPoolInstance(context GLContext) gst.BufferPool {
+func NewGLBufferPool(context GLContext) gst.BufferPool {
 	var carg1 *C.GstGLContext  // in, none, converted
 	var cret  *C.GstBufferPool // return, none, converted
 
@@ -2427,7 +2735,7 @@ func UnsafeGLColorConvertToGlibFull(c GLColorConvert) unsafe.Pointer {
 	return gobject.UnsafeObjectToGlibFull(c)
 }
 
-// NewGLColorConvertInstance wraps gst_gl_color_convert_new
+// NewGLColorConvert wraps gst_gl_color_convert_new
 // 
 // The function takes the following parameters:
 // 
@@ -2436,7 +2744,7 @@ func UnsafeGLColorConvertToGlibFull(c GLColorConvert) unsafe.Pointer {
 // The function returns the following values:
 // 
 // 	- goret GLColorConvert 
-func NewGLColorConvertInstance(context GLContext) GLColorConvert {
+func NewGLColorConvert(context GLContext) GLColorConvert {
 	var carg1 *C.GstGLContext      // in, none, converted
 	var cret  *C.GstGLColorConvert // return, full, converted
 
@@ -2452,7 +2760,7 @@ func NewGLColorConvertInstance(context GLContext) GLColorConvert {
 	return goret
 }
 
-// GLColorConvertInstanceFixateCaps wraps gst_gl_color_convert_fixate_caps
+// GLColorConvertFixateCaps wraps gst_gl_color_convert_fixate_caps
 // 
 // The function takes the following parameters:
 // 
@@ -2466,7 +2774,7 @@ func NewGLColorConvertInstance(context GLContext) GLColorConvert {
 // 	- goret *gst.Caps 
 //
 // Provides an implementation of #GstBaseTransformClass.fixate_caps()
-func GLColorConvertInstanceFixateCaps(context GLContext, direction gst.PadDirection, caps *gst.Caps, other *gst.Caps) *gst.Caps {
+func GLColorConvertFixateCaps(context GLContext, direction gst.PadDirection, caps *gst.Caps, other *gst.Caps) *gst.Caps {
 	var carg1 *C.GstGLContext   // in, none, converted
 	var carg2 C.GstPadDirection // in, none, casted
 	var carg3 *C.GstCaps        // in, none, converted
@@ -2491,7 +2799,7 @@ func GLColorConvertInstanceFixateCaps(context GLContext, direction gst.PadDirect
 	return goret
 }
 
-// GLColorConvertInstanceSwizzleShaderString wraps gst_gl_color_convert_swizzle_shader_string
+// GLColorConvertSwizzleShaderString wraps gst_gl_color_convert_swizzle_shader_string
 // 
 // The function takes the following parameters:
 // 
@@ -2500,7 +2808,7 @@ func GLColorConvertInstanceFixateCaps(context GLContext, direction gst.PadDirect
 // The function returns the following values:
 // 
 // 	- goret string 
-func GLColorConvertInstanceSwizzleShaderString(context GLContext) string {
+func GLColorConvertSwizzleShaderString(context GLContext) string {
 	var carg1 *C.GstGLContext // in, none, converted
 	var cret  *C.gchar        // return, full, string, casted *C.gchar
 
@@ -2517,7 +2825,7 @@ func GLColorConvertInstanceSwizzleShaderString(context GLContext) string {
 	return goret
 }
 
-// GLColorConvertInstanceTransformCaps wraps gst_gl_color_convert_transform_caps
+// GLColorConvertTransformCaps wraps gst_gl_color_convert_transform_caps
 // 
 // The function takes the following parameters:
 // 
@@ -2531,7 +2839,7 @@ func GLColorConvertInstanceSwizzleShaderString(context GLContext) string {
 // 	- goret *gst.Caps 
 //
 // Provides an implementation of #GstBaseTransformClass.transform_caps()
-func GLColorConvertInstanceTransformCaps(context GLContext, direction gst.PadDirection, caps *gst.Caps, filter *gst.Caps) *gst.Caps {
+func GLColorConvertTransformCaps(context GLContext, direction gst.PadDirection, caps *gst.Caps, filter *gst.Caps) *gst.Caps {
 	var carg1 *C.GstGLContext   // in, none, converted
 	var carg2 C.GstPadDirection // in, none, casted
 	var carg3 *C.GstCaps        // in, none, converted
@@ -2556,7 +2864,7 @@ func GLColorConvertInstanceTransformCaps(context GLContext, direction gst.PadDir
 	return goret
 }
 
-// GLColorConvertInstanceYuvToRGBShaderString wraps gst_gl_color_convert_yuv_to_rgb_shader_string
+// GLColorConvertYuvToRGBShaderString wraps gst_gl_color_convert_yuv_to_rgb_shader_string
 // 
 // The function takes the following parameters:
 // 
@@ -2573,7 +2881,7 @@ func GLColorConvertInstanceTransformCaps(context GLContext, direction gst.PadDir
 // The Y component is placed in the 0th index of the returned value, The U component in the
 // 1st, and the V component in the 2nd.  offset, ycoeff, ucoeff, and vcoeff are the
 // specific coefficients and offset used for the conversion.
-func GLColorConvertInstanceYuvToRGBShaderString(context GLContext) string {
+func GLColorConvertYuvToRGBShaderString(context GLContext) string {
 	var carg1 *C.GstGLContext // in, none, converted
 	var cret  *C.gchar        // return, full, string, casted *C.gchar
 
@@ -3071,7 +3379,7 @@ func UnsafeGLContextToGlibFull(c GLContext) unsafe.Pointer {
 	return gobject.UnsafeObjectToGlibFull(c)
 }
 
-// NewGLContextInstance wraps gst_gl_context_new
+// NewGLContext wraps gst_gl_context_new
 // 
 // The function takes the following parameters:
 // 
@@ -3082,7 +3390,7 @@ func UnsafeGLContextToGlibFull(c GLContext) unsafe.Pointer {
 // 	- goret GLContext 
 //
 // Create a new #GstGLContext with the specified @display
-func NewGLContextInstance(display GLDisplay) GLContext {
+func NewGLContext(display GLDisplay) GLContext {
 	var carg1 *C.GstGLDisplay // in, none, converted
 	var cret  *C.GstGLContext // return, none, converted
 
@@ -3098,7 +3406,7 @@ func NewGLContextInstance(display GLDisplay) GLContext {
 	return goret
 }
 
-// NewGLContextInstanceWrapped wraps gst_gl_context_new_wrapped
+// NewGLContextWrapped wraps gst_gl_context_new_wrapped
 // 
 // The function takes the following parameters:
 // 
@@ -3120,7 +3428,7 @@ func NewGLContextInstance(display GLDisplay) GLContext {
 // @context_type must not be %GST_GL_PLATFORM_NONE or %GST_GL_PLATFORM_ANY
 // 
 // @available_apis must not be %GST_GL_API_NONE or %GST_GL_API_ANY
-func NewGLContextInstanceWrapped(display GLDisplay, handle uintptr, contextType GLPlatform, availableApis GLAPI) GLContext {
+func NewGLContextWrapped(display GLDisplay, handle uintptr, contextType GLPlatform, availableApis GLAPI) GLContext {
 	var carg1 *C.GstGLDisplay // in, none, converted
 	var carg2 C.guintptr      // in, none, casted
 	var carg3 C.GstGLPlatform // in, none, casted
@@ -3145,7 +3453,7 @@ func NewGLContextInstanceWrapped(display GLDisplay, handle uintptr, contextType
 	return goret
 }
 
-// GLContextInstanceDefaultGetProcAddress wraps gst_gl_context_default_get_proc_address
+// GLContextDefaultGetProcAddress wraps gst_gl_context_default_get_proc_address
 // 
 // The function takes the following parameters:
 // 
@@ -3160,7 +3468,7 @@ func NewGLContextInstanceWrapped(display GLDisplay, handle uintptr, contextType
 // for @name in the OpenGL shared libraries or in the current process.
 // 
 // See also: gst_gl_context_get_proc_address()
-func GLContextInstanceDefaultGetProcAddress(glApi GLAPI, name string) unsafe.Pointer {
+func GLContextDefaultGetProcAddress(glApi GLAPI, name string) unsafe.Pointer {
 	var carg1 C.GstGLAPI // in, none, casted
 	var carg2 *C.gchar   // in, none, string, casted *C.gchar
 	var cret  C.gpointer // return, none, casted
@@ -3180,13 +3488,13 @@ func GLContextInstanceDefaultGetProcAddress(glApi GLAPI, name string) unsafe.Poi
 	return goret
 }
 
-// GLContextInstanceGetCurrent wraps gst_gl_context_get_current
+// GLContextGetCurrent wraps gst_gl_context_get_current
 // The function returns the following values:
 // 
 // 	- goret GLContext 
 //
 // See also gst_gl_context_activate().
-func GLContextInstanceGetCurrent() GLContext {
+func GLContextGetCurrent() GLContext {
 	var cret *C.GstGLContext // return, none, converted
 
 	cret = C.gst_gl_context_get_current()
@@ -3198,7 +3506,7 @@ func GLContextInstanceGetCurrent() GLContext {
 	return goret
 }
 
-// GLContextInstanceGetCurrentGLApi wraps gst_gl_context_get_current_gl_api
+// GLContextGetCurrentGLApi wraps gst_gl_context_get_current_gl_api
 // 
 // The function takes the following parameters:
 // 
@@ -3212,7 +3520,7 @@ func GLContextInstanceGetCurrent() GLContext {
 //
 // If an error occurs, @major and @minor are not modified and %GST_GL_API_NONE is
 // returned.
-func GLContextInstanceGetCurrentGLApi(platform GLPlatform) (uint, uint, GLAPI) {
+func GLContextGetCurrentGLApi(platform GLPlatform) (uint, uint, GLAPI) {
 	var carg1 C.GstGLPlatform // in, none, casted
 	var carg2 C.guint         // out, full, casted
 	var carg3 C.guint         // out, full, casted
@@ -3234,7 +3542,7 @@ func GLContextInstanceGetCurrentGLApi(platform GLPlatform) (uint, uint, GLAPI) {
 	return major, minor, goret
 }
 
-// GLContextInstanceGetCurrentGLContext wraps gst_gl_context_get_current_gl_context
+// GLContextGetCurrentGLContext wraps gst_gl_context_get_current_gl_context
 // 
 // The function takes the following parameters:
 // 
@@ -3243,7 +3551,7 @@ func GLContextInstanceGetCurrentGLApi(platform GLPlatform) (uint, uint, GLAPI) {
 // The function returns the following values:
 // 
 // 	- goret uintptr 
-func GLContextInstanceGetCurrentGLContext(contextType GLPlatform) uintptr {
+func GLContextGetCurrentGLContext(contextType GLPlatform) uintptr {
 	var carg1 C.GstGLPlatform // in, none, casted
 	var cret  C.guintptr      // return, none, casted
 
@@ -3259,7 +3567,7 @@ func GLContextInstanceGetCurrentGLContext(contextType GLPlatform) uintptr {
 	return goret
 }
 
-// GLContextInstanceGetProcAddressWithPlatform wraps gst_gl_context_get_proc_address_with_platform
+// GLContextGetProcAddressWithPlatform wraps gst_gl_context_get_proc_address_with_platform
 // 
 // The function takes the following parameters:
 // 
@@ -3275,7 +3583,7 @@ func GLContextInstanceGetCurrentGLContext(contextType GLPlatform) uintptr {
 // to retrieve @name.
 // 
 // See also gst_gl_context_get_proc_address().
-func GLContextInstanceGetProcAddressWithPlatform(contextType GLPlatform, glApi GLAPI, name string) unsafe.Pointer {
+func GLContextGetProcAddressWithPlatform(contextType GLPlatform, glApi GLAPI, name string) unsafe.Pointer {
 	var carg1 C.GstGLPlatform // in, none, casted
 	var carg2 C.GstGLAPI      // in, none, casted
 	var carg3 *C.gchar        // in, none, string, casted *C.gchar
@@ -4235,11 +4543,11 @@ func UnsafeGLDisplayToGlibFull(c GLDisplay) unsafe.Pointer {
 	return gobject.UnsafeObjectToGlibFull(c)
 }
 
-// NewGLDisplayInstance wraps gst_gl_display_new
+// NewGLDisplay wraps gst_gl_display_new
 // The function returns the following values:
 // 
 // 	- goret GLDisplay 
-func NewGLDisplayInstance() GLDisplay {
+func NewGLDisplay() GLDisplay {
 	var cret *C.GstGLDisplay // return, full, converted
 
 	cret = C.gst_gl_display_new()
@@ -4251,7 +4559,7 @@ func NewGLDisplayInstance() GLDisplay {
 	return goret
 }
 
-// NewGLDisplayInstanceWithType wraps gst_gl_display_new_with_type
+// NewGLDisplayWithType wraps gst_gl_display_new_with_type
 // 
 // The function takes the following parameters:
 // 
@@ -4265,7 +4573,7 @@ func NewGLDisplayInstance() GLDisplay {
 // gst_gl_display_new() and the seemingly equivalent call
 // gst_gl_display_new_with_type (GST_GL_DISPLAY_TYPE_ANY) in that the latter
 // may return NULL.
-func NewGLDisplayInstanceWithType(typ GLDisplayType) GLDisplay {
+func NewGLDisplayWithType(typ GLDisplayType) GLDisplay {
 	var carg1 C.GstGLDisplayType // in, none, casted
 	var cret  *C.GstGLDisplay    // return, full, converted
 
@@ -4636,12 +4944,12 @@ func UnsafeGLFilterToGlibFull(c GLFilter) unsafe.Pointer {
 	return gobject.UnsafeObjectToGlibFull(c)
 }
 
-// GLFilterInstanceAddRGBAPadTemplates wraps gst_gl_filter_add_rgba_pad_templates
+// GLFilterAddRGBAPadTemplates wraps gst_gl_filter_add_rgba_pad_templates
 // 
 // The function takes the following parameters:
 // 
 // 	- klass *GLFilterClass 
-func GLFilterInstanceAddRGBAPadTemplates(klass *GLFilterClass) {
+func GLFilterAddRGBAPadTemplates(klass *GLFilterClass) {
 	var carg1 *C.GstGLFilterClass // in, none, converted
 
 	carg1 = (*C.GstGLFilterClass)(UnsafeGLFilterClassToGlibNone(klass))
@@ -4870,7 +5178,7 @@ func UnsafeGLFramebufferToGlibFull(c GLFramebuffer) unsafe.Pointer {
 	return gobject.UnsafeObjectToGlibFull(c)
 }
 
-// NewGLFramebufferInstance wraps gst_gl_framebuffer_new
+// NewGLFramebuffer wraps gst_gl_framebuffer_new
 // 
 // The function takes the following parameters:
 // 
@@ -4882,7 +5190,7 @@ func UnsafeGLFramebufferToGlibFull(c GLFramebuffer) unsafe.Pointer {
 //
 // This function will internally create an OpenGL framebuffer object and must
 // be called on @context's OpenGL thread.
-func NewGLFramebufferInstance(context GLContext) GLFramebuffer {
+func NewGLFramebuffer(context GLContext) GLFramebuffer {
 	var carg1 *C.GstGLContext     // in, none, converted
 	var cret  *C.GstGLFramebuffer // return, full, converted
 
@@ -4898,7 +5206,7 @@ func NewGLFramebufferInstance(context GLContext) GLFramebuffer {
 	return goret
 }
 
-// NewGLFramebufferInstanceWithDefaultDepth wraps gst_gl_framebuffer_new_with_default_depth
+// NewGLFramebufferWithDefaultDepth wraps gst_gl_framebuffer_new_with_default_depth
 // 
 // The function takes the following parameters:
 // 
@@ -4912,7 +5220,7 @@ func NewGLFramebufferInstance(context GLContext) GLFramebuffer {
 //
 // This function will internally create an OpenGL framebuffer object and must
 // be called on @context's OpenGL thread.
-func NewGLFramebufferInstanceWithDefaultDepth(context GLContext, width uint, height uint) GLFramebuffer {
+func NewGLFramebufferWithDefaultDepth(context GLContext, width uint, height uint) GLFramebuffer {
 	var carg1 *C.GstGLContext     // in, none, converted
 	var carg2 C.guint             // in, none, casted
 	var carg3 C.guint             // in, none, casted
@@ -5080,7 +5388,7 @@ func UnsafeGLMemoryAllocatorToGlibFull(c GLMemoryAllocator) unsafe.Pointer {
 	return gobject.UnsafeObjectToGlibFull(c)
 }
 
-// GLMemoryAllocatorInstanceGetDefault wraps gst_gl_memory_allocator_get_default
+// GLMemoryAllocatorGetDefault wraps gst_gl_memory_allocator_get_default
 // 
 // The function takes the following parameters:
 // 
@@ -5089,7 +5397,7 @@ func UnsafeGLMemoryAllocatorToGlibFull(c GLMemoryAllocator) unsafe.Pointer {
 // The function returns the following values:
 // 
 // 	- goret GLMemoryAllocator 
-func GLMemoryAllocatorInstanceGetDefault(context GLContext) GLMemoryAllocator {
+func GLMemoryAllocatorGetDefault(context GLContext) GLMemoryAllocator {
 	var carg1 *C.GstGLContext         // in, none, converted
 	var cret  *C.GstGLMemoryAllocator // return, full, converted
 
@@ -5426,7 +5734,7 @@ func UnsafeGLOverlayCompositorToGlibFull(c GLOverlayCompositor) unsafe.Pointer {
 	return gobject.UnsafeObjectToGlibFull(c)
 }
 
-// NewGLOverlayCompositorInstance wraps gst_gl_overlay_compositor_new
+// NewGLOverlayCompositor wraps gst_gl_overlay_compositor_new
 // 
 // The function takes the following parameters:
 // 
@@ -5435,7 +5743,7 @@ func UnsafeGLOverlayCompositorToGlibFull(c GLOverlayCompositor) unsafe.Pointer {
 // The function returns the following values:
 // 
 // 	- goret GLOverlayCompositor 
-func NewGLOverlayCompositorInstance(context GLContext) GLOverlayCompositor {
+func NewGLOverlayCompositor(context GLContext) GLOverlayCompositor {
 	var carg1 *C.GstGLContext           // in, none, converted
 	var cret  *C.GstGLOverlayCompositor // return, none, converted
 
@@ -5451,7 +5759,7 @@ func NewGLOverlayCompositorInstance(context GLContext) GLOverlayCompositor {
 	return goret
 }
 
-// GLOverlayCompositorInstanceAddCaps wraps gst_gl_overlay_compositor_add_caps
+// GLOverlayCompositorAddCaps wraps gst_gl_overlay_compositor_add_caps
 // 
 // The function takes the following parameters:
 // 
@@ -5460,7 +5768,7 @@ func NewGLOverlayCompositorInstance(context GLContext) GLOverlayCompositor {
 // The function returns the following values:
 // 
 // 	- goret *gst.Caps 
-func GLOverlayCompositorInstanceAddCaps(caps *gst.Caps) *gst.Caps {
+func GLOverlayCompositorAddCaps(caps *gst.Caps) *gst.Caps {
 	var carg1 *C.GstCaps // in, none, converted
 	var cret  *C.GstCaps // return, full, converted
 
@@ -5666,7 +5974,7 @@ func UnsafeGLSLStageToGlibFull(c GLSLStage) unsafe.Pointer {
 	return gobject.UnsafeObjectToGlibFull(c)
 }
 
-// NewGLSLStageInstance wraps gst_glsl_stage_new
+// NewGLSLStage wraps gst_glsl_stage_new
 // 
 // The function takes the following parameters:
 // 
@@ -5676,7 +5984,7 @@ func UnsafeGLSLStageToGlibFull(c GLSLStage) unsafe.Pointer {
 // The function returns the following values:
 // 
 // 	- goret GLSLStage 
-func NewGLSLStageInstance(context GLContext, typ uint) GLSLStage {
+func NewGLSLStage(context GLContext, typ uint) GLSLStage {
 	var carg1 *C.GstGLContext // in, none, converted
 	var carg2 C.guint         // in, none, casted
 	var cret  *C.GstGLSLStage // return, none, converted
@@ -5695,7 +6003,7 @@ func NewGLSLStageInstance(context GLContext, typ uint) GLSLStage {
 	return goret
 }
 
-// NewGLSLStageInstanceDefaultFragment wraps gst_glsl_stage_new_default_fragment
+// NewGLSLStageDefaultFragment wraps gst_glsl_stage_new_default_fragment
 // 
 // The function takes the following parameters:
 // 
@@ -5704,7 +6012,7 @@ func NewGLSLStageInstance(context GLContext, typ uint) GLSLStage {
 // The function returns the following values:
 // 
 // 	- goret GLSLStage 
-func NewGLSLStageInstanceDefaultFragment(context GLContext) GLSLStage {
+func NewGLSLStageDefaultFragment(context GLContext) GLSLStage {
 	var carg1 *C.GstGLContext // in, none, converted
 	var cret  *C.GstGLSLStage // return, none, converted
 
@@ -5720,7 +6028,7 @@ func NewGLSLStageInstanceDefaultFragment(context GLContext) GLSLStage {
 	return goret
 }
 
-// NewGLSLStageInstanceDefaultVertex wraps gst_glsl_stage_new_default_vertex
+// NewGLSLStageDefaultVertex wraps gst_glsl_stage_new_default_vertex
 // 
 // The function takes the following parameters:
 // 
@@ -5729,7 +6037,7 @@ func NewGLSLStageInstanceDefaultFragment(context GLContext) GLSLStage {
 // The function returns the following values:
 // 
 // 	- goret GLSLStage 
-func NewGLSLStageInstanceDefaultVertex(context GLContext) GLSLStage {
+func NewGLSLStageDefaultVertex(context GLContext) GLSLStage {
 	var carg1 *C.GstGLContext // in, none, converted
 	var cret  *C.GstGLSLStage // return, none, converted
 
@@ -5745,7 +6053,7 @@ func NewGLSLStageInstanceDefaultVertex(context GLContext) GLSLStage {
 	return goret
 }
 
-// NewGLSLStageInstanceWithString wraps gst_glsl_stage_new_with_string
+// NewGLSLStageWithString wraps gst_glsl_stage_new_with_string
 // 
 // The function takes the following parameters:
 // 
@@ -5758,7 +6066,7 @@ func NewGLSLStageInstanceDefaultVertex(context GLContext) GLSLStage {
 // The function returns the following values:
 // 
 // 	- goret GLSLStage 
-func NewGLSLStageInstanceWithString(context GLContext, typ uint, version GLSLVersion, profile GLSLProfile, str string) GLSLStage {
+func NewGLSLStageWithString(context GLContext, typ uint, version GLSLVersion, profile GLSLProfile, str string) GLSLStage {
 	var carg1 *C.GstGLContext  // in, none, converted
 	var carg2 C.guint          // in, none, casted
 	var carg3 C.GstGLSLVersion // in, none, casted
@@ -5787,7 +6095,7 @@ func NewGLSLStageInstanceWithString(context GLContext, typ uint, version GLSLVer
 	return goret
 }
 
-// NewGLSLStageInstanceWithStrings wraps gst_glsl_stage_new_with_strings
+// NewGLSLStageWithStrings wraps gst_glsl_stage_new_with_strings
 // 
 // The function takes the following parameters:
 // 
@@ -5801,7 +6109,7 @@ func NewGLSLStageInstanceWithString(context GLContext, typ uint, version GLSLVer
 // The function returns the following values:
 // 
 // 	- goret GLSLStage 
-func NewGLSLStageInstanceWithStrings(context GLContext, typ uint, version GLSLVersion, profile GLSLProfile, str []string) GLSLStage {
+func NewGLSLStageWithStrings(context GLContext, typ uint, version GLSLVersion, profile GLSLProfile, str []string) GLSLStage {
 	var carg1 *C.GstGLContext  // in, none, converted
 	var carg2 C.guint          // in, none, casted
 	var carg3 C.GstGLSLVersion // in, none, casted
@@ -6430,7 +6738,7 @@ func UnsafeGLShaderToGlibFull(c GLShader) unsafe.Pointer {
 	return gobject.UnsafeObjectToGlibFull(c)
 }
 
-// NewGLShaderInstance wraps gst_gl_shader_new
+// NewGLShader wraps gst_gl_shader_new
 // 
 // The function takes the following parameters:
 // 
@@ -6441,7 +6749,7 @@ func UnsafeGLShaderToGlibFull(c GLShader) unsafe.Pointer {
 // 	- goret GLShader 
 //
 // Note: must be called in the GL thread
-func NewGLShaderInstance(context GLContext) GLShader {
+func NewGLShader(context GLContext) GLShader {
 	var carg1 *C.GstGLContext // in, none, converted
 	var cret  *C.GstGLShader  // return, full, converted
 
@@ -6457,7 +6765,7 @@ func NewGLShaderInstance(context GLContext) GLShader {
 	return goret
 }
 
-// NewGLShaderInstanceDefault wraps gst_gl_shader_new_default
+// NewGLShaderDefault wraps gst_gl_shader_new_default
 // 
 // The function takes the following parameters:
 // 
@@ -6469,7 +6777,7 @@ func NewGLShaderInstance(context GLContext) GLShader {
 // 	- _goerr error (nullable): an error 
 //
 // Note: must be called in the GL thread
-func NewGLShaderInstanceDefault(context GLContext) (GLShader, error) {
+func NewGLShaderDefault(context GLContext) (GLShader, error) {
 	var carg1 *C.GstGLContext // in, none, converted
 	var cret  *C.GstGLShader  // return, full, converted
 	var _cerr *C.GError       // out, full, converted, nullable
@@ -6490,7 +6798,7 @@ func NewGLShaderInstanceDefault(context GLContext) (GLShader, error) {
 	return goret, _goerr
 }
 
-// GLShaderInstanceStringFragmentExternalOesGetDefault wraps gst_gl_shader_string_fragment_external_oes_get_default
+// GLShaderStringFragmentExternalOesGetDefault wraps gst_gl_shader_string_fragment_external_oes_get_default
 // 
 // The function takes the following parameters:
 // 
@@ -6501,7 +6809,7 @@ func NewGLShaderInstanceDefault(context GLContext) (GLShader, error) {
 // The function returns the following values:
 // 
 // 	- goret string 
-func GLShaderInstanceStringFragmentExternalOesGetDefault(context GLContext, version GLSLVersion, profile GLSLProfile) string {
+func GLShaderStringFragmentExternalOesGetDefault(context GLContext, version GLSLVersion, profile GLSLProfile) string {
 	var carg1 *C.GstGLContext  // in, none, converted
 	var carg2 C.GstGLSLVersion // in, none, casted
 	var carg3 C.GstGLSLProfile // in, none, casted
@@ -6524,7 +6832,7 @@ func GLShaderInstanceStringFragmentExternalOesGetDefault(context GLContext, vers
 	return goret
 }
 
-// GLShaderInstanceStringFragmentGetDefault wraps gst_gl_shader_string_fragment_get_default
+// GLShaderStringFragmentGetDefault wraps gst_gl_shader_string_fragment_get_default
 // 
 // The function takes the following parameters:
 // 
@@ -6535,7 +6843,7 @@ func GLShaderInstanceStringFragmentExternalOesGetDefault(context GLContext, vers
 // The function returns the following values:
 // 
 // 	- goret string 
-func GLShaderInstanceStringFragmentGetDefault(context GLContext, version GLSLVersion, profile GLSLProfile) string {
+func GLShaderStringFragmentGetDefault(context GLContext, version GLSLVersion, profile GLSLProfile) string {
 	var carg1 *C.GstGLContext  // in, none, converted
 	var carg2 C.GstGLSLVersion // in, none, casted
 	var carg3 C.GstGLSLProfile // in, none, casted
@@ -6558,7 +6866,7 @@ func GLShaderInstanceStringFragmentGetDefault(context GLContext, version GLSLVer
 	return goret
 }
 
-// GLShaderInstanceStringGetHighestPrecision wraps gst_gl_shader_string_get_highest_precision
+// GLShaderStringGetHighestPrecision wraps gst_gl_shader_string_get_highest_precision
 // 
 // The function takes the following parameters:
 // 
@@ -6577,7 +6885,7 @@ func GLShaderInstanceStringFragmentGetDefault(context GLContext, version GLSLVer
 // Practically, this will return the string 'precision mediump float'
 // or 'precision highp float' depending on if high precision floats are
 // determined to be supported.
-func GLShaderInstanceStringGetHighestPrecision(context GLContext, version GLSLVersion, profile GLSLProfile) string {
+func GLShaderStringGetHighestPrecision(context GLContext, version GLSLVersion, profile GLSLProfile) string {
 	var carg1 *C.GstGLContext  // in, none, converted
 	var carg2 C.GstGLSLVersion // in, none, casted
 	var carg3 C.GstGLSLProfile // in, none, casted
@@ -7870,7 +8178,7 @@ func UnsafeGLUploadToGlibFull(c GLUpload) unsafe.Pointer {
 	return gobject.UnsafeObjectToGlibFull(c)
 }
 
-// NewGLUploadInstance wraps gst_gl_upload_new
+// NewGLUpload wraps gst_gl_upload_new
 // 
 // The function takes the following parameters:
 // 
@@ -7879,7 +8187,7 @@ func UnsafeGLUploadToGlibFull(c GLUpload) unsafe.Pointer {
 // The function returns the following values:
 // 
 // 	- goret GLUpload 
-func NewGLUploadInstance(context GLContext) GLUpload {
+func NewGLUpload(context GLContext) GLUpload {
 	var carg1 *C.GstGLContext // in, none, converted
 	var cret  *C.GstGLUpload  // return, full, converted
 
@@ -7895,11 +8203,11 @@ func NewGLUploadInstance(context GLContext) GLUpload {
 	return goret
 }
 
-// GLUploadInstanceGetInputTemplateCaps wraps gst_gl_upload_get_input_template_caps
+// GLUploadGetInputTemplateCaps wraps gst_gl_upload_get_input_template_caps
 // The function returns the following values:
 // 
 // 	- goret *gst.Caps 
-func GLUploadInstanceGetInputTemplateCaps() *gst.Caps {
+func GLUploadGetInputTemplateCaps() *gst.Caps {
 	var cret *C.GstCaps // return, full, converted
 
 	cret = C.gst_gl_upload_get_input_template_caps()
@@ -8269,11 +8577,11 @@ func UnsafeGLViewConvertToGlibFull(c GLViewConvert) unsafe.Pointer {
 	return gobject.UnsafeObjectToGlibFull(c)
 }
 
-// NewGLViewConvertInstance wraps gst_gl_view_convert_new
+// NewGLViewConvert wraps gst_gl_view_convert_new
 // The function returns the following values:
 // 
 // 	- goret GLViewConvert 
-func NewGLViewConvertInstance() GLViewConvert {
+func NewGLViewConvert() GLViewConvert {
 	var cret *C.GstGLViewConvert // return, full, converted
 
 	cret = C.gst_gl_view_convert_new()
@@ -8717,7 +9025,7 @@ func UnsafeGLWindowToGlibFull(c GLWindow) unsafe.Pointer {
 	return gobject.UnsafeObjectToGlibFull(c)
 }
 
-// NewGLWindowInstance wraps gst_gl_window_new
+// NewGLWindow wraps gst_gl_window_new
 // 
 // The function takes the following parameters:
 // 
@@ -8726,7 +9034,7 @@ func UnsafeGLWindowToGlibFull(c GLWindow) unsafe.Pointer {
 // The function returns the following values:
 // 
 // 	- goret GLWindow 
-func NewGLWindowInstance(display GLDisplay) GLWindow {
+func NewGLWindow(display GLDisplay) GLWindow {
 	var carg1 *C.GstGLDisplay // in, none, converted
 	var cret  *C.GstGLWindow  // return, full, converted
 
diff --git a/pkg/gstmpegts/gstmpegts.gen.go b/pkg/gstmpegts/gstmpegts.gen.go
index c1a0086..2249484 100644
--- a/pkg/gstmpegts/gstmpegts.gen.go
+++ b/pkg/gstmpegts/gstmpegts.gen.go
@@ -3,8 +3,10 @@
 package gstmpegts
 
 import (
+	"fmt"
 	"log"
 	"runtime"
+	"strings"
 	"unsafe"
 
 	"github.com/diamondburned/gotk4/pkg/glib/v2"
@@ -197,6 +199,34 @@ const (
 )
 
 
+func (e ATSCDescriptorType) String() string {
+	switch e {
+		case MtsDescAtscDownloadDescriptor: return "MtsDescAtscDownloadDescriptor"
+		case MtsDescAtscModuleLink: return "MtsDescAtscModuleLink"
+		case MtsDescAtscCrc32: return "MtsDescAtscCrc32"
+		case MtsDescAtscAc3: return "MtsDescAtscAc3"
+		case MtsDescAtscGenre: return "MtsDescAtscGenre"
+		case MtsDescAtscStuffing: return "MtsDescAtscStuffing"
+		case MtsDescAtscExtendedChannelName: return "MtsDescAtscExtendedChannelName"
+		case MtsDescAtscServiceLocation: return "MtsDescAtscServiceLocation"
+		case MtsDescAtscTimeShiftedService: return "MtsDescAtscTimeShiftedService"
+		case MtsDescAtscCaptionService: return "MtsDescAtscCaptionService"
+		case MtsDescAtscContentAdvisory: return "MtsDescAtscContentAdvisory"
+		case MtsDescAtscComponentName: return "MtsDescAtscComponentName"
+		case MtsDescAtscDccDepartingRequest: return "MtsDescAtscDccDepartingRequest"
+		case MtsDescAtscPrivateInformation: return "MtsDescAtscPrivateInformation"
+		case MtsDescAtscDataService: return "MtsDescAtscDataService"
+		case MtsDescAtscMultiprotocolEncapsulation: return "MtsDescAtscMultiprotocolEncapsulation"
+		case MtsDescAtscGroupLink: return "MtsDescAtscGroupLink"
+		case MtsDescAtscDccArrivingRequest: return "MtsDescAtscDccArrivingRequest"
+		case MtsDescAtscRedistributionControl: return "MtsDescAtscRedistributionControl"
+		case MtsDescAtscEac3: return "MtsDescAtscEac3"
+		case MtsDescAtscEnhancedSignaling: return "MtsDescAtscEnhancedSignaling"
+		case MtsDescAtscPidCount: return "MtsDescAtscPidCount"
+		default: return fmt.Sprintf("ATSCDescriptorType(%d)", e)
+	}
+}
+
 // ATSCStreamType wraps GstMpegtsATSCStreamType
 //
 // Type of mpeg-ts streams for ATSC, as defined by the ATSC Code Points
@@ -236,6 +266,19 @@ const (
 )
 
 
+func (e ATSCStreamType) String() string {
+	switch e {
+		case MpegtsStreamTypeAtscIsochData: return "MpegtsStreamTypeAtscIsochData"
+		case MpegtsStreamTypeAtscSit: return "MpegtsStreamTypeAtscSit"
+		case MpegtsStreamTypeAtscAudioEac3: return "MpegtsStreamTypeAtscAudioEac3"
+		case MpegtsStreamTypeAtscAudioDtsHd: return "MpegtsStreamTypeAtscAudioDtsHd"
+		case MpegtsStreamTypeAtscDciiVideo: return "MpegtsStreamTypeAtscDciiVideo"
+		case MpegtsStreamTypeAtscAudioAc3: return "MpegtsStreamTypeAtscAudioAc3"
+		case MpegtsStreamTypeAtscSubtitling: return "MpegtsStreamTypeAtscSubtitling"
+		default: return fmt.Sprintf("ATSCStreamType(%d)", e)
+	}
+}
+
 // AtscMGTTableType wraps GstMpegtsAtscMGTTableType
 type AtscMGTTableType C.int
 
@@ -251,6 +294,16 @@ const (
 )
 
 
+func (e AtscMGTTableType) String() string {
+	switch e {
+		case MpegtsAtscMgtTableTypeEit0: return "MpegtsAtscMgtTableTypeEit0"
+		case MpegtsAtscMgtTableTypeEit127: return "MpegtsAtscMgtTableTypeEit127"
+		case MpegtsAtscMgtTableTypeEtt0: return "MpegtsAtscMgtTableTypeEtt0"
+		case MpegtsAtscMgtTableTypeEtt127: return "MpegtsAtscMgtTableTypeEtt127"
+		default: return fmt.Sprintf("AtscMGTTableType(%d)", e)
+	}
+}
+
 // CableOuterFECScheme wraps GstMpegtsCableOuterFECScheme
 type CableOuterFECScheme C.int
 
@@ -264,6 +317,15 @@ const (
 )
 
 
+func (e CableOuterFECScheme) String() string {
+	switch e {
+		case MpegtsCableOuterFecNone: return "MpegtsCableOuterFecNone"
+		case MpegtsCableOuterFecRs204188: return "MpegtsCableOuterFecRs204188"
+		case MpegtsCableOuterFecUndefined: return "MpegtsCableOuterFecUndefined"
+		default: return fmt.Sprintf("CableOuterFECScheme(%d)", e)
+	}
+}
+
 // ComponentStreamContent wraps GstMpegtsComponentStreamContent
 type ComponentStreamContent C.int
 
@@ -287,6 +349,20 @@ const (
 )
 
 
+func (e ComponentStreamContent) String() string {
+	switch e {
+		case MpegtsStreamContentSrmCpcm: return "MpegtsStreamContentSrmCpcm"
+		case MpegtsStreamContentMpeg2Video: return "MpegtsStreamContentMpeg2Video"
+		case MpegtsStreamContentMpeg1Layer2Audio: return "MpegtsStreamContentMpeg1Layer2Audio"
+		case MpegtsStreamContentTeletextOrSubtitle: return "MpegtsStreamContentTeletextOrSubtitle"
+		case MpegtsStreamContentAc3: return "MpegtsStreamContentAc3"
+		case MpegtsStreamContentAvc: return "MpegtsStreamContentAvc"
+		case MpegtsStreamContentAac: return "MpegtsStreamContentAac"
+		case MpegtsStreamContentDts: return "MpegtsStreamContentDts"
+		default: return fmt.Sprintf("ComponentStreamContent(%d)", e)
+	}
+}
+
 // ContentNibbleHi wraps GstMpegtsContentNibbleHi
 type ContentNibbleHi C.int
 
@@ -316,6 +392,23 @@ const (
 )
 
 
+func (e ContentNibbleHi) String() string {
+	switch e {
+		case MpegtsContentEducationScienceFactual: return "MpegtsContentEducationScienceFactual"
+		case MpegtsContentLeisureHobbies: return "MpegtsContentLeisureHobbies"
+		case MpegtsContentSpecialCharacteristics: return "MpegtsContentSpecialCharacteristics"
+		case MpegtsContentChildrenYouthProgram: return "MpegtsContentChildrenYouthProgram"
+		case MpegtsContentMusicBalletDance: return "MpegtsContentMusicBalletDance"
+		case MpegtsContentSocialPoliticalEconomics: return "MpegtsContentSocialPoliticalEconomics"
+		case MpegtsContentMovieDrama: return "MpegtsContentMovieDrama"
+		case MpegtsContentNewsCurrentAffairs: return "MpegtsContentNewsCurrentAffairs"
+		case MpegtsContentShowGameShow: return "MpegtsContentShowGameShow"
+		case MpegtsContentSports: return "MpegtsContentSports"
+		case MpegtsContentArtsCulture: return "MpegtsContentArtsCulture"
+		default: return fmt.Sprintf("ContentNibbleHi(%d)", e)
+	}
+}
+
 // DVBCodeRate wraps GstMpegtsDVBCodeRate
 type DVBCodeRate C.int
 
@@ -349,6 +442,25 @@ const (
 )
 
 
+func (e DVBCodeRate) String() string {
+	switch e {
+		case MpegtsFec56: return "MpegtsFec56"
+		case MpegtsFec67: return "MpegtsFec67"
+		case MpegtsFec910: return "MpegtsFec910"
+		case MpegtsFec25: return "MpegtsFec25"
+		case MpegtsFecNone: return "MpegtsFecNone"
+		case MpegtsFec23: return "MpegtsFec23"
+		case MpegtsFec45: return "MpegtsFec45"
+		case MpegtsFec78: return "MpegtsFec78"
+		case MpegtsFec89: return "MpegtsFec89"
+		case MpegtsFecAuto: return "MpegtsFecAuto"
+		case MpegtsFec35: return "MpegtsFec35"
+		case MpegtsFec12: return "MpegtsFec12"
+		case MpegtsFec34: return "MpegtsFec34"
+		default: return fmt.Sprintf("DVBCodeRate(%d)", e)
+	}
+}
+
 // DVBDescriptorType wraps GstMpegtsDVBDescriptorType
 //
 // The type of #GstMpegtsDescriptor
@@ -495,6 +607,76 @@ const (
 )
 
 
+func (e DVBDescriptorType) String() string {
+	switch e {
+		case MtsDescDvbVbiData: return "MtsDescDvbVbiData"
+		case MtsDescDvbTelephone: return "MtsDescDvbTelephone"
+		case MtsDescDvbAc3: return "MtsDescDvbAc3"
+		case MtsDescDvbRelatedContent: return "MtsDescDvbRelatedContent"
+		case MtsDescDvbTimeShiftedEvent: return "MtsDescDvbTimeShiftedEvent"
+		case MtsDescDvbSubtitling: return "MtsDescDvbSubtitling"
+		case MtsDescDvbDataBroadcast: return "MtsDescDvbDataBroadcast"
+		case MtsDescDvbScrambling: return "MtsDescDvbScrambling"
+		case MtsDescDvbS2SatelliteDeliverySystem: return "MtsDescDvbS2SatelliteDeliverySystem"
+		case MtsDescDvbNvodReference: return "MtsDescDvbNvodReference"
+		case MtsDescDvbParentalRating: return "MtsDescDvbParentalRating"
+		case MtsDescDvbTeletext: return "MtsDescDvbTeletext"
+		case MtsDescDvbMultilingualComponent: return "MtsDescDvbMultilingualComponent"
+		case MtsDescDvbApplicationSignalling: return "MtsDescDvbApplicationSignalling"
+		case MtsDescDvbMosaic: return "MtsDescDvbMosaic"
+		case MtsDescDvbLocalTimeOffset: return "MtsDescDvbLocalTimeOffset"
+		case MtsDescDvbTerrestrialDeliverySystem: return "MtsDescDvbTerrestrialDeliverySystem"
+		case MtsDescDvbServiceAvailability: return "MtsDescDvbServiceAvailability"
+		case MtsDescDvbPrivateDataSpecifier: return "MtsDescDvbPrivateDataSpecifier"
+		case MtsDescDvbShortSmoothingBuffer: return "MtsDescDvbShortSmoothingBuffer"
+		case MtsDescDvbDsng: return "MtsDescDvbDsng"
+		case MtsDescDvbDataBroadcastID: return "MtsDescDvbDataBroadcastID"
+		case MtsDescDvbTvaID: return "MtsDescDvbTvaID"
+		case MtsDescDvbEcmRepetitionRate: return "MtsDescDvbEcmRepetitionRate"
+		case MtsDescDvbVbiTeletext: return "MtsDescDvbVbiTeletext"
+		case MtsDescDvbLinkage: return "MtsDescDvbLinkage"
+		case MtsDescDvbMultilingualNetworkName: return "MtsDescDvbMultilingualNetworkName"
+		case MtsDescDvbPdc: return "MtsDescDvbPdc"
+		case MtsDescDvbServiceIdentifier: return "MtsDescDvbServiceIdentifier"
+		case MtsDescDvbBouquetName: return "MtsDescDvbBouquetName"
+		case MtsDescDvbService: return "MtsDescDvbService"
+		case MtsDescDvbTimeShiftedService: return "MtsDescDvbTimeShiftedService"
+		case MtsDescDvbComponent: return "MtsDescDvbComponent"
+		case MtsDescDvbContent: return "MtsDescDvbContent"
+		case MtsDescDvbMultilingualBouquetName: return "MtsDescDvbMultilingualBouquetName"
+		case MtsDescDvbServiceMove: return "MtsDescDvbServiceMove"
+		case MtsDescDvbFrequencyList: return "MtsDescDvbFrequencyList"
+		case MtsDescDvbServiceList: return "MtsDescDvbServiceList"
+		case MtsDescDvbCountryAvailability: return "MtsDescDvbCountryAvailability"
+		case MtsDescDvbPartialTransportStream: return "MtsDescDvbPartialTransportStream"
+		case MtsDescDvbTransportStream: return "MtsDescDvbTransportStream"
+		case MtsDescDvbAncillaryData: return "MtsDescDvbAncillaryData"
+		case MtsDescDvbDefaultAuthority: return "MtsDescDvbDefaultAuthority"
+		case MtsDescDvbTimesliceFecIdentifier: return "MtsDescDvbTimesliceFecIdentifier"
+		case MtsDescDvbFtaContentManagement: return "MtsDescDvbFtaContentManagement"
+		case MtsDescDvbExtendedEvent: return "MtsDescDvbExtendedEvent"
+		case MtsDescDvbCellList: return "MtsDescDvbCellList"
+		case MtsDescDvbCellFrequencyLink: return "MtsDescDvbCellFrequencyLink"
+		case MtsDescDvbContentIdentifier: return "MtsDescDvbContentIdentifier"
+		case MtsDescDvbExtension: return "MtsDescDvbExtension"
+		case MtsDescDvbEnhancedAc3: return "MtsDescDvbEnhancedAc3"
+		case MtsDescDvbAac: return "MtsDescDvbAac"
+		case MtsDescDvbNetworkName: return "MtsDescDvbNetworkName"
+		case MtsDescDvbStreamIdentifier: return "MtsDescDvbStreamIdentifier"
+		case MtsDescDvbAdaptationFieldData: return "MtsDescDvbAdaptationFieldData"
+		case MtsDescDvbCableDeliverySystem: return "MtsDescDvbCableDeliverySystem"
+		case MtsDescDvbDts: return "MtsDescDvbDts"
+		case MtsDescDvbXaitLocation: return "MtsDescDvbXaitLocation"
+		case MtsDescDvbShortEvent: return "MtsDescDvbShortEvent"
+		case MtsDescDvbCaIdentifier: return "MtsDescDvbCaIdentifier"
+		case MtsDescDvbMultilingualServiceName: return "MtsDescDvbMultilingualServiceName"
+		case MtsDescDvbAnnouncementSupport: return "MtsDescDvbAnnouncementSupport"
+		case MtsDescDvbStuffing: return "MtsDescDvbStuffing"
+		case MtsDescDvbSatelliteDeliverySystem: return "MtsDescDvbSatelliteDeliverySystem"
+		default: return fmt.Sprintf("DVBDescriptorType(%d)", e)
+	}
+}
+
 // DVBExtendedDescriptorType wraps GstMpegtsDVBExtendedDescriptorType
 //
 // The type of #GstMpegtsDescriptor
@@ -553,6 +735,33 @@ const (
 )
 
 
+func (e DVBExtendedDescriptorType) String() string {
+	switch e {
+		case MtsDescExtDvbImageIcon: return "MtsDescExtDvbImageIcon"
+		case MtsDescExtDvbNetworkChangeNotify: return "MtsDescExtDvbNetworkChangeNotify"
+		case MtsDescExtDvbServiceRelocated: return "MtsDescExtDvbServiceRelocated"
+		case MtsDescExtDvbDtsNeutral: return "MtsDescExtDvbDtsNeutral"
+		case MtsDescExtDvbVideoDepthRange: return "MtsDescExtDvbVideoDepthRange"
+		case MtsDescExtDvbURILinkage: return "MtsDescExtDvbURILinkage"
+		case MtsDescExtDvbAc4: return "MtsDescExtDvbAc4"
+		case MtsDescExtDvbC2DeliverySystem: return "MtsDescExtDvbC2DeliverySystem"
+		case MtsDescExtDvbCpcmDeliverySignalling: return "MtsDescExtDvbCpcmDeliverySignalling"
+		case MtsDescExtDvbCpIdentifier: return "MtsDescExtDvbCpIdentifier"
+		case MtsDescExtDvbShDeliverySystem: return "MtsDescExtDvbShDeliverySystem"
+		case MtsDescExtDvbSupplementaryAudio: return "MtsDescExtDvbSupplementaryAudio"
+		case MtsDescExtDvbMessage: return "MtsDescExtDvbMessage"
+		case MtsDescExtDvbTargetRegion: return "MtsDescExtDvbTargetRegion"
+		case MtsDescExtDvbTargetRegionName: return "MtsDescExtDvbTargetRegionName"
+		case MtsDescExtDvbCp: return "MtsDescExtDvbCp"
+		case MtsDescExtDvbDtsHdAudioStream: return "MtsDescExtDvbDtsHdAudioStream"
+		case MtsDescExtDvbAudioPreselection: return "MtsDescExtDvbAudioPreselection"
+		case MtsDescExtDvbXaitPid: return "MtsDescExtDvbXaitPid"
+		case MtsDescExtDvbT2DeliverySystem: return "MtsDescExtDvbT2DeliverySystem"
+		case MtsDescExtDvbT2Mi: return "MtsDescExtDvbT2Mi"
+		default: return fmt.Sprintf("DVBExtendedDescriptorType(%d)", e)
+	}
+}
+
 // DVBLinkageHandOverType wraps GstMpegtsDVBLinkageHandOverType
 type DVBLinkageHandOverType C.int
 
@@ -568,6 +777,16 @@ const (
 )
 
 
+func (e DVBLinkageHandOverType) String() string {
+	switch e {
+		case MpegtsDvbLinkageHandOverIdentical: return "MpegtsDvbLinkageHandOverIdentical"
+		case MpegtsDvbLinkageHandOverLocalVariation: return "MpegtsDvbLinkageHandOverLocalVariation"
+		case MpegtsDvbLinkageHandOverAssociated: return "MpegtsDvbLinkageHandOverAssociated"
+		case MpegtsDvbLinkageHandOverReserved: return "MpegtsDvbLinkageHandOverReserved"
+		default: return fmt.Sprintf("DVBLinkageHandOverType(%d)", e)
+	}
+}
+
 // DVBLinkageType wraps GstMpegtsDVBLinkageType
 //
 // Linkage Type (EN 300 468 v.1.13.1)
@@ -607,6 +826,27 @@ const (
 )
 
 
+func (e DVBLinkageType) String() string {
+	switch e {
+		case MpegtsDvbLinkageInformation: return "MpegtsDvbLinkageInformation"
+		case MpegtsDvbLinkageTsContainingCompleteSi: return "MpegtsDvbLinkageTsContainingCompleteSi"
+		case MpegtsDvbLinkageSystemSoftwareUpdate: return "MpegtsDvbLinkageSystemSoftwareUpdate"
+		case MpegtsDvbLinkageTsContainingInt: return "MpegtsDvbLinkageTsContainingInt"
+		case MpegtsDvbLinkageExtendedEvent: return "MpegtsDvbLinkageExtendedEvent"
+		case MpegtsDvbLinkageEpg: return "MpegtsDvbLinkageEpg"
+		case MpegtsDvbLinkageDataBroadcast: return "MpegtsDvbLinkageDataBroadcast"
+		case MpegtsDvbLinkageRcsMap: return "MpegtsDvbLinkageRcsMap"
+		case MpegtsDvbLinkageTsContainingSsu: return "MpegtsDvbLinkageTsContainingSsu"
+		case MpegtsDvbLinkageIPMacNotification: return "MpegtsDvbLinkageIPMacNotification"
+		case MpegtsDvbLinkageServiceReplacement: return "MpegtsDvbLinkageServiceReplacement"
+		case MpegtsDvbLinkageMobileHandOver: return "MpegtsDvbLinkageMobileHandOver"
+		case MpegtsDvbLinkageReserved00: return "MpegtsDvbLinkageReserved00"
+		case MpegtsDvbLinkageCaReplacement: return "MpegtsDvbLinkageCaReplacement"
+		case MpegtsDvbLinkageEvent: return "MpegtsDvbLinkageEvent"
+		default: return fmt.Sprintf("DVBLinkageType(%d)", e)
+	}
+}
+
 // DVBScramblingModeType wraps GstMpegtsDVBScramblingModeType
 type DVBScramblingModeType C.int
 
@@ -632,6 +872,21 @@ const (
 )
 
 
+func (e DVBScramblingModeType) String() string {
+	switch e {
+		case MpegtsDvbScramblingModeCsa2: return "MpegtsDvbScramblingModeCsa2"
+		case MpegtsDvbScramblingModeCsa3Standard: return "MpegtsDvbScramblingModeCsa3Standard"
+		case MpegtsDvbScramblingModeReserved: return "MpegtsDvbScramblingModeReserved"
+		case MpegtsDvbScramblingModeCsa1: return "MpegtsDvbScramblingModeCsa1"
+		case MpegtsDvbScramblingModeCsa3MinimalEnhanced: return "MpegtsDvbScramblingModeCsa3MinimalEnhanced"
+		case MpegtsDvbScramblingModeCsa3FullEnhanced: return "MpegtsDvbScramblingModeCsa3FullEnhanced"
+		case MpegtsDvbScramblingModeCissa: return "MpegtsDvbScramblingModeCissa"
+		case MpegtsDvbScramblingModeAtis0: return "MpegtsDvbScramblingModeAtis0"
+		case MpegtsDvbScramblingModeAtisF: return "MpegtsDvbScramblingModeAtisF"
+		default: return fmt.Sprintf("DVBScramblingModeType(%d)", e)
+	}
+}
+
 // DVBServiceType wraps GstMpegtsDVBServiceType
 //
 // The type of service of a channel.
@@ -699,6 +954,40 @@ const (
 )
 
 
+func (e DVBServiceType) String() string {
+	switch e {
+		case DvbServiceAdvancedCodecSdDigitalTelevision: return "DvbServiceAdvancedCodecSdDigitalTelevision"
+		case DvbServiceAdvancedCodecSdNvodTimeShifted: return "DvbServiceAdvancedCodecSdNvodTimeShifted"
+		case DvbServiceAdvancedCodecSdNvodReference: return "DvbServiceAdvancedCodecSdNvodReference"
+		case DvbServiceDigitalTelevision: return "DvbServiceDigitalTelevision"
+		case DvbServiceTeletext: return "DvbServiceTeletext"
+		case DvbServiceFmRadio: return "DvbServiceFmRadio"
+		case DvbServiceReserved09: return "DvbServiceReserved09"
+		case DvbServiceAdvancedCodecDigitalRadioSound: return "DvbServiceAdvancedCodecDigitalRadioSound"
+		case DvbServiceReserved0DCommonInterface: return "DvbServiceReserved0DCommonInterface"
+		case DvbServiceAdvancedCodecHdDigitalTelevision: return "DvbServiceAdvancedCodecHdDigitalTelevision"
+		case DvbServiceAdvancedCodecHdNvodReference: return "DvbServiceAdvancedCodecHdNvodReference"
+		case DvbServiceDigitalRadioSound: return "DvbServiceDigitalRadioSound"
+		case DvbServiceNvodReference: return "DvbServiceNvodReference"
+		case DvbServiceMosaic: return "DvbServiceMosaic"
+		case DvbServiceDataBroadcast: return "DvbServiceDataBroadcast"
+		case DvbServiceAdvancedCodecHdNvodTimeShifted: return "DvbServiceAdvancedCodecHdNvodTimeShifted"
+		case DvbServiceAdvancedCodecStereoHdNvodTimeShifted: return "DvbServiceAdvancedCodecStereoHdNvodTimeShifted"
+		case DvbServiceReserved00: return "DvbServiceReserved00"
+		case DvbServiceRcsMap: return "DvbServiceRcsMap"
+		case DvbServiceRcsFls: return "DvbServiceRcsFls"
+		case DvbServiceAdvancedCodecStereoHdDigitalTelevision: return "DvbServiceAdvancedCodecStereoHdDigitalTelevision"
+		case DvbServiceAdvancedCodecStereoHdNvodReference: return "DvbServiceAdvancedCodecStereoHdNvodReference"
+		case DvbServiceReservedFf: return "DvbServiceReservedFf"
+		case DvbServiceNvodTimeShifted: return "DvbServiceNvodTimeShifted"
+		case DvbServiceDvbSrm: return "DvbServiceDvbSrm"
+		case DvbServiceAdvancedCodecMosaic: return "DvbServiceAdvancedCodecMosaic"
+		case DvbServiceDvbMhp: return "DvbServiceDvbMhp"
+		case DvbServiceMpeg2HdDigitalTelevision: return "DvbServiceMpeg2HdDigitalTelevision"
+		default: return fmt.Sprintf("DVBServiceType(%d)", e)
+	}
+}
+
 // DVBTeletextType wraps GstMpegtsDVBTeletextType
 //
 // The type of teletext page.
@@ -720,6 +1009,17 @@ const (
 )
 
 
+func (e DVBTeletextType) String() string {
+	switch e {
+		case InitialPage: return "InitialPage"
+		case SubtitlePage: return "SubtitlePage"
+		case AdditionalInfoPage: return "AdditionalInfoPage"
+		case ProgrammeSchedulePage: return "ProgrammeSchedulePage"
+		case HearingImpairedPage: return "HearingImpairedPage"
+		default: return fmt.Sprintf("DVBTeletextType(%d)", e)
+	}
+}
+
 // DescriptorType wraps GstMpegtsDescriptorType
 //
 // The type of #GstMpegtsDescriptor
@@ -842,6 +1142,66 @@ const (
 )
 
 
+func (e DescriptorType) String() string {
+	switch e {
+		case MtsDescTargetBackgroundGrid: return "MtsDescTargetBackgroundGrid"
+		case MtsDescCa: return "MtsDescCa"
+		case MtsDescMpeg4Audio: return "MtsDescMpeg4Audio"
+		case MtsDescFmc: return "MtsDescFmc"
+		case MtsDescMetadataStd: return "MtsDescMetadataStd"
+		case MtsDescIpmp: return "MtsDescIpmp"
+		case MtsDescFlexMuxTiming: return "MtsDescFlexMuxTiming"
+		case MtsDescReserved00: return "MtsDescReserved00"
+		case MtsDescAudioStream: return "MtsDescAudioStream"
+		case MtsDescRegistration: return "MtsDescRegistration"
+		case MtsDescDataStreamAlignment: return "MtsDescDataStreamAlignment"
+		case MtsDescMultiplexBufferUtilisation: return "MtsDescMultiplexBufferUtilisation"
+		case MtsDescMpeg4Video: return "MtsDescMpeg4Video"
+		case MtsDescExternalESID: return "MtsDescExternalESID"
+		case MtsDescMetadataPointer: return "MtsDescMetadataPointer"
+		case MtsDescIbp: return "MtsDescIbp"
+		case MtsDescDsmccAssociationTag: return "MtsDescDsmccAssociationTag"
+		case MtsDescAvcVideo: return "MtsDescAvcVideo"
+		case MtsDescAvcTimingAndHrd: return "MtsDescAvcTimingAndHrd"
+		case MtsDescReserved01: return "MtsDescReserved01"
+		case MtsDescHierarchy: return "MtsDescHierarchy"
+		case MtsDescVideoWindow: return "MtsDescVideoWindow"
+		case MtsDescPrivateDataIndicator: return "MtsDescPrivateDataIndicator"
+		case MtsDescDsmccDeferredAssociationTag: return "MtsDescDsmccDeferredAssociationTag"
+		case MtsDescDsmccNptReference: return "MtsDescDsmccNptReference"
+		case MtsDescDsmccNptEndpoint: return "MtsDescDsmccNptEndpoint"
+		case MtsDescIod: return "MtsDescIod"
+		case MtsDescStd: return "MtsDescStd"
+		case MtsDescAuxiliaryVideoStream: return "MtsDescAuxiliaryVideoStream"
+		case MtsDescSvcExtension: return "MtsDescSvcExtension"
+		case MtsDescMvcExtension: return "MtsDescMvcExtension"
+		case MtsDescStereoscopicProgramInfo: return "MtsDescStereoscopicProgramInfo"
+		case MtsDescStereoscopicVideoInfo: return "MtsDescStereoscopicVideoInfo"
+		case MtsDescVideoStream: return "MtsDescVideoStream"
+		case MtsDescISO639Language: return "MtsDescISO639Language"
+		case MtsDescSystemClock: return "MtsDescSystemClock"
+		case MtsDescSmoothingBuffer: return "MtsDescSmoothingBuffer"
+		case MtsDescDsmccCarouselIdentifier: return "MtsDescDsmccCarouselIdentifier"
+		case MtsDescContentLabeling: return "MtsDescContentLabeling"
+		case MtsDescMetadata: return "MtsDescMetadata"
+		case MtsDescMpeg2AacAudio: return "MtsDescMpeg2AacAudio"
+		case MtsDescCopyright: return "MtsDescCopyright"
+		case MtsDescDsmccStreamEvent: return "MtsDescDsmccStreamEvent"
+		case MtsDescSl: return "MtsDescSl"
+		case MtsDescMuxCode: return "MtsDescMuxCode"
+		case MtsDescMultiplexBuffer: return "MtsDescMultiplexBuffer"
+		case MtsDescMpeg4AudioExtension: return "MtsDescMpeg4AudioExtension"
+		case MtsDescJ2KVideo: return "MtsDescJ2KVideo"
+		case MtsDescMvcOperationPoint: return "MtsDescMvcOperationPoint"
+		case MtsDescMaximumBitrate: return "MtsDescMaximumBitrate"
+		case MtsDescDsmccStreamMode: return "MtsDescDsmccStreamMode"
+		case MtsDescFmxBufferSize: return "MtsDescFmxBufferSize"
+		case MtsDescMpeg4Text: return "MtsDescMpeg4Text"
+		case MtsDescMpeg2StereoscopicVideoFormat: return "MtsDescMpeg2StereoscopicVideoFormat"
+		default: return fmt.Sprintf("DescriptorType(%d)", e)
+	}
+}
+
 // HdmvStreamType wraps GstMpegtsHdmvStreamType
 //
 // Type of mpeg-ts streams for Blu-ray formats. To be matched with the
@@ -878,6 +1238,25 @@ const (
 )
 
 
+func (e HdmvStreamType) String() string {
+	switch e {
+		case MpegtsStreamTypeHdmvSubtitle: return "MpegtsStreamTypeHdmvSubtitle"
+		case MpegtsStreamTypeHdmvAudioDtsHdSecondary: return "MpegtsStreamTypeHdmvAudioDtsHdSecondary"
+		case MpegtsStreamTypeHdmvAudioLpcm: return "MpegtsStreamTypeHdmvAudioLpcm"
+		case MpegtsStreamTypeHdmvAudioDts: return "MpegtsStreamTypeHdmvAudioDts"
+		case MpegtsStreamTypeHdmvAudioEac3: return "MpegtsStreamTypeHdmvAudioEac3"
+		case MpegtsStreamTypeHdmvSubpicturePgs: return "MpegtsStreamTypeHdmvSubpicturePgs"
+		case MpegtsStreamTypeHdmvAudioAc3PlusSecondary: return "MpegtsStreamTypeHdmvAudioAc3PlusSecondary"
+		case MpegtsStreamTypeHdmvAudioAc3: return "MpegtsStreamTypeHdmvAudioAc3"
+		case MpegtsStreamTypeHdmvAudioAc3TrueHd: return "MpegtsStreamTypeHdmvAudioAc3TrueHd"
+		case MpegtsStreamTypeHdmvAudioAc3Plus: return "MpegtsStreamTypeHdmvAudioAc3Plus"
+		case MpegtsStreamTypeHdmvAudioDtsHd: return "MpegtsStreamTypeHdmvAudioDtsHd"
+		case MpegtsStreamTypeHdmvAudioDtsHdMasterAudio: return "MpegtsStreamTypeHdmvAudioDtsHdMasterAudio"
+		case MpegtsStreamTypeHdmvIgs: return "MpegtsStreamTypeHdmvIgs"
+		default: return fmt.Sprintf("HdmvStreamType(%d)", e)
+	}
+}
+
 // ISDBDescriptorType wraps GstMpegtsISDBDescriptorType
 //
 // These values correspond to the registered descriptor type from
@@ -954,6 +1333,44 @@ const (
 )
 
 
+func (e ISDBDescriptorType) String() string {
+	switch e {
+		case MtsDescIsdbContentAvailability: return "MtsDescIsdbContentAvailability"
+		case MtsDescIsdbPartialTsTime: return "MtsDescIsdbPartialTsTime"
+		case MtsDescIsdbExtendedBroadcaster: return "MtsDescIsdbExtendedBroadcaster"
+		case MtsDescIsdbReference: return "MtsDescIsdbReference"
+		case MtsDescIsdbNodeRelation: return "MtsDescIsdbNodeRelation"
+		case MtsDescIsdbEventGroup: return "MtsDescIsdbEventGroup"
+		case MtsDescIsdbDataContent: return "MtsDescIsdbDataContent"
+		case MtsDescIsdbShortNodeInformation: return "MtsDescIsdbShortNodeInformation"
+		case MtsDescIsdbSeries: return "MtsDescIsdbSeries"
+		case MtsDescIsdbConnectedTransmission: return "MtsDescIsdbConnectedTransmission"
+		case MtsDescIsdbHierarchicalTransmission: return "MtsDescIsdbHierarchicalTransmission"
+		case MtsDescIsdbCaService: return "MtsDescIsdbCaService"
+		case MtsDescIsdbLdtLinkage: return "MtsDescIsdbLdtLinkage"
+		case MtsDescIsdbNetworkIdentification: return "MtsDescIsdbNetworkIdentification"
+		case MtsDescIsdbDownloadContent: return "MtsDescIsdbDownloadContent"
+		case MtsDescIsdbCaContractInformation: return "MtsDescIsdbCaContractInformation"
+		case MtsDescIsdbLogoTransmission: return "MtsDescIsdbLogoTransmission"
+		case MtsDescIsdbBasicLocalEvent: return "MtsDescIsdbBasicLocalEvent"
+		case MtsDescIsdbStcReference: return "MtsDescIsdbStcReference"
+		case MtsDescIsdbBroadcasterName: return "MtsDescIsdbBroadcasterName"
+		case MtsDescIsdbComponentGroup: return "MtsDescIsdbComponentGroup"
+		case MtsDescIsdbDigitalCopyControl: return "MtsDescIsdbDigitalCopyControl"
+		case MtsDescIsdbAudioComponent: return "MtsDescIsdbAudioComponent"
+		case MtsDescIsdbTsInformation: return "MtsDescIsdbTsInformation"
+		case MtsDescIsdbServiceGroup: return "MtsDescIsdbServiceGroup"
+		case MtsDescIsdbHyperlink: return "MtsDescIsdbHyperlink"
+		case MtsDescIsdbTargetRegion: return "MtsDescIsdbTargetRegion"
+		case MtsDescIsdbVideoDecodeControl: return "MtsDescIsdbVideoDecodeControl"
+		case MtsDescIsdbSiPrimeTs: return "MtsDescIsdbSiPrimeTs"
+		case MtsDescIsdbBoardInformation: return "MtsDescIsdbBoardInformation"
+		case MtsDescIsdbCaEmmTs: return "MtsDescIsdbCaEmmTs"
+		case MtsDescIsdbSiParameter: return "MtsDescIsdbSiParameter"
+		default: return fmt.Sprintf("ISDBDescriptorType(%d)", e)
+	}
+}
+
 // ISO639AudioType wraps GstMpegtsIso639AudioType
 type ISO639AudioType C.int
 
@@ -969,6 +1386,16 @@ const (
 )
 
 
+func (e ISO639AudioType) String() string {
+	switch e {
+		case MpegtsAudioTypeHearingImpaired: return "MpegtsAudioTypeHearingImpaired"
+		case MpegtsAudioTypeVisualImpairedCommentary: return "MpegtsAudioTypeVisualImpairedCommentary"
+		case MpegtsAudioTypeUndefined: return "MpegtsAudioTypeUndefined"
+		case MpegtsAudioTypeCleanEffects: return "MpegtsAudioTypeCleanEffects"
+		default: return fmt.Sprintf("ISO639AudioType(%d)", e)
+	}
+}
+
 // MetadataFormat wraps GstMpegtsMetadataFormat
 //
 // metadata_descriptor metadata_format valid values. See ISO/IEC 13818-1:2018(E) Table 2-85.
@@ -994,6 +1421,16 @@ const (
 )
 
 
+func (e MetadataFormat) String() string {
+	switch e {
+		case MpegtsMetadataFormatIdentifierField: return "MpegtsMetadataFormatIdentifierField"
+		case MpegtsMetadataFormatTem: return "MpegtsMetadataFormatTem"
+		case MpegtsMetadataFormatBim: return "MpegtsMetadataFormatBim"
+		case MpegtsMetadataFormatApplicationFormat: return "MpegtsMetadataFormatApplicationFormat"
+		default: return fmt.Sprintf("MetadataFormat(%d)", e)
+	}
+}
+
 // MiscDescriptorType wraps GstMpegtsMiscDescriptorType
 //
 // The type of #GstMpegtsDescriptor
@@ -1008,6 +1445,13 @@ const (
 )
 
 
+func (e MiscDescriptorType) String() string {
+	switch e {
+		case MtsDescDtgLogicalChannel: return "MtsDescDtgLogicalChannel"
+		default: return fmt.Sprintf("MiscDescriptorType(%d)", e)
+	}
+}
+
 // ModulationType wraps GstMpegtsModulationType
 type ModulationType C.int
 
@@ -1045,6 +1489,27 @@ const (
 )
 
 
+func (e ModulationType) String() string {
+	switch e {
+		case MpegtsModulationApsk16: return "MpegtsModulationApsk16"
+		case MpegtsModulationQam4Nr_: return "MpegtsModulationQam4Nr_"
+		case MpegtsModulationQam16: return "MpegtsModulationQam16"
+		case MpegtsModulationQam64: return "MpegtsModulationQam64"
+		case MpegtsModulationQam256: return "MpegtsModulationQam256"
+		case MpegtsModulationQpsk: return "MpegtsModulationQpsk"
+		case MpegtsModulationQam128: return "MpegtsModulationQam128"
+		case MpegtsModulationPsk8: return "MpegtsModulationPsk8"
+		case MpegtsModulationApsk32: return "MpegtsModulationApsk32"
+		case MpegtsModulationQam32: return "MpegtsModulationQam32"
+		case MpegtsModulationQamAuto: return "MpegtsModulationQamAuto"
+		case MpegtsModulationVsb8: return "MpegtsModulationVsb8"
+		case MpegtsModulationVsb16: return "MpegtsModulationVsb16"
+		case MpegtsModulationDqpsk: return "MpegtsModulationDqpsk"
+		case MpegtsModulationNone: return "MpegtsModulationNone"
+		default: return fmt.Sprintf("ModulationType(%d)", e)
+	}
+}
+
 // RunningStatus wraps GstMpegtsRunningStatus
 //
 // Running status of a service.
@@ -1068,6 +1533,18 @@ const (
 )
 
 
+func (e RunningStatus) String() string {
+	switch e {
+		case MpegtsRunningStatusNotRunning: return "MpegtsRunningStatusNotRunning"
+		case MpegtsRunningStatusStartsInFewSeconds: return "MpegtsRunningStatusStartsInFewSeconds"
+		case MpegtsRunningStatusPausing: return "MpegtsRunningStatusPausing"
+		case MpegtsRunningStatusRunning: return "MpegtsRunningStatusRunning"
+		case MpegtsRunningStatusOffAir: return "MpegtsRunningStatusOffAir"
+		case MpegtsRunningStatusUndefined: return "MpegtsRunningStatusUndefined"
+		default: return fmt.Sprintf("RunningStatus(%d)", e)
+	}
+}
+
 // SCTEDescriptorType wraps GstMpegtsSCTEDescriptorType
 //
 // These values correspond to the ones defined by SCTE (amongst other in ANSI/SCTE 57)
@@ -1093,6 +1570,20 @@ const (
 )
 
 
+func (e SCTEDescriptorType) String() string {
+	switch e {
+		case MtsDescScteFrameRate: return "MtsDescScteFrameRate"
+		case MtsDescScteExtendedVideo: return "MtsDescScteExtendedVideo"
+		case MtsDescScteComponentName: return "MtsDescScteComponentName"
+		case MtsDescScteFrequencySpec: return "MtsDescScteFrequencySpec"
+		case MtsDescScteModulationParams: return "MtsDescScteModulationParams"
+		case MtsDescScteTransportStreamID: return "MtsDescScteTransportStreamID"
+		case MtsDescScteStuffing: return "MtsDescScteStuffing"
+		case MtsDescScteAc3: return "MtsDescScteAc3"
+		default: return fmt.Sprintf("SCTEDescriptorType(%d)", e)
+	}
+}
+
 // SCTESpliceCommandType wraps GstMpegtsSCTESpliceCommandType
 type SCTESpliceCommandType C.int
 
@@ -1112,6 +1603,18 @@ const (
 )
 
 
+func (e SCTESpliceCommandType) String() string {
+	switch e {
+		case MtsScteSpliceCommandInsert: return "MtsScteSpliceCommandInsert"
+		case MtsScteSpliceCommandTime: return "MtsScteSpliceCommandTime"
+		case MtsScteSpliceCommandBandwidth: return "MtsScteSpliceCommandBandwidth"
+		case MtsScteSpliceCommandPrivate: return "MtsScteSpliceCommandPrivate"
+		case MtsScteSpliceCommandNull: return "MtsScteSpliceCommandNull"
+		case MtsScteSpliceCommandSchedule: return "MtsScteSpliceCommandSchedule"
+		default: return fmt.Sprintf("SCTESpliceCommandType(%d)", e)
+	}
+}
+
 // SCTESpliceDescriptor wraps GstMpegtsSCTESpliceDescriptor
 type SCTESpliceDescriptor C.int
 
@@ -1129,6 +1632,17 @@ const (
 )
 
 
+func (e SCTESpliceDescriptor) String() string {
+	switch e {
+		case MtsScteDescSegmentation: return "MtsScteDescSegmentation"
+		case MtsScteDescTime: return "MtsScteDescTime"
+		case MtsScteDescAudio: return "MtsScteDescAudio"
+		case MtsScteDescAvail: return "MtsScteDescAvail"
+		case MtsScteDescDtmf: return "MtsScteDescDtmf"
+		default: return fmt.Sprintf("SCTESpliceDescriptor(%d)", e)
+	}
+}
+
 // SatellitePolarizationType wraps GstMpegtsSatellitePolarizationType
 type SatellitePolarizationType C.int
 
@@ -1144,6 +1658,16 @@ const (
 )
 
 
+func (e SatellitePolarizationType) String() string {
+	switch e {
+		case MpegtsPolarizationLinearHorizontal: return "MpegtsPolarizationLinearHorizontal"
+		case MpegtsPolarizationLinearVertical: return "MpegtsPolarizationLinearVertical"
+		case MpegtsPolarizationCircularLeft: return "MpegtsPolarizationCircularLeft"
+		case MpegtsPolarizationCircularRight: return "MpegtsPolarizationCircularRight"
+		default: return fmt.Sprintf("SatellitePolarizationType(%d)", e)
+	}
+}
+
 // SatelliteRolloff wraps GstMpegtsSatelliteRolloff
 type SatelliteRolloff C.int
 
@@ -1161,6 +1685,17 @@ const (
 )
 
 
+func (e SatelliteRolloff) String() string {
+	switch e {
+		case MpegtsRolloff20: return "MpegtsRolloff20"
+		case MpegtsRolloff25: return "MpegtsRolloff25"
+		case MpegtsRolloffReserved: return "MpegtsRolloffReserved"
+		case MpegtsRolloffAuto: return "MpegtsRolloffAuto"
+		case MpegtsRolloff35: return "MpegtsRolloff35"
+		default: return fmt.Sprintf("SatelliteRolloff(%d)", e)
+	}
+}
+
 // ScteStreamType wraps GstMpegtsScteStreamType
 //
 // Type of mpeg-ts streams for SCTE. Most users would want to use the
@@ -1206,6 +1741,20 @@ const (
 )
 
 
+func (e ScteStreamType) String() string {
+	switch e {
+		case MpegtsStreamTypeScteSyncData: return "MpegtsStreamTypeScteSyncData"
+		case MpegtsStreamTypeScteAsyncData: return "MpegtsStreamTypeScteAsyncData"
+		case MpegtsStreamTypeScteSubtitling: return "MpegtsStreamTypeScteSubtitling"
+		case MpegtsStreamTypeScteIsochData: return "MpegtsStreamTypeScteIsochData"
+		case MpegtsStreamTypeScteSit: return "MpegtsStreamTypeScteSit"
+		case MpegtsStreamTypeScteDstNrt: return "MpegtsStreamTypeScteDstNrt"
+		case MpegtsStreamTypeScteDsmccDcb: return "MpegtsStreamTypeScteDsmccDcb"
+		case MpegtsStreamTypeScteSignaling: return "MpegtsStreamTypeScteSignaling"
+		default: return fmt.Sprintf("ScteStreamType(%d)", e)
+	}
+}
+
 // SectionATSCTableID wraps GstMpegtsSectionATSCTableID
 //
 // Values for a #GstMpegtsSection table_id.
@@ -1286,6 +1835,30 @@ const (
 )
 
 
+func (e SectionATSCTableID) String() string {
+	switch e {
+		case MtsTableIDAtscChannelOrEventExtendedText: return "MtsTableIDAtscChannelOrEventExtendedText"
+		case MtsTableIDAtscDirectedChannelChangeSectionCode: return "MtsTableIDAtscDirectedChannelChangeSectionCode"
+		case MtsTableIDAtscSatelliteVirtualChannel: return "MtsTableIDAtscSatelliteVirtualChannel"
+		case MtsTableIDAtscRatingRegion: return "MtsTableIDAtscRatingRegion"
+		case MtsTableIDAtscDataEvent: return "MtsTableIDAtscDataEvent"
+		case MtsTableIDAtscProgramIdentifier: return "MtsTableIDAtscProgramIdentifier"
+		case MtsTableIDAtscLongTermService: return "MtsTableIDAtscLongTermService"
+		case MtsTableIDAtscAggregateExtendedText: return "MtsTableIDAtscAggregateExtendedText"
+		case MtsTableIDAtscAggregateDataEvent: return "MtsTableIDAtscAggregateDataEvent"
+		case MtsTableIDAtscMasterGuide: return "MtsTableIDAtscMasterGuide"
+		case MtsTableIDAtscCableVirtualChannel: return "MtsTableIDAtscCableVirtualChannel"
+		case MtsTableIDAtscSystemTime: return "MtsTableIDAtscSystemTime"
+		case MtsTableIDAtscNetworkResource: return "MtsTableIDAtscNetworkResource"
+		case MtsTableIDAtscTerrestrialVirtualChannel: return "MtsTableIDAtscTerrestrialVirtualChannel"
+		case MtsTableIDAtscEventInformation: return "MtsTableIDAtscEventInformation"
+		case MtsTableIDAtscDataService: return "MtsTableIDAtscDataService"
+		case MtsTableIDAtscDirectedChannelChange: return "MtsTableIDAtscDirectedChannelChange"
+		case MtsTableIDAtscAggregateEventInformation: return "MtsTableIDAtscAggregateEventInformation"
+		default: return fmt.Sprintf("SectionATSCTableID(%d)", e)
+	}
+}
+
 // SectionDVBTableID wraps GstMpegtsSectionDVBTableID
 //
 // Values for a #GstMpegtsSection table_id.
@@ -1444,6 +2017,53 @@ const (
 )
 
 
+func (e SectionDVBTableID) String() string {
+	switch e {
+		case MtsTableIDEventInformationOtherTsPresent: return "MtsTableIDEventInformationOtherTsPresent"
+		case MtsTableIDStuffing: return "MtsTableIDStuffing"
+		case MtsTableIDContainer: return "MtsTableIDContainer"
+		case MtsTableIDCaMessageSystemPrivate1: return "MtsTableIDCaMessageSystemPrivate1"
+		case MtsTableIDSelectionInformation: return "MtsTableIDSelectionInformation"
+		case MtsTableIDNetworkInformationOtherNetwork: return "MtsTableIDNetworkInformationOtherNetwork"
+		case MtsTableIDServiceDescriptionActualTs: return "MtsTableIDServiceDescriptionActualTs"
+		case MtsTableIDEventInformationActualTsSchedule1: return "MtsTableIDEventInformationActualTsSchedule1"
+		case MtsTableIDContentIdentifier: return "MtsTableIDContentIdentifier"
+		case MtsTableIDSct: return "MtsTableIDSct"
+		case MtsTableIDTransmissionModeSupportPayload: return "MtsTableIDTransmissionModeSupportPayload"
+		case MtsTableIDEventInformationActualTsPresent: return "MtsTableIDEventInformationActualTsPresent"
+		case MtsTableIDTim: return "MtsTableIDTim"
+		case MtsTableIDTimeDate: return "MtsTableIDTimeDate"
+		case MtsTableIDNetworkInformationActualNetwork: return "MtsTableIDNetworkInformationActualNetwork"
+		case MtsTableIDBouquetAssociation: return "MtsTableIDBouquetAssociation"
+		case MtsTableIDRunningStatus: return "MtsTableIDRunningStatus"
+		case MtsTableIDCaMessageSystemPrivateN: return "MtsTableIDCaMessageSystemPrivateN"
+		case MtsTableIDFct: return "MtsTableIDFct"
+		case MtsTableIDCmt: return "MtsTableIDCmt"
+		case MtsTableIDPcrPacketPayload: return "MtsTableIDPcrPacketPayload"
+		case MtsTableIDEventInformationOtherTsScheduleN: return "MtsTableIDEventInformationOtherTsScheduleN"
+		case MtsTableIDTimeOffset: return "MtsTableIDTimeOffset"
+		case MtsTableIDApplicationInformationTable: return "MtsTableIDApplicationInformationTable"
+		case MtsTableIDCaMessageEcm0: return "MtsTableIDCaMessageEcm0"
+		case MtsTableIDTbtp: return "MtsTableIDTbtp"
+		case MtsTableIDLlFecParityDataTable: return "MtsTableIDLlFecParityDataTable"
+		case MtsTableIDEventInformationActualTsScheduleN: return "MtsTableIDEventInformationActualTsScheduleN"
+		case MtsTableIDMpeFec: return "MtsTableIDMpeFec"
+		case MtsTableIDProtectionMessage: return "MtsTableIDProtectionMessage"
+		case MtsTableIDDiscontinuityInformation: return "MtsTableIDDiscontinuityInformation"
+		case MtsTableIDCaMessageEcm1: return "MtsTableIDCaMessageEcm1"
+		case MtsTableIDSpt: return "MtsTableIDSpt"
+		case MtsTableIDEventInformationOtherTsSchedule1: return "MtsTableIDEventInformationOtherTsSchedule1"
+		case MtsTableIDResolutionNotification: return "MtsTableIDResolutionNotification"
+		case MtsTableIDUpdateNotification: return "MtsTableIDUpdateNotification"
+		case MtsTableIDDownloadableFontInfo: return "MtsTableIDDownloadableFontInfo"
+		case MtsTableIDRelatedContent: return "MtsTableIDRelatedContent"
+		case MtsTableIDMpeIfec: return "MtsTableIDMpeIfec"
+		case MtsTableIDTct: return "MtsTableIDTct"
+		case MtsTableIDServiceDescriptionOtherTs: return "MtsTableIDServiceDescriptionOtherTs"
+		default: return fmt.Sprintf("SectionDVBTableID(%d)", e)
+	}
+}
+
 // SectionSCTETableID wraps GstMpegtsSectionSCTETableID
 //
 // Values for a #GstMpegtsSection table_id.
@@ -1486,6 +2106,19 @@ const (
 )
 
 
+func (e SectionSCTETableID) String() string {
+	switch e {
+		case MtsTableIDScteEas: return "MtsTableIDScteEas"
+		case MtsTableIDScteEbif: return "MtsTableIDScteEbif"
+		case MtsTableIDScteReserved: return "MtsTableIDScteReserved"
+		case MtsTableIDScteEiss: return "MtsTableIDScteEiss"
+		case MtsTableIDScteDii: return "MtsTableIDScteDii"
+		case MtsTableIDScteDdb: return "MtsTableIDScteDdb"
+		case MtsTableIDScteSplice: return "MtsTableIDScteSplice"
+		default: return fmt.Sprintf("SectionSCTETableID(%d)", e)
+	}
+}
+
 // SectionTableID wraps GstMpegtsSectionTableID
 //
 // Values for a #GstMpegtsSection table_id
@@ -1572,6 +2205,30 @@ const (
 )
 
 
+func (e SectionTableID) String() string {
+	switch e {
+		case MtsTableIDConditionalAccess: return "MtsTableIDConditionalAccess"
+		case MtsTableIDTsProgramMap: return "MtsTableIDTsProgramMap"
+		case MtsTableID14496SceneDescription: return "MtsTableID14496SceneDescription"
+		case MtsTableIDMetadata: return "MtsTableIDMetadata"
+		case MtsTableIDDsmCcStreamDescriptors: return "MtsTableIDDsmCcStreamDescriptors"
+		case MtsTableIDDsmCcAddressableSections: return "MtsTableIDDsmCcAddressableSections"
+		case MtsTableIDProgramAssociation: return "MtsTableIDProgramAssociation"
+		case MtsTableIDIpmpControlInformation: return "MtsTableIDIpmpControlInformation"
+		case MtsTableID2300110_Section: return "MtsTableID2300110Section"
+		case MtsTableIDDsmCcUNMessages: return "MtsTableIDDsmCcUNMessages"
+		case MtsTableIDDsmCcDownloadDataMessages: return "MtsTableIDDsmCcDownloadDataMessages"
+		case MtsTableID14496ObjetDescriptor: return "MtsTableID14496ObjetDescriptor"
+		case MtsTableID14496Section: return "MtsTableID14496Section"
+		case MtsTableIDUnset: return "MtsTableIDUnset"
+		case MtsTableIDTsDescription: return "MtsTableIDTsDescription"
+		case MtsTableID2300111_Section: return "MtsTableID2300111Section"
+		case MtsTableIDDsmCcMultiprotoEncapsulatedData: return "MtsTableIDDsmCcMultiprotoEncapsulatedData"
+		case MtsTableIDDsmCcPrivateData: return "MtsTableIDDsmCcPrivateData"
+		default: return fmt.Sprintf("SectionTableID(%d)", e)
+	}
+}
+
 // SectionType wraps GstMpegtsSectionType
 //
 // Types of #GstMpegtsSection that the library handles. This covers all the
@@ -1663,6 +2320,32 @@ const (
 )
 
 
+func (e SectionType) String() string {
+	switch e {
+		case MpegtsSectionTsdt: return "MpegtsSectionTsdt"
+		case MpegtsSectionNit: return "MpegtsSectionNit"
+		case MpegtsSectionAtscMgt: return "MpegtsSectionAtscMgt"
+		case MpegtsSectionUnknown: return "MpegtsSectionUnknown"
+		case MpegtsSectionBat: return "MpegtsSectionBat"
+		case MpegtsSectionSdt: return "MpegtsSectionSdt"
+		case MpegtsSectionTdt: return "MpegtsSectionTdt"
+		case MpegtsSectionSit: return "MpegtsSectionSit"
+		case MpegtsSectionAtscTvct: return "MpegtsSectionAtscTvct"
+		case MpegtsSectionAtscEit: return "MpegtsSectionAtscEit"
+		case MpegtsSectionAtscStt: return "MpegtsSectionAtscStt"
+		case MpegtsSectionPmt: return "MpegtsSectionPmt"
+		case MpegtsSectionAtscCvct: return "MpegtsSectionAtscCvct"
+		case MpegtsSectionAtscEtt: return "MpegtsSectionAtscEtt"
+		case MpegtsSectionAtscRrt: return "MpegtsSectionAtscRrt"
+		case MpegtsSectionEit: return "MpegtsSectionEit"
+		case MpegtsSectionTot: return "MpegtsSectionTot"
+		case MpegtsSectionScteSit: return "MpegtsSectionScteSit"
+		case MpegtsSectionPat: return "MpegtsSectionPat"
+		case MpegtsSectionCat: return "MpegtsSectionCat"
+		default: return fmt.Sprintf("SectionType(%d)", e)
+	}
+}
+
 // StreamType wraps GstMpegtsStreamType
 //
 // Type of MPEG-TS stream type.
@@ -1861,6 +2544,51 @@ const (
 )
 
 
+func (e StreamType) String() string {
+	switch e {
+		case MpegtsStreamTypeMpeg2Ipmp: return "MpegtsStreamTypeMpeg2Ipmp"
+		case MpegtsStreamTypeAudioAacClean: return "MpegtsStreamTypeAudioAacClean"
+		case MpegtsStreamTypeMpeg4TimedText: return "MpegtsStreamTypeMpeg4TimedText"
+		case MpegtsStreamTypeDsmccC: return "MpegtsStreamTypeDsmccC"
+		case MpegtsStreamTypeMetadataSections: return "MpegtsStreamTypeMetadataSections"
+		case MpegtsStreamTypeVideoJp2K: return "MpegtsStreamTypeVideoJp2K"
+		case MpegtsStreamTypeVideoMpeg2StereoAdditionalView: return "MpegtsStreamTypeVideoMpeg2StereoAdditionalView"
+		case MpegtsStreamTypeIpmpStream: return "MpegtsStreamTypeIpmpStream"
+		case MpegtsStreamTypeReserved00: return "MpegtsStreamTypeReserved00"
+		case MpegtsStreamTypeVideoMpeg2: return "MpegtsStreamTypeVideoMpeg2"
+		case MpegtsStreamTypeVideoHevc: return "MpegtsStreamTypeVideoHevc"
+		case MpegtsStreamTypePrivateSections: return "MpegtsStreamTypePrivateSections"
+		case MpegtsStreamTypePrivatePesPackets: return "MpegtsStreamTypePrivatePesPackets"
+		case MpegtsStreamTypeMheg: return "MpegtsStreamTypeMheg"
+		case MpegtsStreamTypeDsmCc: return "MpegtsStreamTypeDsmCc"
+		case MpegtsStreamTypeDsmccA: return "MpegtsStreamTypeDsmccA"
+		case MpegtsStreamTypeMetadataSynchronizedDownload: return "MpegtsStreamTypeMetadataSynchronizedDownload"
+		case MpegtsStreamTypeVideoH264SvcSubBitstream: return "MpegtsStreamTypeVideoH264SvcSubBitstream"
+		case MpegtsStreamTypeSlFlexmuxPesPackets: return "MpegtsStreamTypeSlFlexmuxPesPackets"
+		case MpegtsStreamTypeSlFlexmuxSections: return "MpegtsStreamTypeSlFlexmuxSections"
+		case MpegtsStreamTypeMetadataDataCarousel: return "MpegtsStreamTypeMetadataDataCarousel"
+		case MpegtsStreamTypeVideoH264MvcSubBitstream: return "MpegtsStreamTypeVideoH264MvcSubBitstream"
+		case MpegtsStreamTypeUserPrivateEa: return "MpegtsStreamTypeUserPrivateEa"
+		case MpegtsStreamTypeDsmccB: return "MpegtsStreamTypeDsmccB"
+		case MpegtsStreamTypeAudioMpeg2: return "MpegtsStreamTypeAudioMpeg2"
+		case MpegtsStreamTypeH2221: return "MpegtsStreamTypeH2221"
+		case MpegtsStreamTypeSynchronizedDownload: return "MpegtsStreamTypeSynchronizedDownload"
+		case MpegtsStreamTypeVideoH264: return "MpegtsStreamTypeVideoH264"
+		case MpegtsStreamTypeVideoH264StereoAdditionalView: return "MpegtsStreamTypeVideoH264StereoAdditionalView"
+		case MpegtsStreamTypeAudioMpeg1: return "MpegtsStreamTypeAudioMpeg1"
+		case MpegtsStreamTypeDsmccD: return "MpegtsStreamTypeDsmccD"
+		case MpegtsStreamTypeAudioAacAdts: return "MpegtsStreamTypeAudioAacAdts"
+		case MpegtsStreamTypeVideoMpeg4: return "MpegtsStreamTypeVideoMpeg4"
+		case MpegtsStreamTypeMetadataObjectCarousel: return "MpegtsStreamTypeMetadataObjectCarousel"
+		case MpegtsStreamTypeVideoRvc: return "MpegtsStreamTypeVideoRvc"
+		case MpegtsStreamTypeVideoMpeg1: return "MpegtsStreamTypeVideoMpeg1"
+		case MpegtsStreamTypeAuxiliary: return "MpegtsStreamTypeAuxiliary"
+		case MpegtsStreamTypeAudioAacLatm: return "MpegtsStreamTypeAudioAacLatm"
+		case MpegtsStreamTypeMetadataPesPackets: return "MpegtsStreamTypeMetadataPesPackets"
+		default: return fmt.Sprintf("StreamType(%d)", e)
+	}
+}
+
 // TerrestrialGuardInterval wraps GstMpegtsTerrestrialGuardInterval
 type TerrestrialGuardInterval C.int
 
@@ -1890,6 +2618,23 @@ const (
 )
 
 
+func (e TerrestrialGuardInterval) String() string {
+	switch e {
+		case MpegtsGuardIntervalPn945: return "MpegtsGuardIntervalPn945"
+		case MpegtsGuardInterval18: return "MpegtsGuardInterval18"
+		case MpegtsGuardInterval1128: return "MpegtsGuardInterval1128"
+		case MpegtsGuardInterval19128: return "MpegtsGuardInterval19128"
+		case MpegtsGuardIntervalPn595: return "MpegtsGuardIntervalPn595"
+		case MpegtsGuardInterval132: return "MpegtsGuardInterval132"
+		case MpegtsGuardInterval116: return "MpegtsGuardInterval116"
+		case MpegtsGuardInterval14: return "MpegtsGuardInterval14"
+		case MpegtsGuardIntervalAuto: return "MpegtsGuardIntervalAuto"
+		case MpegtsGuardInterval19256: return "MpegtsGuardInterval19256"
+		case MpegtsGuardIntervalPn420: return "MpegtsGuardIntervalPn420"
+		default: return fmt.Sprintf("TerrestrialGuardInterval(%d)", e)
+	}
+}
+
 // TerrestrialHierarchy wraps GstMpegtsTerrestrialHierarchy
 type TerrestrialHierarchy C.int
 
@@ -1907,6 +2652,17 @@ const (
 )
 
 
+func (e TerrestrialHierarchy) String() string {
+	switch e {
+		case MpegtsHierarchyNone: return "MpegtsHierarchyNone"
+		case MpegtsHierarchy1: return "MpegtsHierarchy1"
+		case MpegtsHierarchy2: return "MpegtsHierarchy2"
+		case MpegtsHierarchy4: return "MpegtsHierarchy4"
+		case MpegtsHierarchyAuto: return "MpegtsHierarchyAuto"
+		default: return fmt.Sprintf("TerrestrialHierarchy(%d)", e)
+	}
+}
+
 // TerrestrialTransmissionMode wraps GstMpegtsTerrestrialTransmissionMode
 type TerrestrialTransmissionMode C.int
 
@@ -1932,6 +2688,21 @@ const (
 )
 
 
+func (e TerrestrialTransmissionMode) String() string {
+	switch e {
+		case MpegtsTransmissionMode16K: return "MpegtsTransmissionMode16K"
+		case MpegtsTransmissionModeC3780: return "MpegtsTransmissionModeC3780"
+		case MpegtsTransmissionMode8K: return "MpegtsTransmissionMode8K"
+		case MpegtsTransmissionModeAuto: return "MpegtsTransmissionModeAuto"
+		case MpegtsTransmissionMode4K: return "MpegtsTransmissionMode4K"
+		case MpegtsTransmissionMode32K: return "MpegtsTransmissionMode32K"
+		case MpegtsTransmissionModeC1: return "MpegtsTransmissionModeC1"
+		case MpegtsTransmissionMode2K: return "MpegtsTransmissionMode2K"
+		case MpegtsTransmissionMode1K: return "MpegtsTransmissionMode1K"
+		default: return fmt.Sprintf("TerrestrialTransmissionMode(%d)", e)
+	}
+}
+
 // RegistrationID wraps GstMpegtsRegistrationId
 //
 // Well-known registration ids, expressed as native-endian 32bit integers. These
@@ -2023,6 +2794,69 @@ func (r RegistrationID) Has(other RegistrationID) bool {
 	return (r & other) == other
 }
 
+func (f RegistrationID) String() string {
+	if f == 0 {
+		return "RegistrationID(0)"
+	}
+
+	var parts []string
+	if (f & MtsRegistration0) != 0 {
+		parts = append(parts, "MtsRegistration0")
+	}
+	if (f & MtsRegistrationAc3) != 0 {
+		parts = append(parts, "MtsRegistrationAc3")
+	}
+	if (f & MtsRegistrationCuei) != 0 {
+		parts = append(parts, "MtsRegistrationCuei")
+	}
+	if (f & MtsRegistrationDrac) != 0 {
+		parts = append(parts, "MtsRegistrationDrac")
+	}
+	if (f & MtsRegistrationDts1) != 0 {
+		parts = append(parts, "MtsRegistrationDts1")
+	}
+	if (f & MtsRegistrationDts2) != 0 {
+		parts = append(parts, "MtsRegistrationDts2")
+	}
+	if (f & MtsRegistrationDts3) != 0 {
+		parts = append(parts, "MtsRegistrationDts3")
+	}
+	if (f & MtsRegistrationBssd) != 0 {
+		parts = append(parts, "MtsRegistrationBssd")
+	}
+	if (f & MtsRegistrationEac3) != 0 {
+		parts = append(parts, "MtsRegistrationEac3")
+	}
+	if (f & MtsRegistrationEtv1) != 0 {
+		parts = append(parts, "MtsRegistrationEtv1")
+	}
+	if (f & MtsRegistrationGa94) != 0 {
+		parts = append(parts, "MtsRegistrationGa94")
+	}
+	if (f & MtsRegistrationHdmv) != 0 {
+		parts = append(parts, "MtsRegistrationHdmv")
+	}
+	if (f & MtsRegistrationKlva) != 0 {
+		parts = append(parts, "MtsRegistrationKlva")
+	}
+	if (f & MtsRegistrationOpus) != 0 {
+		parts = append(parts, "MtsRegistrationOpus")
+	}
+	if (f & MtsRegistrationTshv) != 0 {
+		parts = append(parts, "MtsRegistrationTshv")
+	}
+	if (f & MtsRegistrationVc1) != 0 {
+		parts = append(parts, "MtsRegistrationVc1")
+	}
+	if (f & MtsRegistrationAc4) != 0 {
+		parts = append(parts, "MtsRegistrationAc4")
+	}
+	if (f & MtsRegistrationOtherHevc) != 0 {
+		parts = append(parts, "MtsRegistrationOtherHevc")
+	}
+	return "RegistrationID(" + strings.Join(parts, "|") + ")"
+}
+
 // BufferAddMpegtsPesMetadataMeta wraps gst_buffer_add_mpegts_pes_metadata_meta
 // 
 // The function takes the following parameters:
diff --git a/pkg/gstnet/gstnet.gen.go b/pkg/gstnet/gstnet.gen.go
index fef79c1..bb97c2e 100644
--- a/pkg/gstnet/gstnet.gen.go
+++ b/pkg/gstnet/gstnet.gen.go
@@ -507,7 +507,7 @@ func UnsafeNetClientClockToGlibFull(c NetClientClock) unsafe.Pointer {
 	return gobject.UnsafeObjectToGlibFull(c)
 }
 
-// NewNetClientClockInstance wraps gst_net_client_clock_new
+// NewNetClientClock wraps gst_net_client_clock_new
 // 
 // The function takes the following parameters:
 // 
@@ -523,7 +523,7 @@ func UnsafeNetClientClockToGlibFull(c NetClientClock) unsafe.Pointer {
 // Create a new #GstNetClientClock that will report the time
 // provided by the #GstNetTimeProvider on @remote_address and
 // @remote_port.
-func NewNetClientClockInstance(name string, remoteAddress string, remotePort int, baseTime gst.ClockTime) gst.Clock {
+func NewNetClientClock(name string, remoteAddress string, remotePort int, baseTime gst.ClockTime) gst.Clock {
 	var carg1 *C.gchar       // in, none, string, nullable-string
 	var carg2 *C.gchar       // in, none, string, casted *C.gchar
 	var carg3 C.gint         // in, none, casted
@@ -620,7 +620,7 @@ func UnsafeNetTimeProviderToGlibFull(c NetTimeProvider) unsafe.Pointer {
 	return gobject.UnsafeObjectToGlibFull(c)
 }
 
-// NewNetTimeProviderInstance wraps gst_net_time_provider_new
+// NewNetTimeProvider wraps gst_net_time_provider_new
 // 
 // The function takes the following parameters:
 // 
@@ -634,7 +634,7 @@ func UnsafeNetTimeProviderToGlibFull(c NetTimeProvider) unsafe.Pointer {
 // 	- goret NetTimeProvider 
 //
 // Allows network clients to get the current time of @clock.
-func NewNetTimeProviderInstance(clock gst.Clock, address string, port int) NetTimeProvider {
+func NewNetTimeProvider(clock gst.Clock, address string, port int) NetTimeProvider {
 	var carg1 *C.GstClock           // in, none, converted
 	var carg2 *C.gchar              // in, none, string, nullable-string
 	var carg3 C.gint                // in, none, casted
@@ -717,7 +717,7 @@ func UnsafeNtpClockToGlibFull(c NtpClock) unsafe.Pointer {
 	return gobject.UnsafeObjectToGlibFull(c)
 }
 
-// NewNtpClockInstance wraps gst_ntp_clock_new
+// NewNtpClock wraps gst_ntp_clock_new
 // 
 // The function takes the following parameters:
 // 
@@ -732,7 +732,7 @@ func UnsafeNtpClockToGlibFull(c NtpClock) unsafe.Pointer {
 //
 // Create a new #GstNtpClock that will report the time provided by
 // the NTPv4 server on @remote_address and @remote_port.
-func NewNtpClockInstance(name string, remoteAddress string, remotePort int, baseTime gst.ClockTime) gst.Clock {
+func NewNtpClock(name string, remoteAddress string, remotePort int, baseTime gst.ClockTime) gst.Clock {
 	var carg1 *C.gchar       // in, none, string, nullable-string
 	var carg2 *C.gchar       // in, none, string, casted *C.gchar
 	var carg3 C.gint         // in, none, casted
@@ -839,7 +839,7 @@ func UnsafePtpClockToGlibFull(c PtpClock) unsafe.Pointer {
 	return gobject.UnsafeObjectToGlibFull(c)
 }
 
-// NewPtpClockInstance wraps gst_ptp_clock_new
+// NewPtpClock wraps gst_ptp_clock_new
 // 
 // The function takes the following parameters:
 // 
@@ -861,7 +861,7 @@ func UnsafePtpClockToGlibFull(c PtpClock) unsafe.Pointer {
 // GstPtpClock::internal-clock property will become non-NULL. You can
 // check this with gst_clock_wait_for_sync(), the GstClock::synced signal and
 // gst_clock_is_synced().
-func NewPtpClockInstance(name string, domain uint) gst.Clock {
+func NewPtpClock(name string, domain uint) gst.Clock {
 	var carg1 *C.gchar    // in, none, string, casted *C.gchar
 	var carg2 C.guint     // in, none, casted
 	var cret  *C.GstClock // return, full, converted
diff --git a/pkg/gstpbutils/gstpbutils.gen.go b/pkg/gstpbutils/gstpbutils.gen.go
index a7f452e..3823aa7 100644
--- a/pkg/gstpbutils/gstpbutils.gen.go
+++ b/pkg/gstpbutils/gstpbutils.gen.go
@@ -3,7 +3,9 @@
 package gstpbutils
 
 import (
+	"fmt"
 	"runtime"
+	"strings"
 	"unsafe"
 
 	"github.com/diamondburned/gotk4/pkg/core/userdata"
@@ -141,6 +143,22 @@ func (e AudioVisualizerShader) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e AudioVisualizerShader) String() string {
+	switch e {
+		case AudioVisualizerShaderFade: return "AudioVisualizerShaderFade"
+		case AudioVisualizerShaderFadeAndMoveUp: return "AudioVisualizerShaderFadeAndMoveUp"
+		case AudioVisualizerShaderFadeAndMoveDown: return "AudioVisualizerShaderFadeAndMoveDown"
+		case AudioVisualizerShaderFadeAndMoveLeft: return "AudioVisualizerShaderFadeAndMoveLeft"
+		case AudioVisualizerShaderFadeAndMoveHorizIn: return "AudioVisualizerShaderFadeAndMoveHorizIn"
+		case AudioVisualizerShaderFadeAndMoveVertIn: return "AudioVisualizerShaderFadeAndMoveVertIn"
+		case AudioVisualizerShaderNone: return "AudioVisualizerShaderNone"
+		case AudioVisualizerShaderFadeAndMoveRight: return "AudioVisualizerShaderFadeAndMoveRight"
+		case AudioVisualizerShaderFadeAndMoveHorizOut: return "AudioVisualizerShaderFadeAndMoveHorizOut"
+		case AudioVisualizerShaderFadeAndMoveVertOut: return "AudioVisualizerShaderFadeAndMoveVertOut"
+		default: return fmt.Sprintf("AudioVisualizerShader(%d)", e)
+	}
+}
+
 // DiscovererResult wraps GstDiscovererResult
 //
 // Result values for the discovery process.
@@ -184,6 +202,18 @@ func (e DiscovererResult) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e DiscovererResult) String() string {
+	switch e {
+		case DiscovererOK: return "DiscovererOK"
+		case DiscovererURIInvalid: return "DiscovererURIInvalid"
+		case DiscovererError: return "DiscovererError"
+		case DiscovererTimeout: return "DiscovererTimeout"
+		case DiscovererBusy: return "DiscovererBusy"
+		case DiscovererMissingPlugins: return "DiscovererMissingPlugins"
+		default: return fmt.Sprintf("DiscovererResult(%d)", e)
+	}
+}
+
 // InstallPluginsReturn wraps GstInstallPluginsReturn
 //
 // Result codes returned by gst_install_plugins_async() and
@@ -265,6 +295,23 @@ func (e InstallPluginsReturn) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e InstallPluginsReturn) String() string {
+	switch e {
+		case InstallPluginsInvalid: return "InstallPluginsInvalid"
+		case InstallPluginsSuccess: return "InstallPluginsSuccess"
+		case InstallPluginsCrashed: return "InstallPluginsCrashed"
+		case InstallPluginsStartedOK: return "InstallPluginsStartedOK"
+		case InstallPluginsInternalFailure: return "InstallPluginsInternalFailure"
+		case InstallPluginsHelperMissing: return "InstallPluginsHelperMissing"
+		case InstallPluginsInstallInProgress: return "InstallPluginsInstallInProgress"
+		case InstallPluginsNotFound: return "InstallPluginsNotFound"
+		case InstallPluginsError: return "InstallPluginsError"
+		case InstallPluginsPartialSuccess: return "InstallPluginsPartialSuccess"
+		case InstallPluginsUserAbort: return "InstallPluginsUserAbort"
+		default: return fmt.Sprintf("InstallPluginsReturn(%d)", e)
+	}
+}
+
 // DiscovererSerializeFlags wraps GstDiscovererSerializeFlags
 //
 // You can use these flags to control what is serialized by
@@ -311,6 +358,30 @@ func (f DiscovererSerializeFlags) InitGoValue(v *gobject.Value) {
 	v.SetFlags(int(f))
 }
 
+func (f DiscovererSerializeFlags) String() string {
+	if f == 0 {
+		return "DiscovererSerializeFlags(0)"
+	}
+
+	var parts []string
+	if (f & DiscovererSerializeBasic) != 0 {
+		parts = append(parts, "DiscovererSerializeBasic")
+	}
+	if (f & DiscovererSerializeCaps) != 0 {
+		parts = append(parts, "DiscovererSerializeCaps")
+	}
+	if (f & DiscovererSerializeTags) != 0 {
+		parts = append(parts, "DiscovererSerializeTags")
+	}
+	if (f & DiscovererSerializeMisc) != 0 {
+		parts = append(parts, "DiscovererSerializeMisc")
+	}
+	if (f & DiscovererSerializeAll) != 0 {
+		parts = append(parts, "DiscovererSerializeAll")
+	}
+	return "DiscovererSerializeFlags(" + strings.Join(parts, "|") + ")"
+}
+
 // PbUtilsCapsDescriptionFlags wraps GstPbUtilsCapsDescriptionFlags
 //
 // Flags that are returned by gst_pb_utils_get_caps_description_flags() and
@@ -373,6 +444,39 @@ func (f PbUtilsCapsDescriptionFlags) InitGoValue(v *gobject.Value) {
 	v.SetFlags(int(f))
 }
 
+func (f PbUtilsCapsDescriptionFlags) String() string {
+	if f == 0 {
+		return "PbUtilsCapsDescriptionFlags(0)"
+	}
+
+	var parts []string
+	if (f & PbutilsCapsDescriptionFlagContainer) != 0 {
+		parts = append(parts, "PbutilsCapsDescriptionFlagContainer")
+	}
+	if (f & PbutilsCapsDescriptionFlagAudio) != 0 {
+		parts = append(parts, "PbutilsCapsDescriptionFlagAudio")
+	}
+	if (f & PbutilsCapsDescriptionFlagVideo) != 0 {
+		parts = append(parts, "PbutilsCapsDescriptionFlagVideo")
+	}
+	if (f & PbutilsCapsDescriptionFlagImage) != 0 {
+		parts = append(parts, "PbutilsCapsDescriptionFlagImage")
+	}
+	if (f & PbutilsCapsDescriptionFlagSubtitle) != 0 {
+		parts = append(parts, "PbutilsCapsDescriptionFlagSubtitle")
+	}
+	if (f & PbutilsCapsDescriptionFlagTag) != 0 {
+		parts = append(parts, "PbutilsCapsDescriptionFlagTag")
+	}
+	if (f & PbutilsCapsDescriptionFlagGeneric) != 0 {
+		parts = append(parts, "PbutilsCapsDescriptionFlagGeneric")
+	}
+	if (f & PbutilsCapsDescriptionFlagMetadata) != 0 {
+		parts = append(parts, "PbutilsCapsDescriptionFlagMetadata")
+	}
+	return "PbUtilsCapsDescriptionFlags(" + strings.Join(parts, "|") + ")"
+}
+
 // InstallPluginsResultFunc wraps GstInstallPluginsResultFunc
 //
 // The prototype of the callback function that will be called once the
@@ -2343,7 +2447,7 @@ func UnsafeDiscovererToGlibFull(c Discoverer) unsafe.Pointer {
 	return gobject.UnsafeObjectToGlibFull(c)
 }
 
-// NewDiscovererInstance wraps gst_discoverer_new
+// NewDiscoverer wraps gst_discoverer_new
 // 
 // The function takes the following parameters:
 // 
@@ -2356,7 +2460,7 @@ func UnsafeDiscovererToGlibFull(c Discoverer) unsafe.Pointer {
 // 	- _goerr error (nullable): an error 
 //
 // Creates a new #GstDiscoverer with the provided timeout.
-func NewDiscovererInstance(timeout gst.ClockTime) (Discoverer, error) {
+func NewDiscoverer(timeout gst.ClockTime) (Discoverer, error) {
 	var carg1 C.GstClockTime   // in, none, casted, alias
 	var cret  *C.GstDiscoverer // return, full, converted
 	var _cerr *C.GError        // out, full, converted, nullable
@@ -3805,7 +3909,7 @@ func UnsafeEncodingProfileToGlibFull(c EncodingProfile) unsafe.Pointer {
 	return gobject.UnsafeObjectToGlibFull(c)
 }
 
-// EncodingProfileInstanceFind wraps gst_encoding_profile_find
+// EncodingProfileFind wraps gst_encoding_profile_find
 // 
 // The function takes the following parameters:
 // 
@@ -3819,7 +3923,7 @@ func UnsafeEncodingProfileToGlibFull(c EncodingProfile) unsafe.Pointer {
 // 	- goret EncodingProfile 
 //
 // Find the #GstEncodingProfile with the specified name and category.
-func EncodingProfileInstanceFind(targetname string, profilename string, category string) EncodingProfile {
+func EncodingProfileFind(targetname string, profilename string, category string) EncodingProfile {
 	var carg1 *C.gchar              // in, none, string, casted *C.gchar
 	var carg2 *C.gchar              // in, none, string, nullable-string
 	var carg3 *C.gchar              // in, none, string, nullable-string
@@ -3848,7 +3952,7 @@ func EncodingProfileInstanceFind(targetname string, profilename string, category
 	return goret
 }
 
-// EncodingProfileInstanceFromDiscoverer wraps gst_encoding_profile_from_discoverer
+// EncodingProfileFromDiscoverer wraps gst_encoding_profile_from_discoverer
 // 
 // The function takes the following parameters:
 // 
@@ -3861,7 +3965,7 @@ func EncodingProfileInstanceFind(targetname string, profilename string, category
 // Creates a #GstEncodingProfile matching the formats from the given
 // #GstDiscovererInfo. Streams other than audio or video (eg,
 // subtitles), are currently ignored.
-func EncodingProfileInstanceFromDiscoverer(info DiscovererInfo) EncodingProfile {
+func EncodingProfileFromDiscoverer(info DiscovererInfo) EncodingProfile {
 	var carg1 *C.GstDiscovererInfo  // in, none, converted
 	var cret  *C.GstEncodingProfile // return, full, converted
 
@@ -4603,7 +4707,7 @@ func UnsafeEncodingTargetToGlibFull(c EncodingTarget) unsafe.Pointer {
 	return gobject.UnsafeObjectToGlibFull(c)
 }
 
-// EncodingTargetInstanceLoad wraps gst_encoding_target_load
+// EncodingTargetLoad wraps gst_encoding_target_load
 // 
 // The function takes the following parameters:
 // 
@@ -4623,7 +4727,7 @@ func UnsafeEncodingTargetToGlibFull(c EncodingTarget) unsafe.Pointer {
 // 
 // If the category name is specified only targets from that category will be
 // searched for.
-func EncodingTargetInstanceLoad(name string, category string) (EncodingTarget, error) {
+func EncodingTargetLoad(name string, category string) (EncodingTarget, error) {
 	var carg1 *C.gchar             // in, none, string, casted *C.gchar
 	var carg2 *C.gchar             // in, none, string, nullable-string
 	var cret  *C.GstEncodingTarget // return, full, converted
@@ -4651,7 +4755,7 @@ func EncodingTargetInstanceLoad(name string, category string) (EncodingTarget, e
 	return goret, _goerr
 }
 
-// EncodingTargetInstanceLoadFromFile wraps gst_encoding_target_load_from_file
+// EncodingTargetLoadFromFile wraps gst_encoding_target_load_from_file
 // 
 // The function takes the following parameters:
 // 
@@ -4663,7 +4767,7 @@ func EncodingTargetInstanceLoad(name string, category string) (EncodingTarget, e
 // 	- _goerr error (nullable): an error 
 //
 // Opens the provided file and returns the contained #GstEncodingTarget.
-func EncodingTargetInstanceLoadFromFile(filepath string) (EncodingTarget, error) {
+func EncodingTargetLoadFromFile(filepath string) (EncodingTarget, error) {
 	var carg1 *C.gchar             // in, none, string, casted *C.gchar
 	var cret  *C.GstEncodingTarget // return, full, converted
 	var _cerr *C.GError            // out, full, converted, nullable
@@ -4989,7 +5093,7 @@ func UnsafeEncodingVideoProfileToGlibFull(c EncodingVideoProfile) unsafe.Pointer
 	return gobject.UnsafeObjectToGlibFull(c)
 }
 
-// NewEncodingVideoProfileInstance wraps gst_encoding_video_profile_new
+// NewEncodingVideoProfile wraps gst_encoding_video_profile_new
 // 
 // The function takes the following parameters:
 // 
@@ -5014,7 +5118,7 @@ func UnsafeEncodingVideoProfileToGlibFull(c EncodingVideoProfile) unsafe.Pointer
 // 
 // If you wish to use/force a constant framerate please refer to the
 // gst_encoding_video_profile_set_variableframerate() documentation.
-func NewEncodingVideoProfileInstance(format *gst.Caps, preset string, restriction *gst.Caps, presence uint) EncodingVideoProfile {
+func NewEncodingVideoProfile(format *gst.Caps, preset string, restriction *gst.Caps, presence uint) EncodingVideoProfile {
 	var carg1 *C.GstCaps                 // in, none, converted
 	var carg2 *C.gchar                   // in, none, string, nullable-string
 	var carg3 *C.GstCaps                 // in, none, converted, nullable
@@ -5494,7 +5598,7 @@ func UnsafeEncodingAudioProfileToGlibFull(c EncodingAudioProfile) unsafe.Pointer
 	return gobject.UnsafeObjectToGlibFull(c)
 }
 
-// NewEncodingAudioProfileInstance wraps gst_encoding_audio_profile_new
+// NewEncodingAudioProfile wraps gst_encoding_audio_profile_new
 // 
 // The function takes the following parameters:
 // 
@@ -5513,7 +5617,7 @@ func UnsafeEncodingAudioProfileToGlibFull(c EncodingAudioProfile) unsafe.Pointer
 // 
 // All provided allocatable arguments will be internally copied, so can be
 // safely freed/unreferenced after calling this method.
-func NewEncodingAudioProfileInstance(format *gst.Caps, preset string, restriction *gst.Caps, presence uint) EncodingAudioProfile {
+func NewEncodingAudioProfile(format *gst.Caps, preset string, restriction *gst.Caps, presence uint) EncodingAudioProfile {
 	var carg1 *C.GstCaps                 // in, none, converted
 	var carg2 *C.gchar                   // in, none, string, nullable-string
 	var carg3 *C.GstCaps                 // in, none, converted, nullable
@@ -5624,7 +5728,7 @@ func UnsafeEncodingContainerProfileToGlibFull(c EncodingContainerProfile) unsafe
 	return gobject.UnsafeObjectToGlibFull(c)
 }
 
-// NewEncodingContainerProfileInstance wraps gst_encoding_container_profile_new
+// NewEncodingContainerProfile wraps gst_encoding_container_profile_new
 // 
 // The function takes the following parameters:
 // 
@@ -5639,7 +5743,7 @@ func UnsafeEncodingContainerProfileToGlibFull(c EncodingContainerProfile) unsafe
 // 	- goret EncodingContainerProfile 
 //
 // Creates a new #GstEncodingContainerProfile.
-func NewEncodingContainerProfileInstance(name string, description string, format *gst.Caps, preset string) EncodingContainerProfile {
+func NewEncodingContainerProfile(name string, description string, format *gst.Caps, preset string) EncodingContainerProfile {
 	var carg1 *C.gchar                       // in, none, string, nullable-string
 	var carg2 *C.gchar                       // in, none, string, nullable-string
 	var carg3 *C.GstCaps                     // in, none, converted
diff --git a/pkg/gstplay/gstplay.gen.go b/pkg/gstplay/gstplay.gen.go
index a78ff47..13ec9ab 100644
--- a/pkg/gstplay/gstplay.gen.go
+++ b/pkg/gstplay/gstplay.gen.go
@@ -3,6 +3,7 @@
 package gstplay
 
 import (
+	"fmt"
 	"runtime"
 	"unsafe"
 
@@ -88,6 +89,16 @@ func (e PlayColorBalanceType) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e PlayColorBalanceType) String() string {
+	switch e {
+		case PlayColorBalanceHue: return "PlayColorBalanceHue"
+		case PlayColorBalanceBrightness: return "PlayColorBalanceBrightness"
+		case PlayColorBalanceSaturation: return "PlayColorBalanceSaturation"
+		case PlayColorBalanceContrast: return "PlayColorBalanceContrast"
+		default: return fmt.Sprintf("PlayColorBalanceType(%d)", e)
+	}
+}
+
 // PlayError wraps GstPlayError
 type PlayError C.int
 
@@ -109,6 +120,13 @@ func (e PlayError) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e PlayError) String() string {
+	switch e {
+		case PlayErrorFailed: return "PlayErrorFailed"
+		default: return fmt.Sprintf("PlayError(%d)", e)
+	}
+}
+
 // PlayMessage wraps GstPlayMessage
 type PlayMessage C.int
 
@@ -178,6 +196,25 @@ func (e PlayMessage) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e PlayMessage) String() string {
+	switch e {
+		case PlayMessageStateChanged: return "PlayMessageStateChanged"
+		case PlayMessageBuffering: return "PlayMessageBuffering"
+		case PlayMessageError: return "PlayMessageError"
+		case PlayMessageVideoDimensionsChanged: return "PlayMessageVideoDimensionsChanged"
+		case PlayMessageMuteChanged: return "PlayMessageMuteChanged"
+		case PlayMessageURILoaded: return "PlayMessageURILoaded"
+		case PlayMessageEndOfStream: return "PlayMessageEndOfStream"
+		case PlayMessageWarning: return "PlayMessageWarning"
+		case PlayMessageMediaInfoUpdated: return "PlayMessageMediaInfoUpdated"
+		case PlayMessageVolumeChanged: return "PlayMessageVolumeChanged"
+		case PlayMessageSeekDone: return "PlayMessageSeekDone"
+		case PlayMessagePositionUpdated: return "PlayMessagePositionUpdated"
+		case PlayMessageDurationChanged: return "PlayMessageDurationChanged"
+		default: return fmt.Sprintf("PlayMessage(%d)", e)
+	}
+}
+
 // PlaySnapshotFormat wraps GstPlaySnapshotFormat
 type PlaySnapshotFormat C.int
 
@@ -205,6 +242,17 @@ const (
 )
 
 
+func (e PlaySnapshotFormat) String() string {
+	switch e {
+		case PlayThumbnailRawNative: return "PlayThumbnailRawNative"
+		case PlayThumbnailRawXrgb: return "PlayThumbnailRawXrgb"
+		case PlayThumbnailRawBgrx: return "PlayThumbnailRawBgrx"
+		case PlayThumbnailJPG: return "PlayThumbnailJPG"
+		case PlayThumbnailPNG: return "PlayThumbnailPNG"
+		default: return fmt.Sprintf("PlaySnapshotFormat(%d)", e)
+	}
+}
+
 // PlayState wraps GstPlayState
 type PlayState C.int
 
@@ -239,6 +287,16 @@ func (e PlayState) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e PlayState) String() string {
+	switch e {
+		case PlayStateStopped: return "PlayStateStopped"
+		case PlayStateBuffering: return "PlayStateBuffering"
+		case PlayStatePaused: return "PlayStatePaused"
+		case PlayStatePlaying: return "PlayStatePlaying"
+		default: return fmt.Sprintf("PlayState(%d)", e)
+	}
+}
+
 // PlayVideoRendererInstance is the instance type used by all types implementing GstPlayVideoRenderer. It is used internally by the bindings. Users should use the interface [PlayVideoRenderer] instead.
 type PlayVideoRendererInstance struct {
 	_ [0]func() // equal guard
@@ -751,7 +809,7 @@ func UnsafePlayToGlibFull(c Play) unsafe.Pointer {
 	return gobject.UnsafeObjectToGlibFull(c)
 }
 
-// NewPlayInstance wraps gst_play_new
+// NewPlay wraps gst_play_new
 // 
 // The function takes the following parameters:
 // 
@@ -769,7 +827,7 @@ func UnsafePlayToGlibFull(c Play) unsafe.Pointer {
 // 
 // This also initializes GStreamer via `gst_init()` on the first call if this
 // didn't happen before.
-func NewPlayInstance(videoRenderer PlayVideoRenderer) Play {
+func NewPlay(videoRenderer PlayVideoRenderer) Play {
 	var carg1 *C.GstPlayVideoRenderer // in, full, converted, nullable
 	var cret  *C.GstPlay              // return, full, converted
 
@@ -787,7 +845,7 @@ func NewPlayInstance(videoRenderer PlayVideoRenderer) Play {
 	return goret
 }
 
-// PlayInstanceConfigGetPipelineDumpInErrorDetails wraps gst_play_config_get_pipeline_dump_in_error_details
+// PlayConfigGetPipelineDumpInErrorDetails wraps gst_play_config_get_pipeline_dump_in_error_details
 // 
 // The function takes the following parameters:
 // 
@@ -796,7 +854,7 @@ func NewPlayInstance(videoRenderer PlayVideoRenderer) Play {
 // The function returns the following values:
 // 
 // 	- goret bool 
-func PlayInstanceConfigGetPipelineDumpInErrorDetails(config *gst.Structure) bool {
+func PlayConfigGetPipelineDumpInErrorDetails(config *gst.Structure) bool {
 	var carg1 *C.GstStructure // in, none, converted
 	var cret  C.gboolean      // return
 
@@ -814,7 +872,7 @@ func PlayInstanceConfigGetPipelineDumpInErrorDetails(config *gst.Structure) bool
 	return goret
 }
 
-// PlayInstanceConfigGetPositionUpdateInterval wraps gst_play_config_get_position_update_interval
+// PlayConfigGetPositionUpdateInterval wraps gst_play_config_get_position_update_interval
 // 
 // The function takes the following parameters:
 // 
@@ -823,7 +881,7 @@ func PlayInstanceConfigGetPipelineDumpInErrorDetails(config *gst.Structure) bool
 // The function returns the following values:
 // 
 // 	- goret uint 
-func PlayInstanceConfigGetPositionUpdateInterval(config *gst.Structure) uint {
+func PlayConfigGetPositionUpdateInterval(config *gst.Structure) uint {
 	var carg1 *C.GstStructure // in, none, converted
 	var cret  C.guint         // return, none, casted
 
@@ -839,7 +897,7 @@ func PlayInstanceConfigGetPositionUpdateInterval(config *gst.Structure) uint {
 	return goret
 }
 
-// PlayInstanceConfigGetSeekAccurate wraps gst_play_config_get_seek_accurate
+// PlayConfigGetSeekAccurate wraps gst_play_config_get_seek_accurate
 // 
 // The function takes the following parameters:
 // 
@@ -848,7 +906,7 @@ func PlayInstanceConfigGetPositionUpdateInterval(config *gst.Structure) uint {
 // The function returns the following values:
 // 
 // 	- goret bool 
-func PlayInstanceConfigGetSeekAccurate(config *gst.Structure) bool {
+func PlayConfigGetSeekAccurate(config *gst.Structure) bool {
 	var carg1 *C.GstStructure // in, none, converted
 	var cret  C.gboolean      // return
 
@@ -866,7 +924,7 @@ func PlayInstanceConfigGetSeekAccurate(config *gst.Structure) bool {
 	return goret
 }
 
-// PlayInstanceConfigGetUserAgent wraps gst_play_config_get_user_agent
+// PlayConfigGetUserAgent wraps gst_play_config_get_user_agent
 // 
 // The function takes the following parameters:
 // 
@@ -878,7 +936,7 @@ func PlayInstanceConfigGetSeekAccurate(config *gst.Structure) bool {
 //
 // Return the user agent which has been configured using
 // gst_play_config_set_user_agent() if any.
-func PlayInstanceConfigGetUserAgent(config *gst.Structure) string {
+func PlayConfigGetUserAgent(config *gst.Structure) string {
 	var carg1 *C.GstStructure // in, none, converted
 	var cret  *C.gchar        // return, full, string, casted *C.gchar
 
@@ -895,7 +953,7 @@ func PlayInstanceConfigGetUserAgent(config *gst.Structure) string {
 	return goret
 }
 
-// PlayInstanceConfigSetPipelineDumpInErrorDetails wraps gst_play_config_set_pipeline_dump_in_error_details
+// PlayConfigSetPipelineDumpInErrorDetails wraps gst_play_config_set_pipeline_dump_in_error_details
 // 
 // The function takes the following parameters:
 // 
@@ -907,7 +965,7 @@ func PlayInstanceConfigGetUserAgent(config *gst.Structure) string {
 // name is `pipeline-dump`.
 // 
 // This option is disabled by default.
-func PlayInstanceConfigSetPipelineDumpInErrorDetails(config *gst.Structure, value bool) {
+func PlayConfigSetPipelineDumpInErrorDetails(config *gst.Structure, value bool) {
 	var carg1 *C.GstStructure // in, none, converted
 	var carg2 C.gboolean      // in
 
@@ -921,7 +979,7 @@ func PlayInstanceConfigSetPipelineDumpInErrorDetails(config *gst.Structure, valu
 	runtime.KeepAlive(value)
 }
 
-// PlayInstanceConfigSetPositionUpdateInterval wraps gst_play_config_set_position_update_interval
+// PlayConfigSetPositionUpdateInterval wraps gst_play_config_set_position_update_interval
 // 
 // The function takes the following parameters:
 // 
@@ -930,7 +988,7 @@ func PlayInstanceConfigSetPipelineDumpInErrorDetails(config *gst.Structure, valu
 //
 // Set desired interval in milliseconds between two position-updated messages.
 // Pass 0 to stop updating the position.
-func PlayInstanceConfigSetPositionUpdateInterval(config *gst.Structure, interval uint) {
+func PlayConfigSetPositionUpdateInterval(config *gst.Structure, interval uint) {
 	var carg1 *C.GstStructure // in, none, converted
 	var carg2 C.guint         // in, none, casted
 
@@ -942,7 +1000,7 @@ func PlayInstanceConfigSetPositionUpdateInterval(config *gst.Structure, interval
 	runtime.KeepAlive(interval)
 }
 
-// PlayInstanceConfigSetSeekAccurate wraps gst_play_config_set_seek_accurate
+// PlayConfigSetSeekAccurate wraps gst_play_config_set_seek_accurate
 // 
 // The function takes the following parameters:
 // 
@@ -958,7 +1016,7 @@ func PlayInstanceConfigSetPositionUpdateInterval(config *gst.Structure, interval
 // position without slowing down seeking too much.
 // 
 // Accurate seeking is disabled by default.
-func PlayInstanceConfigSetSeekAccurate(config *gst.Structure, accurate bool) {
+func PlayConfigSetSeekAccurate(config *gst.Structure, accurate bool) {
 	var carg1 *C.GstStructure // in, none, converted
 	var carg2 C.gboolean      // in
 
@@ -972,7 +1030,7 @@ func PlayInstanceConfigSetSeekAccurate(config *gst.Structure, accurate bool) {
 	runtime.KeepAlive(accurate)
 }
 
-// PlayInstanceConfigSetUserAgent wraps gst_play_config_set_user_agent
+// PlayConfigSetUserAgent wraps gst_play_config_set_user_agent
 // 
 // The function takes the following parameters:
 // 
@@ -982,7 +1040,7 @@ func PlayInstanceConfigSetSeekAccurate(config *gst.Structure, accurate bool) {
 // Set the user agent to pass to the server if @play needs to connect
 // to a server during playback. This is typically used when playing HTTP
 // or RTSP streams.
-func PlayInstanceConfigSetUserAgent(config *gst.Structure, agent string) {
+func PlayConfigSetUserAgent(config *gst.Structure, agent string) {
 	var carg1 *C.GstStructure // in, none, converted
 	var carg2 *C.gchar        // in, none, string, nullable-string
 
@@ -997,7 +1055,7 @@ func PlayInstanceConfigSetUserAgent(config *gst.Structure, agent string) {
 	runtime.KeepAlive(agent)
 }
 
-// PlayInstanceIsPlayMessage wraps gst_play_is_play_message
+// PlayIsPlayMessage wraps gst_play_is_play_message
 // 
 // The function takes the following parameters:
 // 
@@ -1006,7 +1064,7 @@ func PlayInstanceConfigSetUserAgent(config *gst.Structure, agent string) {
 // The function returns the following values:
 // 
 // 	- goret bool 
-func PlayInstanceIsPlayMessage(msg *gst.Message) bool {
+func PlayIsPlayMessage(msg *gst.Message) bool {
 	var carg1 *C.GstMessage // in, none, converted
 	var cret  C.gboolean    // return
 
@@ -2472,7 +2530,7 @@ func UnsafePlaySignalAdapterToGlibFull(c PlaySignalAdapter) unsafe.Pointer {
 	return gobject.UnsafeObjectToGlibFull(c)
 }
 
-// NewPlaySignalAdapterInstance wraps gst_play_signal_adapter_new
+// NewPlaySignalAdapter wraps gst_play_signal_adapter_new
 // 
 // The function takes the following parameters:
 // 
@@ -2486,7 +2544,7 @@ func UnsafePlaySignalAdapterToGlibFull(c PlaySignalAdapter) unsafe.Pointer {
 // thread-default #GMainContext. The attached callback will emit the
 // corresponding signal for the message received. Matching signals for play
 // messages from the bus will be emitted by it on the created adapter object.
-func NewPlaySignalAdapterInstance(play Play) PlaySignalAdapter {
+func NewPlaySignalAdapter(play Play) PlaySignalAdapter {
 	var carg1 *C.GstPlay              // in, none, converted
 	var cret  *C.GstPlaySignalAdapter // return, full, converted
 
@@ -2502,7 +2560,7 @@ func NewPlaySignalAdapterInstance(play Play) PlaySignalAdapter {
 	return goret
 }
 
-// NewPlaySignalAdapterInstanceSyncEmit wraps gst_play_signal_adapter_new_sync_emit
+// NewPlaySignalAdapterSyncEmit wraps gst_play_signal_adapter_new_sync_emit
 // 
 // The function takes the following parameters:
 // 
@@ -2514,7 +2572,7 @@ func NewPlaySignalAdapterInstance(play Play) PlaySignalAdapter {
 //
 // Create an adapter that synchronously emits its signals, from the thread in
 // which the messages have been posted.
-func NewPlaySignalAdapterInstanceSyncEmit(play Play) PlaySignalAdapter {
+func NewPlaySignalAdapterSyncEmit(play Play) PlaySignalAdapter {
 	var carg1 *C.GstPlay              // in, none, converted
 	var cret  *C.GstPlaySignalAdapter // return, full, converted
 
@@ -2530,7 +2588,7 @@ func NewPlaySignalAdapterInstanceSyncEmit(play Play) PlaySignalAdapter {
 	return goret
 }
 
-// NewPlaySignalAdapterInstanceWithMainContext wraps gst_play_signal_adapter_new_with_main_context
+// NewPlaySignalAdapterWithMainContext wraps gst_play_signal_adapter_new_with_main_context
 // 
 // The function takes the following parameters:
 // 
@@ -2545,7 +2603,7 @@ func NewPlaySignalAdapterInstanceSyncEmit(play Play) PlaySignalAdapter {
 // attached callback will emit the corresponding signal for the message
 // received. Matching signals for play messages from the bus will be emitted by
 // it on the created adapter object.
-func NewPlaySignalAdapterInstanceWithMainContext(play Play, context *glib.MainContext) PlaySignalAdapter {
+func NewPlaySignalAdapterWithMainContext(play Play, context *glib.MainContext) PlaySignalAdapter {
 	var carg1 *C.GstPlay              // in, none, converted
 	var carg2 *C.GMainContext         // in, none, converted
 	var cret  *C.GstPlaySignalAdapter // return, full, converted
@@ -3172,7 +3230,7 @@ func UnsafePlayVideoOverlayVideoRendererToGlibFull(c PlayVideoOverlayVideoRender
 	return gobject.UnsafeObjectToGlibFull(c)
 }
 
-// NewPlayVideoOverlayVideoRendererInstance wraps gst_play_video_overlay_video_renderer_new
+// NewPlayVideoOverlayVideoRenderer wraps gst_play_video_overlay_video_renderer_new
 // 
 // The function takes the following parameters:
 // 
@@ -3181,7 +3239,7 @@ func UnsafePlayVideoOverlayVideoRendererToGlibFull(c PlayVideoOverlayVideoRender
 // The function returns the following values:
 // 
 // 	- goret PlayVideoRenderer 
-func NewPlayVideoOverlayVideoRendererInstance(windowHandle unsafe.Pointer) PlayVideoRenderer {
+func NewPlayVideoOverlayVideoRenderer(windowHandle unsafe.Pointer) PlayVideoRenderer {
 	var carg1 C.gpointer              // in, none, casted, nullable
 	var cret  *C.GstPlayVideoRenderer // return, full, converted
 
@@ -3199,7 +3257,7 @@ func NewPlayVideoOverlayVideoRendererInstance(windowHandle unsafe.Pointer) PlayV
 	return goret
 }
 
-// NewPlayVideoOverlayVideoRendererInstanceWithSink wraps gst_play_video_overlay_video_renderer_new_with_sink
+// NewPlayVideoOverlayVideoRendererWithSink wraps gst_play_video_overlay_video_renderer_new_with_sink
 // 
 // The function takes the following parameters:
 // 
@@ -3209,7 +3267,7 @@ func NewPlayVideoOverlayVideoRendererInstance(windowHandle unsafe.Pointer) PlayV
 // The function returns the following values:
 // 
 // 	- goret PlayVideoRenderer 
-func NewPlayVideoOverlayVideoRendererInstanceWithSink(windowHandle unsafe.Pointer, videoSink gst.Element) PlayVideoRenderer {
+func NewPlayVideoOverlayVideoRendererWithSink(windowHandle unsafe.Pointer, videoSink gst.Element) PlayVideoRenderer {
 	var carg1 C.gpointer              // in, none, casted, nullable
 	var carg2 *C.GstElement           // in, none, converted
 	var cret  *C.GstPlayVideoRenderer // return, full, converted
diff --git a/pkg/gstplayer/gstplayer.gen.go b/pkg/gstplayer/gstplayer.gen.go
index 917b8a5..58820d2 100644
--- a/pkg/gstplayer/gstplayer.gen.go
+++ b/pkg/gstplayer/gstplayer.gen.go
@@ -3,6 +3,7 @@
 package gstplayer
 
 import (
+	"fmt"
 	"runtime"
 	"unsafe"
 
@@ -88,6 +89,16 @@ func (e PlayerColorBalanceType) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e PlayerColorBalanceType) String() string {
+	switch e {
+		case PlayerColorBalanceHue: return "PlayerColorBalanceHue"
+		case PlayerColorBalanceBrightness: return "PlayerColorBalanceBrightness"
+		case PlayerColorBalanceSaturation: return "PlayerColorBalanceSaturation"
+		case PlayerColorBalanceContrast: return "PlayerColorBalanceContrast"
+		default: return fmt.Sprintf("PlayerColorBalanceType(%d)", e)
+	}
+}
+
 // PlayerError wraps GstPlayerError
 type PlayerError C.int
 
@@ -109,6 +120,13 @@ func (e PlayerError) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e PlayerError) String() string {
+	switch e {
+		case PlayerErrorFailed: return "PlayerErrorFailed"
+		default: return fmt.Sprintf("PlayerError(%d)", e)
+	}
+}
+
 // PlayerSnapshotFormat wraps GstPlayerSnapshotFormat
 type PlayerSnapshotFormat C.int
 
@@ -126,6 +144,17 @@ const (
 )
 
 
+func (e PlayerSnapshotFormat) String() string {
+	switch e {
+		case PlayerThumbnailRawNative: return "PlayerThumbnailRawNative"
+		case PlayerThumbnailRawXrgb: return "PlayerThumbnailRawXrgb"
+		case PlayerThumbnailRawBgrx: return "PlayerThumbnailRawBgrx"
+		case PlayerThumbnailJPG: return "PlayerThumbnailJPG"
+		case PlayerThumbnailPNG: return "PlayerThumbnailPNG"
+		default: return fmt.Sprintf("PlayerSnapshotFormat(%d)", e)
+	}
+}
+
 // PlayerState wraps GstPlayerState
 type PlayerState C.int
 
@@ -160,6 +189,16 @@ func (e PlayerState) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e PlayerState) String() string {
+	switch e {
+		case PlayerStateBuffering: return "PlayerStateBuffering"
+		case PlayerStatePaused: return "PlayerStatePaused"
+		case PlayerStatePlaying: return "PlayerStatePlaying"
+		case PlayerStateStopped: return "PlayerStateStopped"
+		default: return fmt.Sprintf("PlayerState(%d)", e)
+	}
+}
+
 // PlayerSignalDispatcherInstance is the instance type used by all types implementing GstPlayerSignalDispatcher. It is used internally by the bindings. Users should use the interface [PlayerSignalDispatcher] instead.
 type PlayerSignalDispatcherInstance struct {
 	_ [0]func() // equal guard
@@ -678,7 +717,7 @@ func UnsafePlayerToGlibFull(c Player) unsafe.Pointer {
 	return gobject.UnsafeObjectToGlibFull(c)
 }
 
-// NewPlayerInstance wraps gst_player_new
+// NewPlayer wraps gst_player_new
 // 
 // The function takes the following parameters:
 // 
@@ -699,7 +738,7 @@ func UnsafePlayerToGlibFull(c Player) unsafe.Pointer {
 // 
 // This also initializes GStreamer via `gst_init()` on the first call if this
 // didn't happen before.
-func NewPlayerInstance(videoRenderer PlayerVideoRenderer, signalDispatcher PlayerSignalDispatcher) Player {
+func NewPlayer(videoRenderer PlayerVideoRenderer, signalDispatcher PlayerSignalDispatcher) Player {
 	var carg1 *C.GstPlayerVideoRenderer    // in, full, converted, nullable
 	var carg2 *C.GstPlayerSignalDispatcher // in, full, converted, nullable
 	var cret  *C.GstPlayer                 // return, full, converted
@@ -722,7 +761,7 @@ func NewPlayerInstance(videoRenderer PlayerVideoRenderer, signalDispatcher Playe
 	return goret
 }
 
-// PlayerInstanceConfigGetPositionUpdateInterval wraps gst_player_config_get_position_update_interval
+// PlayerConfigGetPositionUpdateInterval wraps gst_player_config_get_position_update_interval
 // 
 // The function takes the following parameters:
 // 
@@ -731,7 +770,7 @@ func NewPlayerInstance(videoRenderer PlayerVideoRenderer, signalDispatcher Playe
 // The function returns the following values:
 // 
 // 	- goret uint 
-func PlayerInstanceConfigGetPositionUpdateInterval(config *gst.Structure) uint {
+func PlayerConfigGetPositionUpdateInterval(config *gst.Structure) uint {
 	var carg1 *C.GstStructure // in, none, converted
 	var cret  C.guint         // return, none, casted
 
@@ -747,7 +786,7 @@ func PlayerInstanceConfigGetPositionUpdateInterval(config *gst.Structure) uint {
 	return goret
 }
 
-// PlayerInstanceConfigGetSeekAccurate wraps gst_player_config_get_seek_accurate
+// PlayerConfigGetSeekAccurate wraps gst_player_config_get_seek_accurate
 // 
 // The function takes the following parameters:
 // 
@@ -756,7 +795,7 @@ func PlayerInstanceConfigGetPositionUpdateInterval(config *gst.Structure) uint {
 // The function returns the following values:
 // 
 // 	- goret bool 
-func PlayerInstanceConfigGetSeekAccurate(config *gst.Structure) bool {
+func PlayerConfigGetSeekAccurate(config *gst.Structure) bool {
 	var carg1 *C.GstStructure // in, none, converted
 	var cret  C.gboolean      // return
 
@@ -774,7 +813,7 @@ func PlayerInstanceConfigGetSeekAccurate(config *gst.Structure) bool {
 	return goret
 }
 
-// PlayerInstanceConfigGetUserAgent wraps gst_player_config_get_user_agent
+// PlayerConfigGetUserAgent wraps gst_player_config_get_user_agent
 // 
 // The function takes the following parameters:
 // 
@@ -786,7 +825,7 @@ func PlayerInstanceConfigGetSeekAccurate(config *gst.Structure) bool {
 //
 // Return the user agent which has been configured using
 // gst_player_config_set_user_agent() if any.
-func PlayerInstanceConfigGetUserAgent(config *gst.Structure) string {
+func PlayerConfigGetUserAgent(config *gst.Structure) string {
 	var carg1 *C.GstStructure // in, none, converted
 	var cret  *C.gchar        // return, full, string, casted *C.gchar
 
@@ -803,7 +842,7 @@ func PlayerInstanceConfigGetUserAgent(config *gst.Structure) string {
 	return goret
 }
 
-// PlayerInstanceConfigSetPositionUpdateInterval wraps gst_player_config_set_position_update_interval
+// PlayerConfigSetPositionUpdateInterval wraps gst_player_config_set_position_update_interval
 // 
 // The function takes the following parameters:
 // 
@@ -812,7 +851,7 @@ func PlayerInstanceConfigGetUserAgent(config *gst.Structure) string {
 //
 // set interval in milliseconds between two position-updated signals.
 // pass 0 to stop updating the position.
-func PlayerInstanceConfigSetPositionUpdateInterval(config *gst.Structure, interval uint) {
+func PlayerConfigSetPositionUpdateInterval(config *gst.Structure, interval uint) {
 	var carg1 *C.GstStructure // in, none, converted
 	var carg2 C.guint         // in, none, casted
 
@@ -824,7 +863,7 @@ func PlayerInstanceConfigSetPositionUpdateInterval(config *gst.Structure, interv
 	runtime.KeepAlive(interval)
 }
 
-// PlayerInstanceConfigSetSeekAccurate wraps gst_player_config_set_seek_accurate
+// PlayerConfigSetSeekAccurate wraps gst_player_config_set_seek_accurate
 // 
 // The function takes the following parameters:
 // 
@@ -840,7 +879,7 @@ func PlayerInstanceConfigSetPositionUpdateInterval(config *gst.Structure, interv
 // position without slowing down seeking too much.
 // 
 // Accurate seeking is disabled by default.
-func PlayerInstanceConfigSetSeekAccurate(config *gst.Structure, accurate bool) {
+func PlayerConfigSetSeekAccurate(config *gst.Structure, accurate bool) {
 	var carg1 *C.GstStructure // in, none, converted
 	var carg2 C.gboolean      // in
 
@@ -854,7 +893,7 @@ func PlayerInstanceConfigSetSeekAccurate(config *gst.Structure, accurate bool) {
 	runtime.KeepAlive(accurate)
 }
 
-// PlayerInstanceConfigSetUserAgent wraps gst_player_config_set_user_agent
+// PlayerConfigSetUserAgent wraps gst_player_config_set_user_agent
 // 
 // The function takes the following parameters:
 // 
@@ -864,7 +903,7 @@ func PlayerInstanceConfigSetSeekAccurate(config *gst.Structure, accurate bool) {
 // Set the user agent to pass to the server if @player needs to connect
 // to a server during playback. This is typically used when playing HTTP
 // or RTSP streams.
-func PlayerInstanceConfigSetUserAgent(config *gst.Structure, agent string) {
+func PlayerConfigSetUserAgent(config *gst.Structure, agent string) {
 	var carg1 *C.GstStructure // in, none, converted
 	var carg2 *C.gchar        // in, none, string, nullable-string
 
@@ -1931,7 +1970,7 @@ func UnsafePlayerGMainContextSignalDispatcherToGlibFull(c PlayerGMainContextSign
 	return gobject.UnsafeObjectToGlibFull(c)
 }
 
-// NewPlayerGMainContextSignalDispatcherInstance wraps gst_player_g_main_context_signal_dispatcher_new
+// NewPlayerGMainContextSignalDispatcher wraps gst_player_g_main_context_signal_dispatcher_new
 // 
 // The function takes the following parameters:
 // 
@@ -1943,7 +1982,7 @@ func UnsafePlayerGMainContextSignalDispatcherToGlibFull(c PlayerGMainContextSign
 //
 // Creates a new GstPlayerSignalDispatcher that uses @application_context,
 // or the thread default one if %NULL is used. See gst_player_new().
-func NewPlayerGMainContextSignalDispatcherInstance(applicationContext *glib.MainContext) PlayerSignalDispatcher {
+func NewPlayerGMainContextSignalDispatcher(applicationContext *glib.MainContext) PlayerSignalDispatcher {
 	var carg1 *C.GMainContext              // in, none, converted, nullable
 	var cret  *C.GstPlayerSignalDispatcher // return, full, converted
 
@@ -2910,7 +2949,7 @@ func UnsafePlayerVideoOverlayVideoRendererToGlibFull(c PlayerVideoOverlayVideoRe
 	return gobject.UnsafeObjectToGlibFull(c)
 }
 
-// NewPlayerVideoOverlayVideoRendererInstance wraps gst_player_video_overlay_video_renderer_new
+// NewPlayerVideoOverlayVideoRenderer wraps gst_player_video_overlay_video_renderer_new
 // 
 // The function takes the following parameters:
 // 
@@ -2919,7 +2958,7 @@ func UnsafePlayerVideoOverlayVideoRendererToGlibFull(c PlayerVideoOverlayVideoRe
 // The function returns the following values:
 // 
 // 	- goret PlayerVideoRenderer 
-func NewPlayerVideoOverlayVideoRendererInstance(windowHandle unsafe.Pointer) PlayerVideoRenderer {
+func NewPlayerVideoOverlayVideoRenderer(windowHandle unsafe.Pointer) PlayerVideoRenderer {
 	var carg1 C.gpointer                // in, none, casted, nullable
 	var cret  *C.GstPlayerVideoRenderer // return, full, converted
 
@@ -2937,7 +2976,7 @@ func NewPlayerVideoOverlayVideoRendererInstance(windowHandle unsafe.Pointer) Pla
 	return goret
 }
 
-// NewPlayerVideoOverlayVideoRendererInstanceWithSink wraps gst_player_video_overlay_video_renderer_new_with_sink
+// NewPlayerVideoOverlayVideoRendererWithSink wraps gst_player_video_overlay_video_renderer_new_with_sink
 // 
 // The function takes the following parameters:
 // 
@@ -2947,7 +2986,7 @@ func NewPlayerVideoOverlayVideoRendererInstance(windowHandle unsafe.Pointer) Pla
 // The function returns the following values:
 // 
 // 	- goret PlayerVideoRenderer 
-func NewPlayerVideoOverlayVideoRendererInstanceWithSink(windowHandle unsafe.Pointer, videoSink gst.Element) PlayerVideoRenderer {
+func NewPlayerVideoOverlayVideoRendererWithSink(windowHandle unsafe.Pointer, videoSink gst.Element) PlayerVideoRenderer {
 	var carg1 C.gpointer                // in, none, casted, nullable
 	var carg2 *C.GstElement             // in, none, converted
 	var cret  *C.GstPlayerVideoRenderer // return, full, converted
diff --git a/pkg/gstrtp/gstrtp.gen.go b/pkg/gstrtp/gstrtp.gen.go
index 67b2d3c..fecb216 100644
--- a/pkg/gstrtp/gstrtp.gen.go
+++ b/pkg/gstrtp/gstrtp.gen.go
@@ -3,7 +3,9 @@
 package gstrtp
 
 import (
+	"fmt"
 	"runtime"
+	"strings"
 	"unsafe"
 
 	"github.com/diamondburned/gotk4/pkg/glib/v2"
@@ -181,6 +183,21 @@ func (e RTCPFBType) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e RTCPFBType) String() string {
+	switch e {
+		case RtcpPsfbTypeVbcn: return "RtcpPsfbTypeVbcn"
+		case RtcpFbTypeInvalid: return "RtcpFbTypeInvalid"
+		case RtcpRtpfbTypeNack: return "RtcpRtpfbTypeNack"
+		case RtcpRtpfbTypeTmmbr: return "RtcpRtpfbTypeTmmbr"
+		case RtcpRtpfbTypeTmmbn: return "RtcpRtpfbTypeTmmbn"
+		case RtcpRtpfbTypeRtcpSrReq: return "RtcpRtpfbTypeRtcpSrReq"
+		case RtcpRtpfbTypeTwcc: return "RtcpRtpfbTypeTwcc"
+		case RtcpPsfbTypeSli: return "RtcpPsfbTypeSli"
+		case RtcpPsfbTypeTstn: return "RtcpPsfbTypeTstn"
+		default: return fmt.Sprintf("RTCPFBType(%d)", e)
+	}
+}
+
 // RTCPSDESType wraps GstRTCPSDESType
 //
 // Different types of SDES content.
@@ -268,6 +285,29 @@ func (e RTCPSDESType) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e RTCPSDESType) String() string {
+	switch e {
+		case RtcpSdesName: return "RtcpSdesName"
+		case RtcpSdesLoc: return "RtcpSdesLoc"
+		case RtcpSdesH323Caddr: return "RtcpSdesH323Caddr"
+		case RtcpSdesApsi: return "RtcpSdesApsi"
+		case RtcpSdesInvalid: return "RtcpSdesInvalid"
+		case RtcpSdesEnd: return "RtcpSdesEnd"
+		case RtcpSdesCname: return "RtcpSdesCname"
+		case RtcpSdesPriv: return "RtcpSdesPriv"
+		case RtcpSdesRgrp: return "RtcpSdesRgrp"
+		case RtcpSdesRtpStreamID: return "RtcpSdesRtpStreamID"
+		case RtcpSdesRepairedRtpStreamID: return "RtcpSdesRepairedRtpStreamID"
+		case RtcpSdesCcid: return "RtcpSdesCcid"
+		case RtcpSdesEmail: return "RtcpSdesEmail"
+		case RtcpSdesPhone: return "RtcpSdesPhone"
+		case RtcpSdesTool: return "RtcpSdesTool"
+		case RtcpSdesNote: return "RtcpSdesNote"
+		case RtcpSdesMid: return "RtcpSdesMid"
+		default: return fmt.Sprintf("RTCPSDESType(%d)", e)
+	}
+}
+
 // RTCPType wraps GstRTCPType
 //
 // Different RTCP packet types.
@@ -323,6 +363,21 @@ func (e RTCPType) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e RTCPType) String() string {
+	switch e {
+		case RtcpTypeSr: return "RtcpTypeSr"
+		case RtcpTypeRr: return "RtcpTypeRr"
+		case RtcpTypeRtpfb: return "RtcpTypeRtpfb"
+		case RtcpTypeXR: return "RtcpTypeXR"
+		case RtcpTypeInvalid: return "RtcpTypeInvalid"
+		case RtcpTypeSdes: return "RtcpTypeSdes"
+		case RtcpTypeBye: return "RtcpTypeBye"
+		case RtcpTypeApp: return "RtcpTypeApp"
+		case RtcpTypePsfb: return "RtcpTypePsfb"
+		default: return fmt.Sprintf("RTCPType(%d)", e)
+	}
+}
+
 // RTCPXRType wraps GstRTCPXRType
 //
 // Types of RTCP Extended Reports, those are defined in RFC 3611 and other RFCs
@@ -375,6 +430,20 @@ func (e RTCPXRType) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e RTCPXRType) String() string {
+	switch e {
+		case RtcpXRTypeDlrr: return "RtcpXRTypeDlrr"
+		case RtcpXRTypeSsumm: return "RtcpXRTypeSsumm"
+		case RtcpXRTypeVoipMetrics: return "RtcpXRTypeVoipMetrics"
+		case RtcpXRTypeInvalid: return "RtcpXRTypeInvalid"
+		case RtcpXRTypeLrle: return "RtcpXRTypeLrle"
+		case RtcpXRTypeDrle: return "RtcpXRTypeDrle"
+		case RtcpXRTypePrt: return "RtcpXRTypePrt"
+		case RtcpXRTypeRrt: return "RtcpXRTypeRrt"
+		default: return fmt.Sprintf("RTCPXRType(%d)", e)
+	}
+}
+
 // RTPPayload wraps GstRTPPayload
 //
 // Standard predefined fixed payload types.
@@ -509,6 +578,38 @@ func (e RTPPayload) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e RTPPayload) String() string {
+	switch e {
+		case RtpPayloadMpa: return "RtpPayloadMpa"
+		case RtpPayloadG728: return "RtpPayloadG728"
+		case RtpPayloadG729: return "RtpPayloadG729"
+		case RtpPayloadH261: return "RtpPayloadH261"
+		case RtpPayloadMp2T: return "RtpPayloadMp2T"
+		case RtpPayloadG721: return "RtpPayloadG721"
+		case RtpPayloadGsm: return "RtpPayloadGsm"
+		case RtpPayloadG723: return "RtpPayloadG723"
+		case RtpPayloadH263: return "RtpPayloadH263"
+		case RtpPayloadG722: return "RtpPayloadG722"
+		case RtpPayloadCn: return "RtpPayloadCn"
+		case RtpPayloadDvi411025: return "RtpPayloadDvi411025"
+		case RtpPayloadCellb: return "RtpPayloadCellb"
+		case RtpPayloadJPEG: return "RtpPayloadJPEG"
+		case RtpPayloadMpv: return "RtpPayloadMpv"
+		case RtpPayloadPcmu: return "RtpPayloadPcmu"
+		case RtpPayload1016: return "RtpPayload1016"
+		case RtpPayloadDvi48000: return "RtpPayloadDvi48000"
+		case RtpPayloadPcma: return "RtpPayloadPcma"
+		case RtpPayloadL16Mono: return "RtpPayloadL16Mono"
+		case RtpPayloadQcelp: return "RtpPayloadQcelp"
+		case RtpPayloadDvi422050: return "RtpPayloadDvi422050"
+		case RtpPayloadNv: return "RtpPayloadNv"
+		case RtpPayloadDvi416000: return "RtpPayloadDvi416000"
+		case RtpPayloadLpc: return "RtpPayloadLpc"
+		case RtpPayloadL16Stereo: return "RtpPayloadL16Stereo"
+		default: return fmt.Sprintf("RTPPayload(%d)", e)
+	}
+}
+
 // RTPProfile wraps GstRTPProfile
 //
 // The transfer profile to use.
@@ -548,6 +649,17 @@ func (e RTPProfile) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e RTPProfile) String() string {
+	switch e {
+		case RtpProfileAvp: return "RtpProfileAvp"
+		case RtpProfileSavp: return "RtpProfileSavp"
+		case RtpProfileAvpf: return "RtpProfileAvpf"
+		case RtpProfileSavpf: return "RtpProfileSavpf"
+		case RtpProfileUnknown: return "RtpProfileUnknown"
+		default: return fmt.Sprintf("RTPProfile(%d)", e)
+	}
+}
+
 // RTPBufferFlags wraps GstRTPBufferFlags
 //
 // Additional RTP buffer flags. These flags can potentially be used on any
@@ -591,6 +703,24 @@ func (f RTPBufferFlags) InitGoValue(v *gobject.Value) {
 	v.SetFlags(int(f))
 }
 
+func (f RTPBufferFlags) String() string {
+	if f == 0 {
+		return "RTPBufferFlags(0)"
+	}
+
+	var parts []string
+	if (f & RtpBufferFlagRetransmission) != 0 {
+		parts = append(parts, "RtpBufferFlagRetransmission")
+	}
+	if (f & RtpBufferFlagRedundant) != 0 {
+		parts = append(parts, "RtpBufferFlagRedundant")
+	}
+	if (f & RtpBufferFlagLast) != 0 {
+		parts = append(parts, "RtpBufferFlagLast")
+	}
+	return "RTPBufferFlags(" + strings.Join(parts, "|") + ")"
+}
+
 // RTPBufferMapFlags wraps GstRTPBufferMapFlags
 //
 // Additional mapping flags for gst_rtp_buffer_map().
@@ -624,6 +754,21 @@ func (f RTPBufferMapFlags) InitGoValue(v *gobject.Value) {
 	v.SetFlags(int(f))
 }
 
+func (f RTPBufferMapFlags) String() string {
+	if f == 0 {
+		return "RTPBufferMapFlags(0)"
+	}
+
+	var parts []string
+	if (f & RtpBufferMapFlagSkipPadding) != 0 {
+		parts = append(parts, "RtpBufferMapFlagSkipPadding")
+	}
+	if (f & RtpBufferMapFlagLast) != 0 {
+		parts = append(parts, "RtpBufferMapFlagLast")
+	}
+	return "RTPBufferMapFlags(" + strings.Join(parts, "|") + ")"
+}
+
 // RTPHeaderExtensionDirection wraps GstRTPHeaderExtensionDirection
 //
 // Direction to which to apply the RTP Header Extension
@@ -670,6 +815,30 @@ func (f RTPHeaderExtensionDirection) InitGoValue(v *gobject.Value) {
 	v.SetFlags(int(f))
 }
 
+func (f RTPHeaderExtensionDirection) String() string {
+	if f == 0 {
+		return "RTPHeaderExtensionDirection(0)"
+	}
+
+	var parts []string
+	if (f & RtpHeaderExtensionDirectionInactive) != 0 {
+		parts = append(parts, "RtpHeaderExtensionDirectionInactive")
+	}
+	if (f & RtpHeaderExtensionDirectionSendonly) != 0 {
+		parts = append(parts, "RtpHeaderExtensionDirectionSendonly")
+	}
+	if (f & RtpHeaderExtensionDirectionRecvonly) != 0 {
+		parts = append(parts, "RtpHeaderExtensionDirectionRecvonly")
+	}
+	if (f & RtpHeaderExtensionDirectionSendrecv) != 0 {
+		parts = append(parts, "RtpHeaderExtensionDirectionSendrecv")
+	}
+	if (f & RtpHeaderExtensionDirectionInherited) != 0 {
+		parts = append(parts, "RtpHeaderExtensionDirectionInherited")
+	}
+	return "RTPHeaderExtensionDirection(" + strings.Join(parts, "|") + ")"
+}
+
 // RTPHeaderExtensionFlags wraps GstRTPHeaderExtensionFlags
 //
 // Flags that apply to a RTP Audio/Video header extension.
@@ -705,6 +874,21 @@ func (f RTPHeaderExtensionFlags) InitGoValue(v *gobject.Value) {
 	v.SetFlags(int(f))
 }
 
+func (f RTPHeaderExtensionFlags) String() string {
+	if f == 0 {
+		return "RTPHeaderExtensionFlags(0)"
+	}
+
+	var parts []string
+	if (f & RtpHeaderExtensionOneByte) != 0 {
+		parts = append(parts, "RtpHeaderExtensionOneByte")
+	}
+	if (f & RtpHeaderExtensionTwoByte) != 0 {
+		parts = append(parts, "RtpHeaderExtensionTwoByte")
+	}
+	return "RTPHeaderExtensionFlags(" + strings.Join(parts, "|") + ")"
+}
+
 // BufferAddRtpSourceMeta wraps gst_buffer_add_rtp_source_meta
 // 
 // The function takes the following parameters:
@@ -2146,7 +2330,7 @@ func UnsafeRTPHeaderExtensionToGlibFull(c RTPHeaderExtension) unsafe.Pointer {
 	return gobject.UnsafeObjectToGlibFull(c)
 }
 
-// RTPHeaderExtensionInstanceCreateFromURI wraps gst_rtp_header_extension_create_from_uri
+// RTPHeaderExtensionCreateFromURI wraps gst_rtp_header_extension_create_from_uri
 // 
 // The function takes the following parameters:
 // 
@@ -2155,7 +2339,7 @@ func UnsafeRTPHeaderExtensionToGlibFull(c RTPHeaderExtension) unsafe.Pointer {
 // The function returns the following values:
 // 
 // 	- goret RTPHeaderExtension 
-func RTPHeaderExtensionInstanceCreateFromURI(uri string) RTPHeaderExtension {
+func RTPHeaderExtensionCreateFromURI(uri string) RTPHeaderExtension {
 	var carg1 *C.gchar                 // in, none, string, casted *C.gchar
 	var cret  *C.GstRTPHeaderExtension // return, full, converted
 
diff --git a/pkg/gstrtsp/gstrtsp.gen.go b/pkg/gstrtsp/gstrtsp.gen.go
index b4196d0..c706668 100644
--- a/pkg/gstrtsp/gstrtsp.gen.go
+++ b/pkg/gstrtsp/gstrtsp.gen.go
@@ -3,7 +3,9 @@
 package gstrtsp
 
 import (
+	"fmt"
 	"runtime"
+	"strings"
 	"unsafe"
 
 	"github.com/diamondburned/gotk4/pkg/core/userdata"
@@ -105,6 +107,15 @@ func (e RTSPAuthMethod) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e RTSPAuthMethod) String() string {
+	switch e {
+		case RtspAuthNone: return "RtspAuthNone"
+		case RtspAuthBasic: return "RtspAuthBasic"
+		case RtspAuthDigest: return "RtspAuthDigest"
+		default: return fmt.Sprintf("RTSPAuthMethod(%d)", e)
+	}
+}
+
 // RTSPFamily wraps GstRTSPFamily
 //
 // The possible network families.
@@ -136,6 +147,15 @@ func (e RTSPFamily) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e RTSPFamily) String() string {
+	switch e {
+		case RtspFamNone: return "RtspFamNone"
+		case RtspFamInet: return "RtspFamInet"
+		case RtspFamInet6: return "RtspFamInet6"
+		default: return fmt.Sprintf("RTSPFamily(%d)", e)
+	}
+}
+
 // RTSPHeaderField wraps GstRTSPHeaderField
 //
 // Enumeration of rtsp header fields
@@ -335,6 +355,102 @@ func (e RTSPHeaderField) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e RTSPHeaderField) String() string {
+	switch e {
+		case RtspHdrRealChallenge2: return "RtspHdrRealChallenge2"
+		case RtspHdrRealChallenge1: return "RtspHdrRealChallenge1"
+		case RtspHdrXAccelerateStreaming: return "RtspHdrXAccelerateStreaming"
+		case RtspHdrXBurstStreaming: return "RtspHdrXBurstStreaming"
+		case RtspHdrPragma: return "RtspHdrPragma"
+		case RtspHdrLast: return "RtspHdrLast"
+		case RtspHdrAuthorization: return "RtspHdrAuthorization"
+		case RtspHdrBandwidth: return "RtspHdrBandwidth"
+		case RtspHdrRetryAfter: return "RtspHdrRetryAfter"
+		case RtspHdrSubscribe: return "RtspHdrSubscribe"
+		case RtspHdrLocation: return "RtspHdrLocation"
+		case RtspHdrIfMatch: return "RtspHdrIfMatch"
+		case RtspHdrRegionData: return "RtspHdrRegionData"
+		case RtspHdrXAcceptProxyAuthent: return "RtspHdrXAcceptProxyAuthent"
+		case RtspHdrInvalid: return "RtspHdrInvalid"
+		case RtspHdrContentLanguage: return "RtspHdrContentLanguage"
+		case RtspHdrScale: return "RtspHdrScale"
+		case RtspHdrTransport: return "RtspHdrTransport"
+		case RtspHdrUserAgent: return "RtspHdrUserAgent"
+		case RtspHdrGUID: return "RtspHdrGUID"
+		case RtspHdrXProxyClientVerb: return "RtspHdrXProxyClientVerb"
+		case RtspHdrHost: return "RtspHdrHost"
+		case RtspHdrCacheControl: return "RtspHdrCacheControl"
+		case RtspHdrPipelinedRequests: return "RtspHdrPipelinedRequests"
+		case RtspHdrContentLocation: return "RtspHdrContentLocation"
+		case RtspHdrAlert: return "RtspHdrAlert"
+		case RtspHdrLanguage: return "RtspHdrLanguage"
+		case RtspHdrSeekStyle: return "RtspHdrSeekStyle"
+		case RtspHdrExpires: return "RtspHdrExpires"
+		case RtspHdrSupported: return "RtspHdrSupported"
+		case RtspHdrMediaProperties: return "RtspHdrMediaProperties"
+		case RtspHdrWwwAuthenticate: return "RtspHdrWwwAuthenticate"
+		case RtspHdrXPlaylistSeekID: return "RtspHdrXPlaylistSeekID"
+		case RtspHdrXServerIPAddress: return "RtspHdrXServerIPAddress"
+		case RtspHdrContentType: return "RtspHdrContentType"
+		case RtspHdrRtpInfo: return "RtspHdrRtpInfo"
+		case RtspHdrSession: return "RtspHdrSession"
+		case RtspHdrMaxAsmWidth: return "RtspHdrMaxAsmWidth"
+		case RtspHdrXPlaylistGenID: return "RtspHdrXPlaylistGenID"
+		case RtspHdrXProxyClientAgent: return "RtspHdrXProxyClientAgent"
+		case RtspHdrXStartupprofile: return "RtspHdrXStartupprofile"
+		case RtspHdrAccept: return "RtspHdrAccept"
+		case RtspHdrRealChallenge3: return "RtspHdrRealChallenge3"
+		case RtspHdrAcceptCharset: return "RtspHdrAcceptCharset"
+		case RtspHdrXRecedingPlaylistchange: return "RtspHdrXRecedingPlaylistchange"
+		case RtspHdrXRtpInfo: return "RtspHdrXRtpInfo"
+		case RtspHdrAcceptRanges: return "RtspHdrAcceptRanges"
+		case RtspHdrContentEncoding: return "RtspHdrContentEncoding"
+		case RtspHdrFrom: return "RtspHdrFrom"
+		case RtspHdrIfModifiedSince: return "RtspHdrIfModifiedSince"
+		case RtspHdrPublic: return "RtspHdrPublic"
+		case RtspHdrUnsupported: return "RtspHdrUnsupported"
+		case RtspHdrVia: return "RtspHdrVia"
+		case RtspHdrETag: return "RtspHdrETag"
+		case RtspHdrCompanyID: return "RtspHdrCompanyID"
+		case RtspHdrAcceptEncoding: return "RtspHdrAcceptEncoding"
+		case RtspHdrClientID: return "RtspHdrClientID"
+		case RtspHdrPlayerStartTime: return "RtspHdrPlayerStartTime"
+		case RtspHdrVary: return "RtspHdrVary"
+		case RtspHdrXPlayerLagTime: return "RtspHdrXPlayerLagTime"
+		case RtspHdrAuthenticationInfo: return "RtspHdrAuthenticationInfo"
+		case RtspHdrXSessioncookie: return "RtspHdrXSessioncookie"
+		case RtspHdrKeymgmt: return "RtspHdrKeymgmt"
+		case RtspHdrSpeed: return "RtspHdrSpeed"
+		case RtspHdrClientChallenge: return "RtspHdrClientChallenge"
+		case RtspHdrTimestamp: return "RtspHdrTimestamp"
+		case RtspHdrFrames: return "RtspHdrFrames"
+		case RtspHdrBlocksize: return "RtspHdrBlocksize"
+		case RtspHdrProxyRequire: return "RtspHdrProxyRequire"
+		case RtspHdrXBroadcastID: return "RtspHdrXBroadcastID"
+		case RtspHdrXPlaylist: return "RtspHdrXPlaylist"
+		case RtspHdrAllow: return "RtspHdrAllow"
+		case RtspHdrConference: return "RtspHdrConference"
+		case RtspHdrConnection: return "RtspHdrConnection"
+		case RtspHdrContentBase: return "RtspHdrContentBase"
+		case RtspHdrContentLength: return "RtspHdrContentLength"
+		case RtspHdrLastModified: return "RtspHdrLastModified"
+		case RtspHdrReferer: return "RtspHdrReferer"
+		case RtspHdrXPlaylistChangeNotice: return "RtspHdrXPlaylistChangeNotice"
+		case RtspHdrCseq: return "RtspHdrCseq"
+		case RtspHdrRequire: return "RtspHdrRequire"
+		case RtspHdrXAcceptAuthent: return "RtspHdrXAcceptAuthent"
+		case RtspHdrXNotice: return "RtspHdrXNotice"
+		case RtspHdrRtcpInterval: return "RtspHdrRtcpInterval"
+		case RtspHdrRateControl: return "RtspHdrRateControl"
+		case RtspHdrAcceptLanguage: return "RtspHdrAcceptLanguage"
+		case RtspHdrDate: return "RtspHdrDate"
+		case RtspHdrProxyAuthenticate: return "RtspHdrProxyAuthenticate"
+		case RtspHdrRange: return "RtspHdrRange"
+		case RtspHdrServer: return "RtspHdrServer"
+		default: return fmt.Sprintf("RTSPHeaderField(%d)", e)
+	}
+}
+
 // RTSPMsgType wraps GstRTSPMsgType
 //
 // The type of a message.
@@ -378,6 +494,18 @@ func (e RTSPMsgType) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e RTSPMsgType) String() string {
+	switch e {
+		case RtspMessageHTTPRequest: return "RtspMessageHTTPRequest"
+		case RtspMessageHTTPResponse: return "RtspMessageHTTPResponse"
+		case RtspMessageData: return "RtspMessageData"
+		case RtspMessageInvalid: return "RtspMessageInvalid"
+		case RtspMessageRequest: return "RtspMessageRequest"
+		case RtspMessageResponse: return "RtspMessageResponse"
+		default: return fmt.Sprintf("RTSPMsgType(%d)", e)
+	}
+}
+
 // RTSPRangeUnit wraps GstRTSPRangeUnit
 //
 // Different possible time range units.
@@ -417,6 +545,17 @@ func (e RTSPRangeUnit) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e RTSPRangeUnit) String() string {
+	switch e {
+		case RtspRangeSmpte: return "RtspRangeSmpte"
+		case RtspRangeSmpte30Drop: return "RtspRangeSmpte30Drop"
+		case RtspRangeSmpte25: return "RtspRangeSmpte25"
+		case RtspRangeNpt: return "RtspRangeNpt"
+		case RtspRangeClock: return "RtspRangeClock"
+		default: return fmt.Sprintf("RTSPRangeUnit(%d)", e)
+	}
+}
+
 // RTSPResult wraps GstRTSPResult
 //
 // Result codes from the RTSP functions.
@@ -512,6 +651,31 @@ func (e RTSPResult) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e RTSPResult) String() string {
+	switch e {
+		case RtspEwsaversion: return "RtspEwsaversion"
+		case RtspOKRedirect: return "RtspOKRedirect"
+		case RtspError: return "RtspError"
+		case RtspEinval: return "RtspEinval"
+		case RtspEnomem: return "RtspEnomem"
+		case RtspEnotip: return "RtspEnotip"
+		case RtspOK: return "RtspOK"
+		case RtspEresolv: return "RtspEresolv"
+		case RtspEwsastart: return "RtspEwsastart"
+		case RtspEeof: return "RtspEeof"
+		case RtspEtpost: return "RtspEtpost"
+		case RtspEintr: return "RtspEintr"
+		case RtspEsys: return "RtspEsys"
+		case RtspEparse: return "RtspEparse"
+		case RtspEnet: return "RtspEnet"
+		case RtspEtimeout: return "RtspEtimeout"
+		case RtspEtget: return "RtspEtget"
+		case RtspElast: return "RtspElast"
+		case RtspEnotimpl: return "RtspEnotimpl"
+		default: return fmt.Sprintf("RTSPResult(%d)", e)
+	}
+}
+
 // RTSPState wraps GstRTSPState
 //
 // The different RTSP states.
@@ -555,6 +719,18 @@ func (e RTSPState) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e RTSPState) String() string {
+	switch e {
+		case RtspStateInvalid: return "RtspStateInvalid"
+		case RtspStateInit: return "RtspStateInit"
+		case RtspStateReady: return "RtspStateReady"
+		case RtspStateSeeking: return "RtspStateSeeking"
+		case RtspStatePlaying: return "RtspStatePlaying"
+		case RtspStateRecording: return "RtspStateRecording"
+		default: return fmt.Sprintf("RTSPState(%d)", e)
+	}
+}
+
 // RTSPStatusCode wraps GstRTSPStatusCode
 //
 // Enumeration of rtsp status codes
@@ -674,6 +850,60 @@ func (e RTSPStatusCode) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e RTSPStatusCode) String() string {
+	switch e {
+		case RtspStsInvalid: return "RtspStsInvalid"
+		case RtspStsMultipleChoices: return "RtspStsMultipleChoices"
+		case RtspStsNotAcceptable: return "RtspStsNotAcceptable"
+		case RtspStsUnsupportedMediaType: return "RtspStsUnsupportedMediaType"
+		case RtspStsHeaderFieldNotValidForResource: return "RtspStsHeaderFieldNotValidForResource"
+		case RtspStsParameterIsReadonly: return "RtspStsParameterIsReadonly"
+		case RtspStsAggregateOperationNotAllowed: return "RtspStsAggregateOperationNotAllowed"
+		case RtspStsOnlyAggregateOperationAllowed: return "RtspStsOnlyAggregateOperationAllowed"
+		case RtspStsMovedPermanently: return "RtspStsMovedPermanently"
+		case RtspStsSeeOther: return "RtspStsSeeOther"
+		case RtspStsUseProxy: return "RtspStsUseProxy"
+		case RtspStsGone: return "RtspStsGone"
+		case RtspStsKeyManagementFailure: return "RtspStsKeyManagementFailure"
+		case RtspStsNotImplemented: return "RtspStsNotImplemented"
+		case RtspStsOK: return "RtspStsOK"
+		case RtspStsUnauthorized: return "RtspStsUnauthorized"
+		case RtspStsRequestTimeout: return "RtspStsRequestTimeout"
+		case RtspStsPreconditionFailed: return "RtspStsPreconditionFailed"
+		case RtspStsSessionNotFound: return "RtspStsSessionNotFound"
+		case RtspStsDestinationUnreachable: return "RtspStsDestinationUnreachable"
+		case RtspStsContinue: return "RtspStsContinue"
+		case RtspStsCreated: return "RtspStsCreated"
+		case RtspStsRedirectTemporarily: return "RtspStsRedirectTemporarily"
+		case RtspStsProxyAuthRequired: return "RtspStsProxyAuthRequired"
+		case RtspStsRequestEntityTooLarge: return "RtspStsRequestEntityTooLarge"
+		case RtspStsConferenceNotFound: return "RtspStsConferenceNotFound"
+		case RtspStsInvalidRange: return "RtspStsInvalidRange"
+		case RtspStsBadGateway: return "RtspStsBadGateway"
+		case RtspStsPaymentRequired: return "RtspStsPaymentRequired"
+		case RtspStsForbidden: return "RtspStsForbidden"
+		case RtspStsInternalServerError: return "RtspStsInternalServerError"
+		case RtspStsServiceUnavailable: return "RtspStsServiceUnavailable"
+		case RtspStsGatewayTimeout: return "RtspStsGatewayTimeout"
+		case RtspStsOptionNotSupported: return "RtspStsOptionNotSupported"
+		case RtspStsNotModified: return "RtspStsNotModified"
+		case RtspStsNotFound: return "RtspStsNotFound"
+		case RtspStsMethodNotAllowed: return "RtspStsMethodNotAllowed"
+		case RtspStsLengthRequired: return "RtspStsLengthRequired"
+		case RtspStsParameterNotUnderstood: return "RtspStsParameterNotUnderstood"
+		case RtspStsNotEnoughBandwidth: return "RtspStsNotEnoughBandwidth"
+		case RtspStsMoveTemporarily: return "RtspStsMoveTemporarily"
+		case RtspStsBadRequest: return "RtspStsBadRequest"
+		case RtspStsMethodNotValidInThisState: return "RtspStsMethodNotValidInThisState"
+		case RtspStsUnsupportedTransport: return "RtspStsUnsupportedTransport"
+		case RtspStsRtspVersionNotSupported: return "RtspStsRtspVersionNotSupported"
+		case RtspStsLowOnStorage: return "RtspStsLowOnStorage"
+		case RtspStsRedirectPermanently: return "RtspStsRedirectPermanently"
+		case RtspStsRequestURITooLarge: return "RtspStsRequestURITooLarge"
+		default: return fmt.Sprintf("RTSPStatusCode(%d)", e)
+	}
+}
+
 // RTSPTimeType wraps GstRTSPTimeType
 //
 // Possible time types.
@@ -713,6 +943,17 @@ func (e RTSPTimeType) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e RTSPTimeType) String() string {
+	switch e {
+		case RtspTimeSeconds: return "RtspTimeSeconds"
+		case RtspTimeNow: return "RtspTimeNow"
+		case RtspTimeEnd: return "RtspTimeEnd"
+		case RtspTimeFrames: return "RtspTimeFrames"
+		case RtspTimeUTC: return "RtspTimeUTC"
+		default: return fmt.Sprintf("RTSPTimeType(%d)", e)
+	}
+}
+
 // RTSPVersion wraps GstRTSPVersion
 //
 // The supported RTSP versions.
@@ -748,6 +989,16 @@ func (e RTSPVersion) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e RTSPVersion) String() string {
+	switch e {
+		case RtspVersion10: return "RtspVersion10"
+		case RtspVersion11: return "RtspVersion11"
+		case RtspVersion20: return "RtspVersion20"
+		case RtspVersionInvalid: return "RtspVersionInvalid"
+		default: return fmt.Sprintf("RTSPVersion(%d)", e)
+	}
+}
+
 // RTSPEvent wraps GstRTSPEvent
 //
 // The possible events for the connection.
@@ -779,6 +1030,21 @@ func (f RTSPEvent) InitGoValue(v *gobject.Value) {
 	v.SetFlags(int(f))
 }
 
+func (f RTSPEvent) String() string {
+	if f == 0 {
+		return "RTSPEvent(0)"
+	}
+
+	var parts []string
+	if (f & RtspEvRead) != 0 {
+		parts = append(parts, "RtspEvRead")
+	}
+	if (f & RtspEvWrite) != 0 {
+		parts = append(parts, "RtspEvWrite")
+	}
+	return "RTSPEvent(" + strings.Join(parts, "|") + ")"
+}
+
 // RTSPLowerTrans wraps GstRTSPLowerTrans
 //
 // The different transport methods.
@@ -826,6 +1092,33 @@ func (f RTSPLowerTrans) InitGoValue(v *gobject.Value) {
 	v.SetFlags(int(f))
 }
 
+func (f RTSPLowerTrans) String() string {
+	if f == 0 {
+		return "RTSPLowerTrans(0)"
+	}
+
+	var parts []string
+	if (f & RtspLowerTransUnknown) != 0 {
+		parts = append(parts, "RtspLowerTransUnknown")
+	}
+	if (f & RtspLowerTransUDP) != 0 {
+		parts = append(parts, "RtspLowerTransUDP")
+	}
+	if (f & RtspLowerTransUDPMcast) != 0 {
+		parts = append(parts, "RtspLowerTransUDPMcast")
+	}
+	if (f & RtspLowerTransTCP) != 0 {
+		parts = append(parts, "RtspLowerTransTCP")
+	}
+	if (f & RtspLowerTransHTTP) != 0 {
+		parts = append(parts, "RtspLowerTransHTTP")
+	}
+	if (f & RtspLowerTransTLS) != 0 {
+		parts = append(parts, "RtspLowerTransTLS")
+	}
+	return "RTSPLowerTrans(" + strings.Join(parts, "|") + ")"
+}
+
 // RTSPMethod wraps GstRTSPMethod
 //
 // The different supported RTSP methods.
@@ -905,6 +1198,57 @@ func (f RTSPMethod) InitGoValue(v *gobject.Value) {
 	v.SetFlags(int(f))
 }
 
+func (f RTSPMethod) String() string {
+	if f == 0 {
+		return "RTSPMethod(0)"
+	}
+
+	var parts []string
+	if (f & RtspInvalid) != 0 {
+		parts = append(parts, "RtspInvalid")
+	}
+	if (f & RtspDescribe) != 0 {
+		parts = append(parts, "RtspDescribe")
+	}
+	if (f & RtspAnnounce) != 0 {
+		parts = append(parts, "RtspAnnounce")
+	}
+	if (f & RtspGetParameter) != 0 {
+		parts = append(parts, "RtspGetParameter")
+	}
+	if (f & RtspOptions) != 0 {
+		parts = append(parts, "RtspOptions")
+	}
+	if (f & RtspPause) != 0 {
+		parts = append(parts, "RtspPause")
+	}
+	if (f & RtspPlay) != 0 {
+		parts = append(parts, "RtspPlay")
+	}
+	if (f & RtspRecord) != 0 {
+		parts = append(parts, "RtspRecord")
+	}
+	if (f & RtspRedirect) != 0 {
+		parts = append(parts, "RtspRedirect")
+	}
+	if (f & RtspSetup) != 0 {
+		parts = append(parts, "RtspSetup")
+	}
+	if (f & RtspSetParameter) != 0 {
+		parts = append(parts, "RtspSetParameter")
+	}
+	if (f & RtspTeardown) != 0 {
+		parts = append(parts, "RtspTeardown")
+	}
+	if (f & RtspGet) != 0 {
+		parts = append(parts, "RtspGet")
+	}
+	if (f & RtspPost) != 0 {
+		parts = append(parts, "RtspPost")
+	}
+	return "RTSPMethod(" + strings.Join(parts, "|") + ")"
+}
+
 // RTSPProfile wraps GstRTSPProfile
 //
 // The transfer profile to use.
@@ -948,6 +1292,30 @@ func (f RTSPProfile) InitGoValue(v *gobject.Value) {
 	v.SetFlags(int(f))
 }
 
+func (f RTSPProfile) String() string {
+	if f == 0 {
+		return "RTSPProfile(0)"
+	}
+
+	var parts []string
+	if (f & RtspProfileUnknown) != 0 {
+		parts = append(parts, "RtspProfileUnknown")
+	}
+	if (f & RtspProfileAvp) != 0 {
+		parts = append(parts, "RtspProfileAvp")
+	}
+	if (f & RtspProfileSavp) != 0 {
+		parts = append(parts, "RtspProfileSavp")
+	}
+	if (f & RtspProfileAvpf) != 0 {
+		parts = append(parts, "RtspProfileAvpf")
+	}
+	if (f & RtspProfileSavpf) != 0 {
+		parts = append(parts, "RtspProfileSavpf")
+	}
+	return "RTSPProfile(" + strings.Join(parts, "|") + ")"
+}
+
 // RTSPTransMode wraps GstRTSPTransMode
 //
 // The transfer mode to use.
@@ -983,6 +1351,24 @@ func (f RTSPTransMode) InitGoValue(v *gobject.Value) {
 	v.SetFlags(int(f))
 }
 
+func (f RTSPTransMode) String() string {
+	if f == 0 {
+		return "RTSPTransMode(0)"
+	}
+
+	var parts []string
+	if (f & RtspTransUnknown) != 0 {
+		parts = append(parts, "RtspTransUnknown")
+	}
+	if (f & RtspTransRtp) != 0 {
+		parts = append(parts, "RtspTransRtp")
+	}
+	if (f & RtspTransRdt) != 0 {
+		parts = append(parts, "RtspTransRdt")
+	}
+	return "RTSPTransMode(" + strings.Join(parts, "|") + ")"
+}
+
 // RTSPConnectionAcceptCertificateFunc wraps GstRTSPConnectionAcceptCertificateFunc
 type RTSPConnectionAcceptCertificateFunc func(conn gio.TlsConnection, peerCert gio.TlsCertificate, errors gio.TLSCertificateFlags) (goret bool)
 
diff --git a/pkg/gstsdp/gstsdp.gen.go b/pkg/gstsdp/gstsdp.gen.go
index 4a8428a..9f993c3 100644
--- a/pkg/gstsdp/gstsdp.gen.go
+++ b/pkg/gstsdp/gstsdp.gen.go
@@ -3,6 +3,7 @@
 package gstsdp
 
 import (
+	"fmt"
 	"runtime"
 	"unsafe"
 
@@ -57,6 +58,15 @@ const (
 )
 
 
+func (e MIKEYCacheType) String() string {
+	switch e {
+		case MikeyCacheNone: return "MikeyCacheNone"
+		case MikeyCacheAlways: return "MikeyCacheAlways"
+		case MikeyCacheForCsb: return "MikeyCacheForCsb"
+		default: return fmt.Sprintf("MIKEYCacheType(%d)", e)
+	}
+}
+
 // MIKEYEncAlg wraps GstMIKEYEncAlg
 //
 // The encryption algorithm used to encrypt the Encr data field
@@ -82,6 +92,16 @@ const (
 )
 
 
+func (e MIKEYEncAlg) String() string {
+	switch e {
+		case MikeyEncAesKw128: return "MikeyEncAesKw128"
+		case MikeyEncAesGcm128: return "MikeyEncAesGcm128"
+		case MikeyEncNull: return "MikeyEncNull"
+		case MikeyEncAesCm128: return "MikeyEncAesCm128"
+		default: return fmt.Sprintf("MIKEYEncAlg(%d)", e)
+	}
+}
+
 // MIKEYKVType wraps GstMIKEYKVType
 //
 // The key validity type
@@ -103,6 +123,15 @@ const (
 )
 
 
+func (e MIKEYKVType) String() string {
+	switch e {
+		case MikeyKvInterval: return "MikeyKvInterval"
+		case MikeyKvNull: return "MikeyKvNull"
+		case MikeyKvSpi: return "MikeyKvSpi"
+		default: return fmt.Sprintf("MIKEYKVType(%d)", e)
+	}
+}
+
 // MIKEYKeyDataType wraps GstMIKEYKeyDataType
 //
 // The type of key.
@@ -120,6 +149,14 @@ const (
 )
 
 
+func (e MIKEYKeyDataType) String() string {
+	switch e {
+		case MikeyKdTgk: return "MikeyKdTgk"
+		case MikeyKdTek: return "MikeyKdTek"
+		default: return fmt.Sprintf("MIKEYKeyDataType(%d)", e)
+	}
+}
+
 // MIKEYMacAlg wraps GstMIKEYMacAlg
 //
 // Specifies the authentication algorithm used
@@ -137,6 +174,14 @@ const (
 )
 
 
+func (e MIKEYMacAlg) String() string {
+	switch e {
+		case MikeyMacHMACSHA1160: return "MikeyMacHMACSHA1160"
+		case MikeyMacNull: return "MikeyMacNull"
+		default: return fmt.Sprintf("MIKEYMacAlg(%d)", e)
+	}
+}
+
 // MIKEYMapType wraps GstMIKEYMapType
 //
 // Specifies the method of uniquely mapping Crypto Sessions to the security
@@ -151,6 +196,13 @@ const (
 )
 
 
+func (e MIKEYMapType) String() string {
+	switch e {
+		case MikeyMapTypeSrtp: return "MikeyMapTypeSrtp"
+		default: return fmt.Sprintf("MIKEYMapType(%d)", e)
+	}
+}
+
 // MIKEYPRFFunc wraps GstMIKEYPRFFunc
 //
 // The PRF function that has been/will be used for key derivation
@@ -164,6 +216,13 @@ const (
 )
 
 
+func (e MIKEYPRFFunc) String() string {
+	switch e {
+		case MikeyPrfMikey1: return "MikeyPrfMikey1"
+		default: return fmt.Sprintf("MIKEYPRFFunc(%d)", e)
+	}
+}
+
 // MIKEYPayloadType wraps GstMIKEYPayloadType
 //
 // Different MIKEY Payload types.
@@ -233,6 +292,27 @@ const (
 )
 
 
+func (e MIKEYPayloadType) String() string {
+	switch e {
+		case MikeyPtPke: return "MikeyPtPke"
+		case MikeyPtT: return "MikeyPtT"
+		case MikeyPtChash: return "MikeyPtChash"
+		case MikeyPtLast: return "MikeyPtLast"
+		case MikeyPtKemac: return "MikeyPtKemac"
+		case MikeyPtRand: return "MikeyPtRand"
+		case MikeyPtSp: return "MikeyPtSp"
+		case MikeyPtErr: return "MikeyPtErr"
+		case MikeyPtKeyData: return "MikeyPtKeyData"
+		case MikeyPtDh: return "MikeyPtDh"
+		case MikeyPtSign: return "MikeyPtSign"
+		case MikeyPtID: return "MikeyPtID"
+		case MikeyPtCert: return "MikeyPtCert"
+		case MikeyPtV: return "MikeyPtV"
+		case MikeyPtGenExt: return "MikeyPtGenExt"
+		default: return fmt.Sprintf("MIKEYPayloadType(%d)", e)
+	}
+}
+
 // MIKEYSecProto wraps GstMIKEYSecProto
 //
 // Specifies the security protocol
@@ -246,6 +326,13 @@ const (
 )
 
 
+func (e MIKEYSecProto) String() string {
+	switch e {
+		case MikeySecProtoSrtp: return "MikeySecProtoSrtp"
+		default: return fmt.Sprintf("MIKEYSecProto(%d)", e)
+	}
+}
+
 // MIKEYSecSRTP wraps GstMIKEYSecSRTP
 //
 // This policy specifies the parameters for SRTP and SRTCP
@@ -311,6 +398,26 @@ const (
 )
 
 
+func (e MIKEYSecSRTP) String() string {
+	switch e {
+		case MikeySpSrtpEncAlg: return "MikeySpSrtpEncAlg"
+		case MikeySpSrtpAuthAlg: return "MikeySpSrtpAuthAlg"
+		case MikeySpSrtpPrf: return "MikeySpSrtpPrf"
+		case MikeySpSrtpSrtpEnc: return "MikeySpSrtpSrtpEnc"
+		case MikeySpSrtpFecOrder: return "MikeySpSrtpFecOrder"
+		case MikeySpSrtpAuthTagLen: return "MikeySpSrtpAuthTagLen"
+		case MikeySpSrtpSrtpPrefixLen: return "MikeySpSrtpSrtpPrefixLen"
+		case MikeySpSrtpAeadAuthTagLen: return "MikeySpSrtpAeadAuthTagLen"
+		case MikeySpSrtpEncKeyLen: return "MikeySpSrtpEncKeyLen"
+		case MikeySpSrtpAuthKeyLen: return "MikeySpSrtpAuthKeyLen"
+		case MikeySpSrtpSaltKeyLen: return "MikeySpSrtpSaltKeyLen"
+		case MikeySpSrtpKeyDerivRate: return "MikeySpSrtpKeyDerivRate"
+		case MikeySpSrtpSrtcpEnc: return "MikeySpSrtpSrtcpEnc"
+		case MikeySpSrtpSrtpAuth: return "MikeySpSrtpSrtpAuth"
+		default: return fmt.Sprintf("MIKEYSecSRTP(%d)", e)
+	}
+}
+
 // MIKEYTSType wraps GstMIKEYTSType
 //
 // Specifies the timestamp type.
@@ -332,6 +439,15 @@ const (
 )
 
 
+func (e MIKEYTSType) String() string {
+	switch e {
+		case MikeyTsTypeNtpUTC: return "MikeyTsTypeNtpUTC"
+		case MikeyTsTypeNtp: return "MikeyTsTypeNtp"
+		case MikeyTsTypeCounter: return "MikeyTsTypeCounter"
+		default: return fmt.Sprintf("MIKEYTSType(%d)", e)
+	}
+}
+
 // MIKEYType wraps GstMIKEYType
 //
 // Different MIKEY data types.
@@ -373,6 +489,20 @@ const (
 )
 
 
+func (e MIKEYType) String() string {
+	switch e {
+		case MikeyTypeDhResp: return "MikeyTypeDhResp"
+		case MikeyTypeError: return "MikeyTypeError"
+		case MikeyTypeInvalid: return "MikeyTypeInvalid"
+		case MikeyTypePskInit: return "MikeyTypePskInit"
+		case MikeyTypePskVerify: return "MikeyTypePskVerify"
+		case MikeyTypePkInit: return "MikeyTypePkInit"
+		case MikeyTypePkVerify: return "MikeyTypePkVerify"
+		case MikeyTypeDhInit: return "MikeyTypeDhInit"
+		default: return fmt.Sprintf("MIKEYType(%d)", e)
+	}
+}
+
 // SDPResult wraps GstSDPResult
 //
 // Return values for the SDP functions.
@@ -390,6 +520,14 @@ const (
 )
 
 
+func (e SDPResult) String() string {
+	switch e {
+		case SdpOK: return "SdpOK"
+		case SdpEinval: return "SdpEinval"
+		default: return fmt.Sprintf("SDPResult(%d)", e)
+	}
+}
+
 // SdpAddressIsMulticast wraps gst_sdp_address_is_multicast
 // 
 // The function takes the following parameters:
diff --git a/pkg/gsttag/gsttag.gen.go b/pkg/gsttag/gsttag.gen.go
index 9706616..8588e6e 100644
--- a/pkg/gsttag/gsttag.gen.go
+++ b/pkg/gsttag/gsttag.gen.go
@@ -3,7 +3,9 @@
 package gsttag
 
 import (
+	"fmt"
 	"runtime"
+	"strings"
 	"unsafe"
 
 	"github.com/diamondburned/gotk4/pkg/gobject/v2"
@@ -72,6 +74,15 @@ func (e TagDemuxResult) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e TagDemuxResult) String() string {
+	switch e {
+		case TagDemuxResultBrokenTag: return "TagDemuxResultBrokenTag"
+		case TagDemuxResultAgain: return "TagDemuxResultAgain"
+		case TagDemuxResultOK: return "TagDemuxResultOK"
+		default: return fmt.Sprintf("TagDemuxResult(%d)", e)
+	}
+}
+
 // TagImageType wraps GstTagImageType
 //
 // Type of image contained in an image tag (specified as "image-type" field in
@@ -174,6 +185,32 @@ func (e TagImageType) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e TagImageType) String() string {
+	switch e {
+		case TagImageTypeBandOrchestra: return "TagImageTypeBandOrchestra"
+		case TagImageTypeComposer: return "TagImageTypeComposer"
+		case TagImageTypeDuringPerformance: return "TagImageTypeDuringPerformance"
+		case TagImageTypeVideoCapture: return "TagImageTypeVideoCapture"
+		case TagImageTypeFrontCover: return "TagImageTypeFrontCover"
+		case TagImageTypeMedium: return "TagImageTypeMedium"
+		case TagImageTypeLyricist: return "TagImageTypeLyricist"
+		case TagImageTypeFish: return "TagImageTypeFish"
+		case TagImageTypePublisherStudioLogo: return "TagImageTypePublisherStudioLogo"
+		case TagImageTypeDuringRecording: return "TagImageTypeDuringRecording"
+		case TagImageTypeUndefined: return "TagImageTypeUndefined"
+		case TagImageTypeLeafletPage: return "TagImageTypeLeafletPage"
+		case TagImageTypeLeadArtist: return "TagImageTypeLeadArtist"
+		case TagImageTypeArtist: return "TagImageTypeArtist"
+		case TagImageTypeRecordingLocation: return "TagImageTypeRecordingLocation"
+		case TagImageTypeIllustration: return "TagImageTypeIllustration"
+		case TagImageTypeBandArtistLogo: return "TagImageTypeBandArtistLogo"
+		case TagImageTypeNone: return "TagImageTypeNone"
+		case TagImageTypeConductor: return "TagImageTypeConductor"
+		case TagImageTypeBackCover: return "TagImageTypeBackCover"
+		default: return fmt.Sprintf("TagImageType(%d)", e)
+	}
+}
+
 // TagLicenseFlags wraps GstTagLicenseFlags
 //
 // See http://creativecommons.org/ns for more information.
@@ -271,6 +308,57 @@ func (f TagLicenseFlags) InitGoValue(v *gobject.Value) {
 	v.SetFlags(int(f))
 }
 
+func (f TagLicenseFlags) String() string {
+	if f == 0 {
+		return "TagLicenseFlags(0)"
+	}
+
+	var parts []string
+	if (f & TagLicensePermitsReproduction) != 0 {
+		parts = append(parts, "TagLicensePermitsReproduction")
+	}
+	if (f & TagLicensePermitsDistribution) != 0 {
+		parts = append(parts, "TagLicensePermitsDistribution")
+	}
+	if (f & TagLicensePermitsDerivativeWorks) != 0 {
+		parts = append(parts, "TagLicensePermitsDerivativeWorks")
+	}
+	if (f & TagLicensePermitsSharing) != 0 {
+		parts = append(parts, "TagLicensePermitsSharing")
+	}
+	if (f & TagLicenseRequiresNotice) != 0 {
+		parts = append(parts, "TagLicenseRequiresNotice")
+	}
+	if (f & TagLicenseRequiresAttribution) != 0 {
+		parts = append(parts, "TagLicenseRequiresAttribution")
+	}
+	if (f & TagLicenseRequiresShareAlike) != 0 {
+		parts = append(parts, "TagLicenseRequiresShareAlike")
+	}
+	if (f & TagLicenseRequiresSourceCode) != 0 {
+		parts = append(parts, "TagLicenseRequiresSourceCode")
+	}
+	if (f & TagLicenseRequiresCopyleft) != 0 {
+		parts = append(parts, "TagLicenseRequiresCopyleft")
+	}
+	if (f & TagLicenseRequiresLesserCopyleft) != 0 {
+		parts = append(parts, "TagLicenseRequiresLesserCopyleft")
+	}
+	if (f & TagLicenseProhibitsCommercialUse) != 0 {
+		parts = append(parts, "TagLicenseProhibitsCommercialUse")
+	}
+	if (f & TagLicenseProhibitsHighIncomeNationUse) != 0 {
+		parts = append(parts, "TagLicenseProhibitsHighIncomeNationUse")
+	}
+	if (f & TagLicenseCreativeCommonsLicense) != 0 {
+		parts = append(parts, "TagLicenseCreativeCommonsLicense")
+	}
+	if (f & TagLicenseFreeSoftwareFoundationLicense) != 0 {
+		parts = append(parts, "TagLicenseFreeSoftwareFoundationLicense")
+	}
+	return "TagLicenseFlags(" + strings.Join(parts, "|") + ")"
+}
+
 // TagCheckLanguageCode wraps gst_tag_check_language_code
 // 
 // The function takes the following parameters:
diff --git a/pkg/gstvideo/gstvideo.gen.go b/pkg/gstvideo/gstvideo.gen.go
index 20070de..c9beb91 100644
--- a/pkg/gstvideo/gstvideo.gen.go
+++ b/pkg/gstvideo/gstvideo.gen.go
@@ -3,7 +3,9 @@
 package gstvideo
 
 import (
+	"fmt"
 	"runtime"
+	"strings"
 	"unsafe"
 
 	"github.com/diamondburned/gotk4/pkg/core/userdata"
@@ -246,6 +248,15 @@ func (e AncillaryMetaField) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e AncillaryMetaField) String() string {
+	switch e {
+		case AncillaryMetaFieldProgressive: return "AncillaryMetaFieldProgressive"
+		case AncillaryMetaFieldInterlacedFirst: return "AncillaryMetaFieldInterlacedFirst"
+		case AncillaryMetaFieldInterlacedSecond: return "AncillaryMetaFieldInterlacedSecond"
+		default: return fmt.Sprintf("AncillaryMetaField(%d)", e)
+	}
+}
+
 // ColorBalanceType wraps GstColorBalanceType
 //
 // An enumeration indicating whether an element implements color balancing
@@ -278,6 +289,14 @@ func (e ColorBalanceType) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e ColorBalanceType) String() string {
+	switch e {
+		case ColorBalanceHardware: return "ColorBalanceHardware"
+		case ColorBalanceSoftware: return "ColorBalanceSoftware"
+		default: return fmt.Sprintf("ColorBalanceType(%d)", e)
+	}
+}
+
 // NavigationCommand wraps GstNavigationCommand
 //
 // A set of commands that may be issued to an element providing the
@@ -382,6 +401,27 @@ func (e NavigationCommand) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e NavigationCommand) String() string {
+	switch e {
+		case NavigationCommandMenu5: return "NavigationCommandMenu5"
+		case NavigationCommandUp: return "NavigationCommandUp"
+		case NavigationCommandDown: return "NavigationCommandDown"
+		case NavigationCommandPrevAngle: return "NavigationCommandPrevAngle"
+		case NavigationCommandInvalid: return "NavigationCommandInvalid"
+		case NavigationCommandMenu2: return "NavigationCommandMenu2"
+		case NavigationCommandMenu4: return "NavigationCommandMenu4"
+		case NavigationCommandMenu6: return "NavigationCommandMenu6"
+		case NavigationCommandMenu7: return "NavigationCommandMenu7"
+		case NavigationCommandRight: return "NavigationCommandRight"
+		case NavigationCommandActivate: return "NavigationCommandActivate"
+		case NavigationCommandNextAngle: return "NavigationCommandNextAngle"
+		case NavigationCommandMenu1: return "NavigationCommandMenu1"
+		case NavigationCommandMenu3: return "NavigationCommandMenu3"
+		case NavigationCommandLeft: return "NavigationCommandLeft"
+		default: return fmt.Sprintf("NavigationCommand(%d)", e)
+	}
+}
+
 // NavigationEventType wraps GstNavigationEventType
 //
 // Enum values for the various events that an element implementing the
@@ -474,6 +514,25 @@ func (e NavigationEventType) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e NavigationEventType) String() string {
+	switch e {
+		case NavigationEventInvalid: return "NavigationEventInvalid"
+		case NavigationEventMouseButtonPress: return "NavigationEventMouseButtonPress"
+		case NavigationEventMouseButtonRelease: return "NavigationEventMouseButtonRelease"
+		case NavigationEventCommand: return "NavigationEventCommand"
+		case NavigationEventMouseScroll: return "NavigationEventMouseScroll"
+		case NavigationEventTouchDown: return "NavigationEventTouchDown"
+		case NavigationEventTouchMotion: return "NavigationEventTouchMotion"
+		case NavigationEventTouchFrame: return "NavigationEventTouchFrame"
+		case NavigationEventKeyPress: return "NavigationEventKeyPress"
+		case NavigationEventKeyRelease: return "NavigationEventKeyRelease"
+		case NavigationEventMouseMove: return "NavigationEventMouseMove"
+		case NavigationEventTouchUp: return "NavigationEventTouchUp"
+		case NavigationEventTouchCancel: return "NavigationEventTouchCancel"
+		default: return fmt.Sprintf("NavigationEventType(%d)", e)
+	}
+}
+
 // NavigationMessageType wraps GstNavigationMessageType
 //
 // A set of notifications that may be received on the bus when navigation
@@ -521,6 +580,17 @@ func (e NavigationMessageType) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e NavigationMessageType) String() string {
+	switch e {
+		case NavigationMessageInvalid: return "NavigationMessageInvalid"
+		case NavigationMessageMouseOver: return "NavigationMessageMouseOver"
+		case NavigationMessageCommandsChanged: return "NavigationMessageCommandsChanged"
+		case NavigationMessageAnglesChanged: return "NavigationMessageAnglesChanged"
+		case NavigationMessageEvent: return "NavigationMessageEvent"
+		default: return fmt.Sprintf("NavigationMessageType(%d)", e)
+	}
+}
+
 // NavigationQueryType wraps GstNavigationQueryType
 //
 // Types of navigation interface queries.
@@ -552,6 +622,15 @@ func (e NavigationQueryType) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e NavigationQueryType) String() string {
+	switch e {
+		case NavigationQueryAngles: return "NavigationQueryAngles"
+		case NavigationQueryInvalid: return "NavigationQueryInvalid"
+		case NavigationQueryCommands: return "NavigationQueryCommands"
+		default: return fmt.Sprintf("NavigationQueryType(%d)", e)
+	}
+}
+
 // VideoAFDSpec wraps GstVideoAFDSpec
 //
 // Enumeration of the different standards that may apply to AFD data:
@@ -589,6 +668,15 @@ func (e VideoAFDSpec) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e VideoAFDSpec) String() string {
+	switch e {
+		case VideoAfdSpecDvbEtsi: return "VideoAfdSpecDvbEtsi"
+		case VideoAfdSpecAtscA53: return "VideoAfdSpecAtscA53"
+		case VideoAfdSpecSmpteSt20161: return "VideoAfdSpecSmpteSt20161"
+		default: return fmt.Sprintf("VideoAFDSpec(%d)", e)
+	}
+}
+
 // VideoAFDValue wraps GstVideoAFDValue
 //
 // Enumeration of the various values for Active Format Description (AFD)
@@ -700,6 +788,23 @@ func (e VideoAFDValue) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e VideoAFDValue) String() string {
+	switch e {
+		case VideoAfd43_Full149_Center: return "VideoAfd43Full149Center"
+		case VideoAfd169_Letter149_Center: return "VideoAfd169Letter149Center"
+		case VideoAfd169_Letter43_Center: return "VideoAfd169Letter43Center"
+		case VideoAfd169_TopAligned: return "VideoAfd169TopAligned"
+		case VideoAfd149_TopAligned: return "VideoAfd149TopAligned"
+		case VideoAfdGreaterThan169: return "VideoAfdGreaterThan169"
+		case VideoAfd43_Full43_Pillar: return "VideoAfd43Full43Pillar"
+		case VideoAfd169_Letter169_Full: return "VideoAfd169Letter169Full"
+		case VideoAfd149_Letter149_Pillar: return "VideoAfd149Letter149Pillar"
+		case VideoAfdUnavailable: return "VideoAfdUnavailable"
+		case VideoAfd43_Full169_Full: return "VideoAfd43Full169Full"
+		default: return fmt.Sprintf("VideoAFDValue(%d)", e)
+	}
+}
+
 // VideoAlphaMode wraps GstVideoAlphaMode
 //
 // Different alpha modes.
@@ -737,6 +842,15 @@ func (e VideoAlphaMode) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e VideoAlphaMode) String() string {
+	switch e {
+		case VideoAlphaModeCopy: return "VideoAlphaModeCopy"
+		case VideoAlphaModeSet: return "VideoAlphaModeSet"
+		case VideoAlphaModeMult: return "VideoAlphaModeMult"
+		default: return fmt.Sprintf("VideoAlphaMode(%d)", e)
+	}
+}
+
 // VideoAncillaryDID wraps GstVideoAncillaryDID
 type VideoAncillaryDID C.int
 
@@ -778,6 +892,24 @@ func (e VideoAncillaryDID) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e VideoAncillaryDID) String() string {
+	switch e {
+		case VideoAncillaryDidHancSdtvAudioData1Last: return "VideoAncillaryDidHancSdtvAudioData1Last"
+		case VideoAncillaryDidHancSdtvAudioData2First: return "VideoAncillaryDidHancSdtvAudioData2First"
+		case VideoAncillaryDidHancSdtvAudioData2Last: return "VideoAncillaryDidHancSdtvAudioData2Last"
+		case VideoAncillaryDidUndefined: return "VideoAncillaryDidUndefined"
+		case VideoAncillaryDidDeletion: return "VideoAncillaryDidDeletion"
+		case VideoAncillaryDidHancHdtvAudioDataFirst: return "VideoAncillaryDidHancHdtvAudioDataFirst"
+		case VideoAncillaryDidHancHdtvAudioDataLast: return "VideoAncillaryDidHancHdtvAudioDataLast"
+		case VideoAncillaryDidCameraPosition: return "VideoAncillaryDidCameraPosition"
+		case VideoAncillaryDidHancErrorDetection: return "VideoAncillaryDidHancErrorDetection"
+		case VideoAncillaryDidHanc3GAudioDataFirst: return "VideoAncillaryDidHanc3GAudioDataFirst"
+		case VideoAncillaryDidHanc3GAudioDataLast: return "VideoAncillaryDidHanc3GAudioDataLast"
+		case VideoAncillaryDidHancSdtvAudioData1First: return "VideoAncillaryDidHancSdtvAudioData1First"
+		default: return fmt.Sprintf("VideoAncillaryDID(%d)", e)
+	}
+}
+
 // VideoAncillaryDID16 wraps GstVideoAncillaryDID16
 //
 // Some know types of Ancillary Data identifiers.
@@ -809,6 +941,15 @@ func (e VideoAncillaryDID16) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e VideoAncillaryDID16) String() string {
+	switch e {
+		case VideoAncillaryDid16S334Eia708: return "VideoAncillaryDid16S334Eia708"
+		case VideoAncillaryDid16S334Eia608: return "VideoAncillaryDid16S334Eia608"
+		case VideoAncillaryDid16S20163AfdBar: return "VideoAncillaryDid16S20163AfdBar"
+		default: return fmt.Sprintf("VideoAncillaryDID16(%d)", e)
+	}
+}
+
 // VideoCaptionType wraps GstVideoCaptionType
 //
 // The various known types of Closed Caption (CC).
@@ -865,6 +1006,17 @@ func (e VideoCaptionType) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e VideoCaptionType) String() string {
+	switch e {
+		case VideoCaptionTypeCea708Raw: return "VideoCaptionTypeCea708Raw"
+		case VideoCaptionTypeCea708Cdp: return "VideoCaptionTypeCea708Cdp"
+		case VideoCaptionTypeUnknown: return "VideoCaptionTypeUnknown"
+		case VideoCaptionTypeCea608Raw: return "VideoCaptionTypeCea608Raw"
+		case VideoCaptionTypeCea608S3341A: return "VideoCaptionTypeCea608S3341A"
+		default: return fmt.Sprintf("VideoCaptionType(%d)", e)
+	}
+}
+
 // VideoChromaMethod wraps GstVideoChromaMethod
 //
 // Different subsampling and upsampling methods
@@ -894,6 +1046,14 @@ func (e VideoChromaMethod) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e VideoChromaMethod) String() string {
+	switch e {
+		case VideoChromaMethodNearest: return "VideoChromaMethodNearest"
+		case VideoChromaMethodLinear: return "VideoChromaMethodLinear"
+		default: return fmt.Sprintf("VideoChromaMethod(%d)", e)
+	}
+}
+
 // VideoChromaMode wraps GstVideoChromaMode
 //
 // Different chroma downsampling and upsampling modes
@@ -929,6 +1089,16 @@ func (e VideoChromaMode) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e VideoChromaMode) String() string {
+	switch e {
+		case VideoChromaModeFull: return "VideoChromaModeFull"
+		case VideoChromaModeUpsampleOnly: return "VideoChromaModeUpsampleOnly"
+		case VideoChromaModeDownsampleOnly: return "VideoChromaModeDownsampleOnly"
+		case VideoChromaModeNone: return "VideoChromaModeNone"
+		default: return fmt.Sprintf("VideoChromaMode(%d)", e)
+	}
+}
+
 // VideoColorMatrix wraps GstVideoColorMatrix
 //
 // The color matrix is used to convert between Y'PbPr and
@@ -979,6 +1149,19 @@ func (e VideoColorMatrix) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e VideoColorMatrix) String() string {
+	switch e {
+		case VideoColorMatrixBt2020: return "VideoColorMatrixBt2020"
+		case VideoColorMatrixUnknown: return "VideoColorMatrixUnknown"
+		case VideoColorMatrixRGB: return "VideoColorMatrixRGB"
+		case VideoColorMatrixFcc: return "VideoColorMatrixFcc"
+		case VideoColorMatrixBt709: return "VideoColorMatrixBt709"
+		case VideoColorMatrixBt601: return "VideoColorMatrixBt601"
+		case VideoColorMatrixSmpte240M: return "VideoColorMatrixSmpte240M"
+		default: return fmt.Sprintf("VideoColorMatrix(%d)", e)
+	}
+}
+
 // VideoColorPrimaries wraps GstVideoColorPrimaries
 //
 // The color primaries define the how to transform linear RGB values to and from
@@ -1060,6 +1243,25 @@ func (e VideoColorPrimaries) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e VideoColorPrimaries) String() string {
+	switch e {
+		case VideoColorPrimariesUnknown: return "VideoColorPrimariesUnknown"
+		case VideoColorPrimariesBt709: return "VideoColorPrimariesBt709"
+		case VideoColorPrimariesBt470Bg: return "VideoColorPrimariesBt470Bg"
+		case VideoColorPrimariesSmpte170M: return "VideoColorPrimariesSmpte170M"
+		case VideoColorPrimariesSmpte240M: return "VideoColorPrimariesSmpte240M"
+		case VideoColorPrimariesBt2020: return "VideoColorPrimariesBt2020"
+		case VideoColorPrimariesSmptest428: return "VideoColorPrimariesSmptest428"
+		case VideoColorPrimariesSmpteeg432: return "VideoColorPrimariesSmpteeg432"
+		case VideoColorPrimariesBt470M: return "VideoColorPrimariesBt470M"
+		case VideoColorPrimariesFilm: return "VideoColorPrimariesFilm"
+		case VideoColorPrimariesAdobergb: return "VideoColorPrimariesAdobergb"
+		case VideoColorPrimariesSmpterp431: return "VideoColorPrimariesSmpterp431"
+		case VideoColorPrimariesEbu3213: return "VideoColorPrimariesEbu3213"
+		default: return fmt.Sprintf("VideoColorPrimaries(%d)", e)
+	}
+}
+
 // VideoColorRange wraps GstVideoColorRange
 //
 // Possible color range values. These constants are defined for 8 bit color
@@ -1093,6 +1295,15 @@ func (e VideoColorRange) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e VideoColorRange) String() string {
+	switch e {
+		case VideoColorRangeUnknown: return "VideoColorRangeUnknown"
+		case VideoColorRange0255: return "VideoColorRange0255"
+		case VideoColorRange16235: return "VideoColorRange16235"
+		default: return fmt.Sprintf("VideoColorRange(%d)", e)
+	}
+}
+
 // VideoDitherMethod wraps GstVideoDitherMethod
 //
 // Different dithering methods to use.
@@ -1132,6 +1343,17 @@ func (e VideoDitherMethod) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e VideoDitherMethod) String() string {
+	switch e {
+		case VideoDitherVerterr: return "VideoDitherVerterr"
+		case VideoDitherFloydSteinberg: return "VideoDitherFloydSteinberg"
+		case VideoDitherSierraLite: return "VideoDitherSierraLite"
+		case VideoDitherBayer: return "VideoDitherBayer"
+		case VideoDitherNone: return "VideoDitherNone"
+		default: return fmt.Sprintf("VideoDitherMethod(%d)", e)
+	}
+}
+
 // VideoFieldOrder wraps GstVideoFieldOrder
 //
 // Field order of interlaced content. This is only valid for
@@ -1167,6 +1389,15 @@ func (e VideoFieldOrder) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e VideoFieldOrder) String() string {
+	switch e {
+		case VideoFieldOrderUnknown: return "VideoFieldOrderUnknown"
+		case VideoFieldOrderTopFieldFirst: return "VideoFieldOrderTopFieldFirst"
+		case VideoFieldOrderBottomFieldFirst: return "VideoFieldOrderBottomFieldFirst"
+		default: return fmt.Sprintf("VideoFieldOrder(%d)", e)
+	}
+}
+
 // VideoFormat wraps GstVideoFormat
 //
 // Enum value describing the most common video formats.
@@ -1743,6 +1974,146 @@ func (e VideoFormat) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e VideoFormat) String() string {
+	switch e {
+		case VideoFormatXrgb: return "VideoFormatXrgb"
+		case VideoFormatXbgr: return "VideoFormatXbgr"
+		case VideoFormatAbgr64LE: return "VideoFormatAbgr64LE"
+		case VideoFormatEncoded: return "VideoFormatEncoded"
+		case VideoFormatI42210Be: return "VideoFormatI42210Be"
+		case VideoFormatGray16LE: return "VideoFormatGray16LE"
+		case VideoFormatBgra64Be: return "VideoFormatBgra64Be"
+		case VideoFormatYuv9: return "VideoFormatYuv9"
+		case VideoFormatARGB64: return "VideoFormatARGB64"
+		case VideoFormatY44410LE: return "VideoFormatY44410LE"
+		case VideoFormatNv1216L32S: return "VideoFormatNv1216L32S"
+		case VideoFormatA44412LE: return "VideoFormatA44412LE"
+		case VideoFormatRGBA: return "VideoFormatRGBA"
+		case VideoFormatGbr10LE: return "VideoFormatGbr10LE"
+		case VideoFormatA42210LE: return "VideoFormatA42210LE"
+		case VideoFormatVuya: return "VideoFormatVuya"
+		case VideoFormatP012Be: return "VideoFormatP012Be"
+		case VideoFormatA44412Be: return "VideoFormatA44412Be"
+		case VideoFormatA42012LE: return "VideoFormatA42012LE"
+		case VideoFormatA44410Be: return "VideoFormatA44410Be"
+		case VideoFormatGbra10LE: return "VideoFormatGbra10LE"
+		case VideoFormatGbra12Be: return "VideoFormatGbra12Be"
+		case VideoFormatARGB64Be: return "VideoFormatARGB64Be"
+		case VideoFormatAbgr64Be: return "VideoFormatAbgr64Be"
+		case VideoFormatNv1210Be8L128: return "VideoFormatNv1210Be8L128"
+		case VideoFormatA44416LE: return "VideoFormatA44416LE"
+		case VideoFormatGbr10Be: return "VideoFormatGbr10Be"
+		case VideoFormatGbra: return "VideoFormatGbra"
+		case VideoFormatY212Be: return "VideoFormatY212Be"
+		case VideoFormatRgbp: return "VideoFormatRgbp"
+		case VideoFormatAv12: return "VideoFormatAv12"
+		case VideoFormatRGBA64LE: return "VideoFormatRGBA64LE"
+		case VideoFormatA42216Be: return "VideoFormatA42216Be"
+		case VideoFormatUnknown: return "VideoFormatUnknown"
+		case VideoFormatNv24: return "VideoFormatNv24"
+		case VideoFormatNv61: return "VideoFormatNv61"
+		case VideoFormatP01010LE: return "VideoFormatP01010LE"
+		case VideoFormatIyu2: return "VideoFormatIyu2"
+		case VideoFormatI42012LE: return "VideoFormatI42012LE"
+		case VideoFormatY412LE: return "VideoFormatY412LE"
+		case VideoFormatNv1210LE404L4: return "VideoFormatNv1210LE404L4"
+		case VideoFormatY42B: return "VideoFormatY42B"
+		case VideoFormatI42010Be: return "VideoFormatI42010Be"
+		case VideoFormatMt2110T: return "VideoFormatMt2110T"
+		case VideoFormatYV12: return "VideoFormatYV12"
+		case VideoFormatYuy2: return "VideoFormatYuy2"
+		case VideoFormatGbra10Be: return "VideoFormatGbra10Be"
+		case VideoFormatNv1210LE40: return "VideoFormatNv1210LE40"
+		case VideoFormatA44416Be: return "VideoFormatA44416Be"
+		case VideoFormatGbr16Be: return "VideoFormatGbr16Be"
+		case VideoFormatYvu9: return "VideoFormatYvu9"
+		case VideoFormatA42010LE: return "VideoFormatA42010LE"
+		case VideoFormatGbr12Be: return "VideoFormatGbr12Be"
+		case VideoFormatY44412Be: return "VideoFormatY44412Be"
+		case VideoFormatRGB10A2LE: return "VideoFormatRGB10A2LE"
+		case VideoFormatARGB64LE: return "VideoFormatARGB64LE"
+		case VideoFormatBGR16: return "VideoFormatBGR16"
+		case VideoFormatGbra12LE: return "VideoFormatGbra12LE"
+		case VideoFormatDmaDRM: return "VideoFormatDmaDRM"
+		case VideoFormatBgrx: return "VideoFormatBgrx"
+		case VideoFormatV210: return "VideoFormatV210"
+		case VideoFormatA420: return "VideoFormatA420"
+		case VideoFormatGbr: return "VideoFormatGbr"
+		case VideoFormatA42016LE: return "VideoFormatA42016LE"
+		case VideoFormatGbr16LE: return "VideoFormatGbr16LE"
+		case VideoFormatAyuv: return "VideoFormatAyuv"
+		case VideoFormatRGB8P: return "VideoFormatRGB8P"
+		case VideoFormatA44410LE: return "VideoFormatA44410LE"
+		case VideoFormatRGB: return "VideoFormatRGB"
+		case VideoFormatBGR15: return "VideoFormatBGR15"
+		case VideoFormatAyuv64: return "VideoFormatAyuv64"
+		case VideoFormatY44412LE: return "VideoFormatY44412LE"
+		case VideoFormatUyvp: return "VideoFormatUyvp"
+		case VideoFormatP01010Be: return "VideoFormatP01010Be"
+		case VideoFormatP016LE: return "VideoFormatP016LE"
+		case VideoFormatY412Be: return "VideoFormatY412Be"
+		case VideoFormatRGBA64Be: return "VideoFormatRGBA64Be"
+		case VideoFormatV216: return "VideoFormatV216"
+		case VideoFormatR210: return "VideoFormatR210"
+		case VideoFormatI42210LE: return "VideoFormatI42210LE"
+		case VideoFormatVyuy: return "VideoFormatVyuy"
+		case VideoFormatNv1210LE32: return "VideoFormatNv1210LE32"
+		case VideoFormatP012LE: return "VideoFormatP012LE"
+		case VideoFormatI420: return "VideoFormatI420"
+		case VideoFormatA444: return "VideoFormatA444"
+		case VideoFormatA42216LE: return "VideoFormatA42216LE"
+		case VideoFormatGray16Be: return "VideoFormatGray16Be"
+		case VideoFormatBgra: return "VideoFormatBgra"
+		case VideoFormatRGB15: return "VideoFormatRGB15"
+		case VideoFormatIyu1: return "VideoFormatIyu1"
+		case VideoFormatY410: return "VideoFormatY410"
+		case VideoFormatA42212LE: return "VideoFormatA42212LE"
+		case VideoFormatA42012Be: return "VideoFormatA42012Be"
+		case VideoFormatY444: return "VideoFormatY444"
+		case VideoFormatI42212Be: return "VideoFormatI42212Be"
+		case VideoFormatGray10LE32: return "VideoFormatGray10LE32"
+		case VideoFormatY210: return "VideoFormatY210"
+		case VideoFormatP016Be: return "VideoFormatP016Be"
+		case VideoFormatNv12: return "VideoFormatNv12"
+		case VideoFormatGbr12LE: return "VideoFormatGbr12LE"
+		case VideoFormatBgrp: return "VideoFormatBgrp"
+		case VideoFormatA422: return "VideoFormatA422"
+		case VideoFormatNv21: return "VideoFormatNv21"
+		case VideoFormatBGR: return "VideoFormatBGR"
+		case VideoFormatBGR10A2LE: return "VideoFormatBGR10A2LE"
+		case VideoFormatY44416Be: return "VideoFormatY44416Be"
+		case VideoFormatA42016Be: return "VideoFormatA42016Be"
+		case VideoFormatGray8: return "VideoFormatGray8"
+		case VideoFormatY44410Be: return "VideoFormatY44410Be"
+		case VideoFormatNv1232L32: return "VideoFormatNv1232L32"
+		case VideoFormatBgra64LE: return "VideoFormatBgra64LE"
+		case VideoFormatY44416LE: return "VideoFormatY44416LE"
+		case VideoFormatNv124L4: return "VideoFormatNv124L4"
+		case VideoFormatA42212Be: return "VideoFormatA42212Be"
+		case VideoFormatRbga: return "VideoFormatRbga"
+		case VideoFormatRgbx: return "VideoFormatRgbx"
+		case VideoFormatA42010Be: return "VideoFormatA42010Be"
+		case VideoFormatNv1610LE32: return "VideoFormatNv1610LE32"
+		case VideoFormatYvyu: return "VideoFormatYvyu"
+		case VideoFormatAbgr: return "VideoFormatAbgr"
+		case VideoFormatY41B: return "VideoFormatY41B"
+		case VideoFormatV308: return "VideoFormatV308"
+		case VideoFormatNv1264Z32: return "VideoFormatNv1264Z32"
+		case VideoFormatUyvy: return "VideoFormatUyvy"
+		case VideoFormatARGB: return "VideoFormatARGB"
+		case VideoFormatRGB16: return "VideoFormatRGB16"
+		case VideoFormatI42010LE: return "VideoFormatI42010LE"
+		case VideoFormatI42012Be: return "VideoFormatI42012Be"
+		case VideoFormatI42212LE: return "VideoFormatI42212LE"
+		case VideoFormatNv128L128: return "VideoFormatNv128L128"
+		case VideoFormatNv16: return "VideoFormatNv16"
+		case VideoFormatMt2110R: return "VideoFormatMt2110R"
+		case VideoFormatA42210Be: return "VideoFormatA42210Be"
+		case VideoFormatY212LE: return "VideoFormatY212LE"
+		default: return fmt.Sprintf("VideoFormat(%d)", e)
+	}
+}
+
 // VideoGLTextureOrientation wraps GstVideoGLTextureOrientation
 //
 // The orientation of the GL texture.
@@ -1778,6 +2149,16 @@ func (e VideoGLTextureOrientation) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e VideoGLTextureOrientation) String() string {
+	switch e {
+		case VideoGLTextureOrientationXNormalYNormal: return "VideoGLTextureOrientationXNormalYNormal"
+		case VideoGLTextureOrientationXNormalYFlip: return "VideoGLTextureOrientationXNormalYFlip"
+		case VideoGLTextureOrientationXFlipYNormal: return "VideoGLTextureOrientationXFlipYNormal"
+		case VideoGLTextureOrientationXFlipYFlip: return "VideoGLTextureOrientationXFlipYFlip"
+		default: return fmt.Sprintf("VideoGLTextureOrientation(%d)", e)
+	}
+}
+
 // VideoGLTextureType wraps GstVideoGLTextureType
 //
 // The GL texture type.
@@ -1825,6 +2206,19 @@ func (e VideoGLTextureType) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e VideoGLTextureType) String() string {
+	switch e {
+		case VideoGLTextureTypeRGB: return "VideoGLTextureTypeRGB"
+		case VideoGLTextureTypeRGBA: return "VideoGLTextureTypeRGBA"
+		case VideoGLTextureTypeR: return "VideoGLTextureTypeR"
+		case VideoGLTextureTypeRg: return "VideoGLTextureTypeRg"
+		case VideoGLTextureTypeLuminance: return "VideoGLTextureTypeLuminance"
+		case VideoGLTextureTypeLuminanceAlpha: return "VideoGLTextureTypeLuminanceAlpha"
+		case VideoGLTextureTypeRGB16: return "VideoGLTextureTypeRGB16"
+		default: return fmt.Sprintf("VideoGLTextureType(%d)", e)
+	}
+}
+
 // VideoGammaMode wraps GstVideoGammaMode
 type VideoGammaMode C.int
 
@@ -1851,6 +2245,14 @@ func (e VideoGammaMode) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e VideoGammaMode) String() string {
+	switch e {
+		case VideoGammaModeNone: return "VideoGammaModeNone"
+		case VideoGammaModeRemap: return "VideoGammaModeRemap"
+		default: return fmt.Sprintf("VideoGammaMode(%d)", e)
+	}
+}
+
 // VideoInterlaceMode wraps GstVideoInterlaceMode
 //
 // The possible values of the #GstVideoInterlaceMode describing the interlace
@@ -1903,6 +2305,17 @@ func (e VideoInterlaceMode) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e VideoInterlaceMode) String() string {
+	switch e {
+		case VideoInterlaceModeFields: return "VideoInterlaceModeFields"
+		case VideoInterlaceModeAlternate: return "VideoInterlaceModeAlternate"
+		case VideoInterlaceModeProgressive: return "VideoInterlaceModeProgressive"
+		case VideoInterlaceModeInterleaved: return "VideoInterlaceModeInterleaved"
+		case VideoInterlaceModeMixed: return "VideoInterlaceModeMixed"
+		default: return fmt.Sprintf("VideoInterlaceMode(%d)", e)
+	}
+}
+
 // VideoMatrixMode wraps GstVideoMatrixMode
 //
 // Different color matrix conversion modes
@@ -1940,6 +2353,16 @@ func (e VideoMatrixMode) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e VideoMatrixMode) String() string {
+	switch e {
+		case VideoMatrixModeInputOnly: return "VideoMatrixModeInputOnly"
+		case VideoMatrixModeOutputOnly: return "VideoMatrixModeOutputOnly"
+		case VideoMatrixModeNone: return "VideoMatrixModeNone"
+		case VideoMatrixModeFull: return "VideoMatrixModeFull"
+		default: return fmt.Sprintf("VideoMatrixMode(%d)", e)
+	}
+}
+
 // VideoMultiviewFramePacking wraps GstVideoMultiviewFramePacking
 //
 // #GstVideoMultiviewFramePacking represents the subset of #GstVideoMultiviewMode
@@ -2017,6 +2440,22 @@ func (e VideoMultiviewFramePacking) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e VideoMultiviewFramePacking) String() string {
+	switch e {
+		case VideoMultiviewFramePackingRight: return "VideoMultiviewFramePackingRight"
+		case VideoMultiviewFramePackingSideBySide: return "VideoMultiviewFramePackingSideBySide"
+		case VideoMultiviewFramePackingSideBySideQuincunx: return "VideoMultiviewFramePackingSideBySideQuincunx"
+		case VideoMultiviewFramePackingRowInterleaved: return "VideoMultiviewFramePackingRowInterleaved"
+		case VideoMultiviewFramePackingTopBottom: return "VideoMultiviewFramePackingTopBottom"
+		case VideoMultiviewFramePackingMono: return "VideoMultiviewFramePackingMono"
+		case VideoMultiviewFramePackingColumnInterleaved: return "VideoMultiviewFramePackingColumnInterleaved"
+		case VideoMultiviewFramePackingCheckerboard: return "VideoMultiviewFramePackingCheckerboard"
+		case VideoMultiviewFramePackingNone: return "VideoMultiviewFramePackingNone"
+		case VideoMultiviewFramePackingLeft: return "VideoMultiviewFramePackingLeft"
+		default: return fmt.Sprintf("VideoMultiviewFramePacking(%d)", e)
+	}
+}
+
 // VideoMultiviewMode wraps GstVideoMultiviewMode
 //
 // All possible stereoscopic 3D and multiview representations.
@@ -2110,6 +2549,25 @@ func (e VideoMultiviewMode) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e VideoMultiviewMode) String() string {
+	switch e {
+		case VideoMultiviewModeSideBySideQuincunx: return "VideoMultiviewModeSideBySideQuincunx"
+		case VideoMultiviewModeCheckerboard: return "VideoMultiviewModeCheckerboard"
+		case VideoMultiviewModeMultiviewFrameByFrame: return "VideoMultiviewModeMultiviewFrameByFrame"
+		case VideoMultiviewModeSideBySide: return "VideoMultiviewModeSideBySide"
+		case VideoMultiviewModeColumnInterleaved: return "VideoMultiviewModeColumnInterleaved"
+		case VideoMultiviewModeRowInterleaved: return "VideoMultiviewModeRowInterleaved"
+		case VideoMultiviewModeTopBottom: return "VideoMultiviewModeTopBottom"
+		case VideoMultiviewModeFrameByFrame: return "VideoMultiviewModeFrameByFrame"
+		case VideoMultiviewModeSeparated: return "VideoMultiviewModeSeparated"
+		case VideoMultiviewModeNone: return "VideoMultiviewModeNone"
+		case VideoMultiviewModeMono: return "VideoMultiviewModeMono"
+		case VideoMultiviewModeLeft: return "VideoMultiviewModeLeft"
+		case VideoMultiviewModeRight: return "VideoMultiviewModeRight"
+		default: return fmt.Sprintf("VideoMultiviewMode(%d)", e)
+	}
+}
+
 // VideoOrientationMethod wraps GstVideoOrientationMethod
 //
 // The different video orientation methods.
@@ -2169,6 +2627,22 @@ func (e VideoOrientationMethod) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e VideoOrientationMethod) String() string {
+	switch e {
+		case VideoOrientation90R: return "VideoOrientation90R"
+		case VideoOrientation180: return "VideoOrientation180"
+		case VideoOrientationHoriz: return "VideoOrientationHoriz"
+		case VideoOrientationUlLr: return "VideoOrientationUlLr"
+		case VideoOrientationUrLl: return "VideoOrientationUrLl"
+		case VideoOrientationCustom: return "VideoOrientationCustom"
+		case VideoOrientationIdentity: return "VideoOrientationIdentity"
+		case VideoOrientation90L: return "VideoOrientation90L"
+		case VideoOrientationVert: return "VideoOrientationVert"
+		case VideoOrientationAuto: return "VideoOrientationAuto"
+		default: return fmt.Sprintf("VideoOrientationMethod(%d)", e)
+	}
+}
+
 // VideoPrimariesMode wraps GstVideoPrimariesMode
 //
 // Different primaries conversion modes
@@ -2201,6 +2675,15 @@ func (e VideoPrimariesMode) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e VideoPrimariesMode) String() string {
+	switch e {
+		case VideoPrimariesModeNone: return "VideoPrimariesModeNone"
+		case VideoPrimariesModeMergeOnly: return "VideoPrimariesModeMergeOnly"
+		case VideoPrimariesModeFast: return "VideoPrimariesModeFast"
+		default: return fmt.Sprintf("VideoPrimariesMode(%d)", e)
+	}
+}
+
 // VideoResamplerMethod wraps GstVideoResamplerMethod
 //
 // Different subsampling and upsampling methods
@@ -2242,6 +2725,17 @@ func (e VideoResamplerMethod) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e VideoResamplerMethod) String() string {
+	switch e {
+		case VideoResamplerMethodNearest: return "VideoResamplerMethodNearest"
+		case VideoResamplerMethodLinear: return "VideoResamplerMethodLinear"
+		case VideoResamplerMethodCubic: return "VideoResamplerMethodCubic"
+		case VideoResamplerMethodSinc: return "VideoResamplerMethodSinc"
+		case VideoResamplerMethodLanczos: return "VideoResamplerMethodLanczos"
+		default: return fmt.Sprintf("VideoResamplerMethod(%d)", e)
+	}
+}
+
 // VideoTileMode wraps GstVideoTileMode
 //
 // Enum value describing the available tiling modes.
@@ -2276,6 +2770,15 @@ func (e VideoTileMode) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e VideoTileMode) String() string {
+	switch e {
+		case VideoTileModeUnknown: return "VideoTileModeUnknown"
+		case VideoTileModeZflipz2X2: return "VideoTileModeZflipz2X2"
+		case VideoTileModeLinear: return "VideoTileModeLinear"
+		default: return fmt.Sprintf("VideoTileMode(%d)", e)
+	}
+}
+
 // VideoTileType wraps GstVideoTileType
 //
 // Enum value describing the most common tiling types.
@@ -2301,6 +2804,13 @@ func (e VideoTileType) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e VideoTileType) String() string {
+	switch e {
+		case VideoTileTypeIndexed: return "VideoTileTypeIndexed"
+		default: return fmt.Sprintf("VideoTileType(%d)", e)
+	}
+}
+
 // VideoTransferFunction wraps GstVideoTransferFunction
 //
 // The video transfer function defines the formula for converting between
@@ -2404,6 +2914,29 @@ func (e VideoTransferFunction) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e VideoTransferFunction) String() string {
+	switch e {
+		case VideoTransferGamma20: return "VideoTransferGamma20"
+		case VideoTransferSmpte240M: return "VideoTransferSmpte240M"
+		case VideoTransferSrgb: return "VideoTransferSrgb"
+		case VideoTransferBt202012: return "VideoTransferBt202012"
+		case VideoTransferBt601: return "VideoTransferBt601"
+		case VideoTransferUnknown: return "VideoTransferUnknown"
+		case VideoTransferGamma28: return "VideoTransferGamma28"
+		case VideoTransferBt202010: return "VideoTransferBt202010"
+		case VideoTransferBt709: return "VideoTransferBt709"
+		case VideoTransferLog316: return "VideoTransferLog316"
+		case VideoTransferAdobergb: return "VideoTransferAdobergb"
+		case VideoTransferSmpte2084: return "VideoTransferSmpte2084"
+		case VideoTransferGamma18: return "VideoTransferGamma18"
+		case VideoTransferGamma22: return "VideoTransferGamma22"
+		case VideoTransferLog100: return "VideoTransferLog100"
+		case VideoTransferAribStdB67: return "VideoTransferAribStdB67"
+		case VideoTransferGamma10: return "VideoTransferGamma10"
+		default: return fmt.Sprintf("VideoTransferFunction(%d)", e)
+	}
+}
+
 // VideoVBIParserResult wraps GstVideoVBIParserResult
 //
 // Return values for #GstVideoVBIParser
@@ -2435,6 +2968,15 @@ func (e VideoVBIParserResult) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e VideoVBIParserResult) String() string {
+	switch e {
+		case VideoVbiParserResultError: return "VideoVbiParserResultError"
+		case VideoVbiParserResultDone: return "VideoVbiParserResultDone"
+		case VideoVbiParserResultOK: return "VideoVbiParserResultOK"
+		default: return fmt.Sprintf("VideoVBIParserResult(%d)", e)
+	}
+}
+
 // NavigationModifierType wraps GstNavigationModifierType
 //
 // Flags to indicate the state of modifier keys and mouse buttons
@@ -2530,6 +3072,69 @@ func (f NavigationModifierType) InitGoValue(v *gobject.Value) {
 	v.SetFlags(int(f))
 }
 
+func (f NavigationModifierType) String() string {
+	if f == 0 {
+		return "NavigationModifierType(0)"
+	}
+
+	var parts []string
+	if (f & NavigationModifierNone) != 0 {
+		parts = append(parts, "NavigationModifierNone")
+	}
+	if (f & NavigationModifierShiftMask) != 0 {
+		parts = append(parts, "NavigationModifierShiftMask")
+	}
+	if (f & NavigationModifierLockMask) != 0 {
+		parts = append(parts, "NavigationModifierLockMask")
+	}
+	if (f & NavigationModifierControlMask) != 0 {
+		parts = append(parts, "NavigationModifierControlMask")
+	}
+	if (f & NavigationModifierMod1Mask) != 0 {
+		parts = append(parts, "NavigationModifierMod1Mask")
+	}
+	if (f & NavigationModifierMod2Mask) != 0 {
+		parts = append(parts, "NavigationModifierMod2Mask")
+	}
+	if (f & NavigationModifierMod3Mask) != 0 {
+		parts = append(parts, "NavigationModifierMod3Mask")
+	}
+	if (f & NavigationModifierMod4Mask) != 0 {
+		parts = append(parts, "NavigationModifierMod4Mask")
+	}
+	if (f & NavigationModifierMod5Mask) != 0 {
+		parts = append(parts, "NavigationModifierMod5Mask")
+	}
+	if (f & NavigationModifierButton1Mask) != 0 {
+		parts = append(parts, "NavigationModifierButton1Mask")
+	}
+	if (f & NavigationModifierButton2Mask) != 0 {
+		parts = append(parts, "NavigationModifierButton2Mask")
+	}
+	if (f & NavigationModifierButton3Mask) != 0 {
+		parts = append(parts, "NavigationModifierButton3Mask")
+	}
+	if (f & NavigationModifierButton4Mask) != 0 {
+		parts = append(parts, "NavigationModifierButton4Mask")
+	}
+	if (f & NavigationModifierButton5Mask) != 0 {
+		parts = append(parts, "NavigationModifierButton5Mask")
+	}
+	if (f & NavigationModifierSuperMask) != 0 {
+		parts = append(parts, "NavigationModifierSuperMask")
+	}
+	if (f & NavigationModifierHyperMask) != 0 {
+		parts = append(parts, "NavigationModifierHyperMask")
+	}
+	if (f & NavigationModifierMetaMask) != 0 {
+		parts = append(parts, "NavigationModifierMetaMask")
+	}
+	if (f & NavigationModifierMask) != 0 {
+		parts = append(parts, "NavigationModifierMask")
+	}
+	return "NavigationModifierType(" + strings.Join(parts, "|") + ")"
+}
+
 // VideoBufferFlags wraps GstVideoBufferFlags
 //
 // Additional video buffer flags. These flags can potentially be used on any
@@ -2619,6 +3224,45 @@ func (f VideoBufferFlags) InitGoValue(v *gobject.Value) {
 	v.SetFlags(int(f))
 }
 
+func (f VideoBufferFlags) String() string {
+	if f == 0 {
+		return "VideoBufferFlags(0)"
+	}
+
+	var parts []string
+	if (f & VideoBufferFlagInterlaced) != 0 {
+		parts = append(parts, "VideoBufferFlagInterlaced")
+	}
+	if (f & VideoBufferFlagTff) != 0 {
+		parts = append(parts, "VideoBufferFlagTff")
+	}
+	if (f & VideoBufferFlagRff) != 0 {
+		parts = append(parts, "VideoBufferFlagRff")
+	}
+	if (f & VideoBufferFlagOnefield) != 0 {
+		parts = append(parts, "VideoBufferFlagOnefield")
+	}
+	if (f & VideoBufferFlagMultipleView) != 0 {
+		parts = append(parts, "VideoBufferFlagMultipleView")
+	}
+	if (f & VideoBufferFlagFirstInBundle) != 0 {
+		parts = append(parts, "VideoBufferFlagFirstInBundle")
+	}
+	if (f & VideoBufferFlagTopField) != 0 {
+		parts = append(parts, "VideoBufferFlagTopField")
+	}
+	if (f & VideoBufferFlagBottomField) != 0 {
+		parts = append(parts, "VideoBufferFlagBottomField")
+	}
+	if (f & VideoBufferFlagMarker) != 0 {
+		parts = append(parts, "VideoBufferFlagMarker")
+	}
+	if (f & VideoBufferFlagLast) != 0 {
+		parts = append(parts, "VideoBufferFlagLast")
+	}
+	return "VideoBufferFlags(" + strings.Join(parts, "|") + ")"
+}
+
 // VideoChromaFlags wraps GstVideoChromaFlags
 //
 // Extra flags that influence the result from gst_video_chroma_resample_new().
@@ -2650,6 +3294,21 @@ func (f VideoChromaFlags) InitGoValue(v *gobject.Value) {
 	v.SetFlags(int(f))
 }
 
+func (f VideoChromaFlags) String() string {
+	if f == 0 {
+		return "VideoChromaFlags(0)"
+	}
+
+	var parts []string
+	if (f & VideoChromaFlagNone) != 0 {
+		parts = append(parts, "VideoChromaFlagNone")
+	}
+	if (f & VideoChromaFlagInterlaced) != 0 {
+		parts = append(parts, "VideoChromaFlagInterlaced")
+	}
+	return "VideoChromaFlags(" + strings.Join(parts, "|") + ")"
+}
+
 // VideoChromaSite wraps GstVideoChromaSite
 //
 // Various Chroma sitings.
@@ -2709,6 +3368,42 @@ func (f VideoChromaSite) InitGoValue(v *gobject.Value) {
 	v.SetFlags(int(f))
 }
 
+func (f VideoChromaSite) String() string {
+	if f == 0 {
+		return "VideoChromaSite(0)"
+	}
+
+	var parts []string
+	if (f & VideoChromaSiteUnknown) != 0 {
+		parts = append(parts, "VideoChromaSiteUnknown")
+	}
+	if (f & VideoChromaSiteNone) != 0 {
+		parts = append(parts, "VideoChromaSiteNone")
+	}
+	if (f & VideoChromaSiteHCosited) != 0 {
+		parts = append(parts, "VideoChromaSiteHCosited")
+	}
+	if (f & VideoChromaSiteVCosited) != 0 {
+		parts = append(parts, "VideoChromaSiteVCosited")
+	}
+	if (f & VideoChromaSiteAltLine) != 0 {
+		parts = append(parts, "VideoChromaSiteAltLine")
+	}
+	if (f & VideoChromaSiteCosited) != 0 {
+		parts = append(parts, "VideoChromaSiteCosited")
+	}
+	if (f & VideoChromaSiteJPEG) != 0 {
+		parts = append(parts, "VideoChromaSiteJPEG")
+	}
+	if (f & VideoChromaSiteMpeg2) != 0 {
+		parts = append(parts, "VideoChromaSiteMpeg2")
+	}
+	if (f & VideoChromaSiteDv) != 0 {
+		parts = append(parts, "VideoChromaSiteDv")
+	}
+	return "VideoChromaSite(" + strings.Join(parts, "|") + ")"
+}
+
 // VideoCodecFrameFlags wraps GstVideoCodecFrameFlags
 //
 // Flags for #GstVideoCodecFrame
@@ -2752,6 +3447,30 @@ func (f VideoCodecFrameFlags) InitGoValue(v *gobject.Value) {
 	v.SetFlags(int(f))
 }
 
+func (f VideoCodecFrameFlags) String() string {
+	if f == 0 {
+		return "VideoCodecFrameFlags(0)"
+	}
+
+	var parts []string
+	if (f & VideoCodecFrameFlagDecodeOnly) != 0 {
+		parts = append(parts, "VideoCodecFrameFlagDecodeOnly")
+	}
+	if (f & VideoCodecFrameFlagSyncPoint) != 0 {
+		parts = append(parts, "VideoCodecFrameFlagSyncPoint")
+	}
+	if (f & VideoCodecFrameFlagForceKeyframe) != 0 {
+		parts = append(parts, "VideoCodecFrameFlagForceKeyframe")
+	}
+	if (f & VideoCodecFrameFlagForceKeyframeHeaders) != 0 {
+		parts = append(parts, "VideoCodecFrameFlagForceKeyframeHeaders")
+	}
+	if (f & VideoCodecFrameFlagCorrupted) != 0 {
+		parts = append(parts, "VideoCodecFrameFlagCorrupted")
+	}
+	return "VideoCodecFrameFlags(" + strings.Join(parts, "|") + ")"
+}
+
 // VideoDecoderRequestSyncPointFlags wraps GstVideoDecoderRequestSyncPointFlags
 //
 // Flags to be used in combination with gst_video_decoder_request_sync_point().
@@ -2786,6 +3505,21 @@ func (f VideoDecoderRequestSyncPointFlags) InitGoValue(v *gobject.Value) {
 	v.SetFlags(int(f))
 }
 
+func (f VideoDecoderRequestSyncPointFlags) String() string {
+	if f == 0 {
+		return "VideoDecoderRequestSyncPointFlags(0)"
+	}
+
+	var parts []string
+	if (f & VideoDecoderRequestSyncPointDiscardInput) != 0 {
+		parts = append(parts, "VideoDecoderRequestSyncPointDiscardInput")
+	}
+	if (f & VideoDecoderRequestSyncPointCorruptOutput) != 0 {
+		parts = append(parts, "VideoDecoderRequestSyncPointCorruptOutput")
+	}
+	return "VideoDecoderRequestSyncPointFlags(" + strings.Join(parts, "|") + ")"
+}
+
 // VideoDitherFlags wraps GstVideoDitherFlags
 //
 // Extra flags that influence the result from gst_video_chroma_resample_new().
@@ -2821,6 +3555,24 @@ func (f VideoDitherFlags) InitGoValue(v *gobject.Value) {
 	v.SetFlags(int(f))
 }
 
+func (f VideoDitherFlags) String() string {
+	if f == 0 {
+		return "VideoDitherFlags(0)"
+	}
+
+	var parts []string
+	if (f & VideoDitherFlagNone) != 0 {
+		parts = append(parts, "VideoDitherFlagNone")
+	}
+	if (f & VideoDitherFlagInterlaced) != 0 {
+		parts = append(parts, "VideoDitherFlagInterlaced")
+	}
+	if (f & VideoDitherFlagQuantize) != 0 {
+		parts = append(parts, "VideoDitherFlagQuantize")
+	}
+	return "VideoDitherFlags(" + strings.Join(parts, "|") + ")"
+}
+
 // VideoFlags wraps GstVideoFlags
 //
 // Extra video flags
@@ -2858,6 +3610,24 @@ func (f VideoFlags) InitGoValue(v *gobject.Value) {
 	v.SetFlags(int(f))
 }
 
+func (f VideoFlags) String() string {
+	if f == 0 {
+		return "VideoFlags(0)"
+	}
+
+	var parts []string
+	if (f & VideoFlagNone) != 0 {
+		parts = append(parts, "VideoFlagNone")
+	}
+	if (f & VideoFlagVariableFPS) != 0 {
+		parts = append(parts, "VideoFlagVariableFPS")
+	}
+	if (f & VideoFlagPremultipliedAlpha) != 0 {
+		parts = append(parts, "VideoFlagPremultipliedAlpha")
+	}
+	return "VideoFlags(" + strings.Join(parts, "|") + ")"
+}
+
 // VideoFormatFlags wraps GstVideoFormatFlags
 //
 // The different video flags that a format info can have.
@@ -2930,6 +3700,45 @@ func (f VideoFormatFlags) InitGoValue(v *gobject.Value) {
 	v.SetFlags(int(f))
 }
 
+func (f VideoFormatFlags) String() string {
+	if f == 0 {
+		return "VideoFormatFlags(0)"
+	}
+
+	var parts []string
+	if (f & VideoFormatFlagYuv) != 0 {
+		parts = append(parts, "VideoFormatFlagYuv")
+	}
+	if (f & VideoFormatFlagRGB) != 0 {
+		parts = append(parts, "VideoFormatFlagRGB")
+	}
+	if (f & VideoFormatFlagGray) != 0 {
+		parts = append(parts, "VideoFormatFlagGray")
+	}
+	if (f & VideoFormatFlagAlpha) != 0 {
+		parts = append(parts, "VideoFormatFlagAlpha")
+	}
+	if (f & VideoFormatFlagLE) != 0 {
+		parts = append(parts, "VideoFormatFlagLE")
+	}
+	if (f & VideoFormatFlagPalette) != 0 {
+		parts = append(parts, "VideoFormatFlagPalette")
+	}
+	if (f & VideoFormatFlagComplex) != 0 {
+		parts = append(parts, "VideoFormatFlagComplex")
+	}
+	if (f & VideoFormatFlagUnpack) != 0 {
+		parts = append(parts, "VideoFormatFlagUnpack")
+	}
+	if (f & VideoFormatFlagTiled) != 0 {
+		parts = append(parts, "VideoFormatFlagTiled")
+	}
+	if (f & VideoFormatFlagSubtiles) != 0 {
+		parts = append(parts, "VideoFormatFlagSubtiles")
+	}
+	return "VideoFormatFlags(" + strings.Join(parts, "|") + ")"
+}
+
 // VideoFrameFlags wraps GstVideoFrameFlags
 //
 // Extra video frame flags
@@ -2997,6 +3806,42 @@ func (f VideoFrameFlags) InitGoValue(v *gobject.Value) {
 	v.SetFlags(int(f))
 }
 
+func (f VideoFrameFlags) String() string {
+	if f == 0 {
+		return "VideoFrameFlags(0)"
+	}
+
+	var parts []string
+	if (f & VideoFrameFlagNone) != 0 {
+		parts = append(parts, "VideoFrameFlagNone")
+	}
+	if (f & VideoFrameFlagInterlaced) != 0 {
+		parts = append(parts, "VideoFrameFlagInterlaced")
+	}
+	if (f & VideoFrameFlagTff) != 0 {
+		parts = append(parts, "VideoFrameFlagTff")
+	}
+	if (f & VideoFrameFlagRff) != 0 {
+		parts = append(parts, "VideoFrameFlagRff")
+	}
+	if (f & VideoFrameFlagOnefield) != 0 {
+		parts = append(parts, "VideoFrameFlagOnefield")
+	}
+	if (f & VideoFrameFlagMultipleView) != 0 {
+		parts = append(parts, "VideoFrameFlagMultipleView")
+	}
+	if (f & VideoFrameFlagFirstInBundle) != 0 {
+		parts = append(parts, "VideoFrameFlagFirstInBundle")
+	}
+	if (f & VideoFrameFlagTopField) != 0 {
+		parts = append(parts, "VideoFrameFlagTopField")
+	}
+	if (f & VideoFrameFlagBottomField) != 0 {
+		parts = append(parts, "VideoFrameFlagBottomField")
+	}
+	return "VideoFrameFlags(" + strings.Join(parts, "|") + ")"
+}
+
 // VideoFrameMapFlags wraps GstVideoFrameMapFlags
 //
 // Additional mapping flags for gst_video_frame_map().
@@ -3031,6 +3876,21 @@ func (f VideoFrameMapFlags) InitGoValue(v *gobject.Value) {
 	v.SetFlags(int(f))
 }
 
+func (f VideoFrameMapFlags) String() string {
+	if f == 0 {
+		return "VideoFrameMapFlags(0)"
+	}
+
+	var parts []string
+	if (f & VideoFrameMapFlagNoRef) != 0 {
+		parts = append(parts, "VideoFrameMapFlagNoRef")
+	}
+	if (f & VideoFrameMapFlagLast) != 0 {
+		parts = append(parts, "VideoFrameMapFlagLast")
+	}
+	return "VideoFrameMapFlags(" + strings.Join(parts, "|") + ")"
+}
+
 // VideoMultiviewFlags wraps GstVideoMultiviewFlags
 //
 // GstVideoMultiviewFlags are used to indicate extra properties of a
@@ -3104,6 +3964,39 @@ func (f VideoMultiviewFlags) InitGoValue(v *gobject.Value) {
 	v.SetFlags(int(f))
 }
 
+func (f VideoMultiviewFlags) String() string {
+	if f == 0 {
+		return "VideoMultiviewFlags(0)"
+	}
+
+	var parts []string
+	if (f & VideoMultiviewFlagsNone) != 0 {
+		parts = append(parts, "VideoMultiviewFlagsNone")
+	}
+	if (f & VideoMultiviewFlagsRightViewFirst) != 0 {
+		parts = append(parts, "VideoMultiviewFlagsRightViewFirst")
+	}
+	if (f & VideoMultiviewFlagsLeftFlipped) != 0 {
+		parts = append(parts, "VideoMultiviewFlagsLeftFlipped")
+	}
+	if (f & VideoMultiviewFlagsLeftFlopped) != 0 {
+		parts = append(parts, "VideoMultiviewFlagsLeftFlopped")
+	}
+	if (f & VideoMultiviewFlagsRightFlipped) != 0 {
+		parts = append(parts, "VideoMultiviewFlagsRightFlipped")
+	}
+	if (f & VideoMultiviewFlagsRightFlopped) != 0 {
+		parts = append(parts, "VideoMultiviewFlagsRightFlopped")
+	}
+	if (f & VideoMultiviewFlagsHalfAspect) != 0 {
+		parts = append(parts, "VideoMultiviewFlagsHalfAspect")
+	}
+	if (f & VideoMultiviewFlagsMixedMono) != 0 {
+		parts = append(parts, "VideoMultiviewFlagsMixedMono")
+	}
+	return "VideoMultiviewFlags(" + strings.Join(parts, "|") + ")"
+}
+
 // VideoOverlayFormatFlags wraps GstVideoOverlayFormatFlags
 //
 // Overlay format flags.
@@ -3139,6 +4032,24 @@ func (f VideoOverlayFormatFlags) InitGoValue(v *gobject.Value) {
 	v.SetFlags(int(f))
 }
 
+func (f VideoOverlayFormatFlags) String() string {
+	if f == 0 {
+		return "VideoOverlayFormatFlags(0)"
+	}
+
+	var parts []string
+	if (f & VideoOverlayFormatFlagNone) != 0 {
+		parts = append(parts, "VideoOverlayFormatFlagNone")
+	}
+	if (f & VideoOverlayFormatFlagPremultipliedAlpha) != 0 {
+		parts = append(parts, "VideoOverlayFormatFlagPremultipliedAlpha")
+	}
+	if (f & VideoOverlayFormatFlagGlobalAlpha) != 0 {
+		parts = append(parts, "VideoOverlayFormatFlagGlobalAlpha")
+	}
+	return "VideoOverlayFormatFlags(" + strings.Join(parts, "|") + ")"
+}
+
 // VideoPackFlags wraps GstVideoPackFlags
 //
 // The different flags that can be used when packing and unpacking.
@@ -3180,6 +4091,24 @@ func (f VideoPackFlags) InitGoValue(v *gobject.Value) {
 	v.SetFlags(int(f))
 }
 
+func (f VideoPackFlags) String() string {
+	if f == 0 {
+		return "VideoPackFlags(0)"
+	}
+
+	var parts []string
+	if (f & VideoPackFlagNone) != 0 {
+		parts = append(parts, "VideoPackFlagNone")
+	}
+	if (f & VideoPackFlagTruncateRange) != 0 {
+		parts = append(parts, "VideoPackFlagTruncateRange")
+	}
+	if (f & VideoPackFlagInterlaced) != 0 {
+		parts = append(parts, "VideoPackFlagInterlaced")
+	}
+	return "VideoPackFlags(" + strings.Join(parts, "|") + ")"
+}
+
 // VideoResamplerFlags wraps GstVideoResamplerFlags
 //
 // Different resampler flags.
@@ -3213,6 +4142,21 @@ func (f VideoResamplerFlags) InitGoValue(v *gobject.Value) {
 	v.SetFlags(int(f))
 }
 
+func (f VideoResamplerFlags) String() string {
+	if f == 0 {
+		return "VideoResamplerFlags(0)"
+	}
+
+	var parts []string
+	if (f & VideoResamplerFlagNone) != 0 {
+		parts = append(parts, "VideoResamplerFlagNone")
+	}
+	if (f & VideoResamplerFlagHalfTaps) != 0 {
+		parts = append(parts, "VideoResamplerFlagHalfTaps")
+	}
+	return "VideoResamplerFlags(" + strings.Join(parts, "|") + ")"
+}
+
 // VideoScalerFlags wraps GstVideoScalerFlags
 //
 // Different scale flags.
@@ -3244,6 +4188,21 @@ func (f VideoScalerFlags) InitGoValue(v *gobject.Value) {
 	v.SetFlags(int(f))
 }
 
+func (f VideoScalerFlags) String() string {
+	if f == 0 {
+		return "VideoScalerFlags(0)"
+	}
+
+	var parts []string
+	if (f & VideoScalerFlagNone) != 0 {
+		parts = append(parts, "VideoScalerFlagNone")
+	}
+	if (f & VideoScalerFlagInterlaced) != 0 {
+		parts = append(parts, "VideoScalerFlagInterlaced")
+	}
+	return "VideoScalerFlags(" + strings.Join(parts, "|") + ")"
+}
+
 // VideoTimeCodeFlags wraps GstVideoTimeCodeFlags
 //
 // Flags related to the time code information.
@@ -3280,6 +4239,24 @@ func (f VideoTimeCodeFlags) InitGoValue(v *gobject.Value) {
 	v.SetFlags(int(f))
 }
 
+func (f VideoTimeCodeFlags) String() string {
+	if f == 0 {
+		return "VideoTimeCodeFlags(0)"
+	}
+
+	var parts []string
+	if (f & VideoTimeCodeFlagsNone) != 0 {
+		parts = append(parts, "VideoTimeCodeFlagsNone")
+	}
+	if (f & VideoTimeCodeFlagsDropFrame) != 0 {
+		parts = append(parts, "VideoTimeCodeFlagsDropFrame")
+	}
+	if (f & VideoTimeCodeFlagsInterlaced) != 0 {
+		parts = append(parts, "VideoTimeCodeFlagsInterlaced")
+	}
+	return "VideoTimeCodeFlags(" + strings.Join(parts, "|") + ")"
+}
+
 // VideoConvertSampleCallback wraps GstVideoConvertSampleCallback
 type VideoConvertSampleCallback func(sample *gst.Sample, err error)
 
@@ -5941,7 +6918,7 @@ func UnsafeNavigationToGlibFull(c Navigation) unsafe.Pointer {
 	return gobject.UnsafeObjectToGlibFull(&i.Instance)
 }
 
-// NavigationInstanceEventGetCoordinates wraps gst_navigation_event_get_coordinates
+// NavigationEventGetCoordinates wraps gst_navigation_event_get_coordinates
 // 
 // The function takes the following parameters:
 // 
@@ -5956,7 +6933,7 @@ func UnsafeNavigationToGlibFull(c Navigation) unsafe.Pointer {
 // 	- goret bool 
 //
 // Try to retrieve x and y coordinates of a #GstNavigation event.
-func NavigationInstanceEventGetCoordinates(event *gst.Event) (float64, float64, bool) {
+func NavigationEventGetCoordinates(event *gst.Event) (float64, float64, bool) {
 	var carg1 *C.GstEvent // in, none, converted
 	var carg2 C.gdouble   // out, full, casted
 	var carg3 C.gdouble   // out, full, casted
@@ -5980,7 +6957,7 @@ func NavigationInstanceEventGetCoordinates(event *gst.Event) (float64, float64,
 	return x, y, goret
 }
 
-// NavigationInstanceEventGetType wraps gst_navigation_event_get_type
+// NavigationEventGetType wraps gst_navigation_event_get_type
 // 
 // The function takes the following parameters:
 // 
@@ -5992,7 +6969,7 @@ func NavigationInstanceEventGetCoordinates(event *gst.Event) (float64, float64,
 //
 // Inspect a #GstEvent and return the #GstNavigationEventType of the event, or
 // #GST_NAVIGATION_EVENT_INVALID if the event is not a #GstNavigation event.
-func NavigationInstanceEventGetType(event *gst.Event) NavigationEventType {
+func NavigationEventGetType(event *gst.Event) NavigationEventType {
 	var carg1 *C.GstEvent              // in, none, converted
 	var cret  C.GstNavigationEventType // return, none, casted
 
@@ -6008,7 +6985,7 @@ func NavigationInstanceEventGetType(event *gst.Event) NavigationEventType {
 	return goret
 }
 
-// NavigationInstanceEventNewCommand wraps gst_navigation_event_new_command
+// NavigationEventNewCommand wraps gst_navigation_event_new_command
 // 
 // The function takes the following parameters:
 // 
@@ -6019,7 +6996,7 @@ func NavigationInstanceEventGetType(event *gst.Event) NavigationEventType {
 // 	- goret *gst.Event 
 //
 // Create a new navigation event given navigation command..
-func NavigationInstanceEventNewCommand(command NavigationCommand) *gst.Event {
+func NavigationEventNewCommand(command NavigationCommand) *gst.Event {
 	var carg1 C.GstNavigationCommand // in, none, casted
 	var cret  *C.GstEvent            // return, full, converted
 
@@ -6035,7 +7012,7 @@ func NavigationInstanceEventNewCommand(command NavigationCommand) *gst.Event {
 	return goret
 }
 
-// NavigationInstanceEventNewKeyPress wraps gst_navigation_event_new_key_press
+// NavigationEventNewKeyPress wraps gst_navigation_event_new_key_press
 // 
 // The function takes the following parameters:
 // 
@@ -6048,7 +7025,7 @@ func NavigationInstanceEventNewCommand(command NavigationCommand) *gst.Event {
 // 	- goret *gst.Event 
 //
 // Create a new navigation event for the given key press.
-func NavigationInstanceEventNewKeyPress(key string, state NavigationModifierType) *gst.Event {
+func NavigationEventNewKeyPress(key string, state NavigationModifierType) *gst.Event {
 	var carg1 *C.gchar                    // in, none, string, casted *C.gchar
 	var carg2 C.GstNavigationModifierType // in, none, casted
 	var cret  *C.GstEvent                 // return, full, converted
@@ -6068,7 +7045,7 @@ func NavigationInstanceEventNewKeyPress(key string, state NavigationModifierType
 	return goret
 }
 
-// NavigationInstanceEventNewKeyRelease wraps gst_navigation_event_new_key_release
+// NavigationEventNewKeyRelease wraps gst_navigation_event_new_key_release
 // 
 // The function takes the following parameters:
 // 
@@ -6081,7 +7058,7 @@ func NavigationInstanceEventNewKeyPress(key string, state NavigationModifierType
 // 	- goret *gst.Event 
 //
 // Create a new navigation event for the given key release.
-func NavigationInstanceEventNewKeyRelease(key string, state NavigationModifierType) *gst.Event {
+func NavigationEventNewKeyRelease(key string, state NavigationModifierType) *gst.Event {
 	var carg1 *C.gchar                    // in, none, string, casted *C.gchar
 	var carg2 C.GstNavigationModifierType // in, none, casted
 	var cret  *C.GstEvent                 // return, full, converted
@@ -6101,7 +7078,7 @@ func NavigationInstanceEventNewKeyRelease(key string, state NavigationModifierTy
 	return goret
 }
 
-// NavigationInstanceEventNewMouseButtonPress wraps gst_navigation_event_new_mouse_button_press
+// NavigationEventNewMouseButtonPress wraps gst_navigation_event_new_mouse_button_press
 // 
 // The function takes the following parameters:
 // 
@@ -6116,7 +7093,7 @@ func NavigationInstanceEventNewKeyRelease(key string, state NavigationModifierTy
 // 	- goret *gst.Event 
 //
 // Create a new navigation event for the given key mouse button press.
-func NavigationInstanceEventNewMouseButtonPress(button int, x float64, y float64, state NavigationModifierType) *gst.Event {
+func NavigationEventNewMouseButtonPress(button int, x float64, y float64, state NavigationModifierType) *gst.Event {
 	var carg1 C.gint                      // in, none, casted
 	var carg2 C.gdouble                   // in, none, casted
 	var carg3 C.gdouble                   // in, none, casted
@@ -6141,7 +7118,7 @@ func NavigationInstanceEventNewMouseButtonPress(button int, x float64, y float64
 	return goret
 }
 
-// NavigationInstanceEventNewMouseButtonRelease wraps gst_navigation_event_new_mouse_button_release
+// NavigationEventNewMouseButtonRelease wraps gst_navigation_event_new_mouse_button_release
 // 
 // The function takes the following parameters:
 // 
@@ -6156,7 +7133,7 @@ func NavigationInstanceEventNewMouseButtonPress(button int, x float64, y float64
 // 	- goret *gst.Event 
 //
 // Create a new navigation event for the given key mouse button release.
-func NavigationInstanceEventNewMouseButtonRelease(button int, x float64, y float64, state NavigationModifierType) *gst.Event {
+func NavigationEventNewMouseButtonRelease(button int, x float64, y float64, state NavigationModifierType) *gst.Event {
 	var carg1 C.gint                      // in, none, casted
 	var carg2 C.gdouble                   // in, none, casted
 	var carg3 C.gdouble                   // in, none, casted
@@ -6181,7 +7158,7 @@ func NavigationInstanceEventNewMouseButtonRelease(button int, x float64, y float
 	return goret
 }
 
-// NavigationInstanceEventNewMouseMove wraps gst_navigation_event_new_mouse_move
+// NavigationEventNewMouseMove wraps gst_navigation_event_new_mouse_move
 // 
 // The function takes the following parameters:
 // 
@@ -6195,7 +7172,7 @@ func NavigationInstanceEventNewMouseButtonRelease(button int, x float64, y float
 // 	- goret *gst.Event 
 //
 // Create a new navigation event for the new mouse location.
-func NavigationInstanceEventNewMouseMove(x float64, y float64, state NavigationModifierType) *gst.Event {
+func NavigationEventNewMouseMove(x float64, y float64, state NavigationModifierType) *gst.Event {
 	var carg1 C.gdouble                   // in, none, casted
 	var carg2 C.gdouble                   // in, none, casted
 	var carg3 C.GstNavigationModifierType // in, none, casted
@@ -6217,7 +7194,7 @@ func NavigationInstanceEventNewMouseMove(x float64, y float64, state NavigationM
 	return goret
 }
 
-// NavigationInstanceEventNewMouseScroll wraps gst_navigation_event_new_mouse_scroll
+// NavigationEventNewMouseScroll wraps gst_navigation_event_new_mouse_scroll
 // 
 // The function takes the following parameters:
 // 
@@ -6233,7 +7210,7 @@ func NavigationInstanceEventNewMouseMove(x float64, y float64, state NavigationM
 // 	- goret *gst.Event 
 //
 // Create a new navigation event for the mouse scroll.
-func NavigationInstanceEventNewMouseScroll(x float64, y float64, deltaX float64, deltaY float64, state NavigationModifierType) *gst.Event {
+func NavigationEventNewMouseScroll(x float64, y float64, deltaX float64, deltaY float64, state NavigationModifierType) *gst.Event {
 	var carg1 C.gdouble                   // in, none, casted
 	var carg2 C.gdouble                   // in, none, casted
 	var carg3 C.gdouble                   // in, none, casted
@@ -6261,7 +7238,7 @@ func NavigationInstanceEventNewMouseScroll(x float64, y float64, deltaX float64,
 	return goret
 }
 
-// NavigationInstanceEventNewTouchCancel wraps gst_navigation_event_new_touch_cancel
+// NavigationEventNewTouchCancel wraps gst_navigation_event_new_touch_cancel
 // 
 // The function takes the following parameters:
 // 
@@ -6276,7 +7253,7 @@ func NavigationInstanceEventNewMouseScroll(x float64, y float64, deltaX float64,
 // points are cancelled and should be discarded. For example, under Wayland
 // this event might be sent when a swipe passes the threshold to be recognized
 // as a gesture by the compositor.
-func NavigationInstanceEventNewTouchCancel(state NavigationModifierType) *gst.Event {
+func NavigationEventNewTouchCancel(state NavigationModifierType) *gst.Event {
 	var carg1 C.GstNavigationModifierType // in, none, casted
 	var cret  *C.GstEvent                 // return, full, converted
 
@@ -6292,7 +7269,7 @@ func NavigationInstanceEventNewTouchCancel(state NavigationModifierType) *gst.Ev
 	return goret
 }
 
-// NavigationInstanceEventNewTouchDown wraps gst_navigation_event_new_touch_down
+// NavigationEventNewTouchDown wraps gst_navigation_event_new_touch_down
 // 
 // The function takes the following parameters:
 // 
@@ -6311,7 +7288,7 @@ func NavigationInstanceEventNewTouchCancel(state NavigationModifierType) *gst.Ev
 // 	- goret *gst.Event 
 //
 // Create a new navigation event for an added touch point.
-func NavigationInstanceEventNewTouchDown(identifier uint, x float64, y float64, pressure float64, state NavigationModifierType) *gst.Event {
+func NavigationEventNewTouchDown(identifier uint, x float64, y float64, pressure float64, state NavigationModifierType) *gst.Event {
 	var carg1 C.guint                     // in, none, casted
 	var carg2 C.gdouble                   // in, none, casted
 	var carg3 C.gdouble                   // in, none, casted
@@ -6339,7 +7316,7 @@ func NavigationInstanceEventNewTouchDown(identifier uint, x float64, y float64,
 	return goret
 }
 
-// NavigationInstanceEventNewTouchFrame wraps gst_navigation_event_new_touch_frame
+// NavigationEventNewTouchFrame wraps gst_navigation_event_new_touch_frame
 // 
 // The function takes the following parameters:
 // 
@@ -6353,7 +7330,7 @@ func NavigationInstanceEventNewTouchDown(identifier uint, x float64, y float64,
 // Create a new navigation event signalling the end of a touch frame. Touch
 // frames signal that all previous down, motion and up events not followed by
 // another touch frame event already should be considered simultaneous.
-func NavigationInstanceEventNewTouchFrame(state NavigationModifierType) *gst.Event {
+func NavigationEventNewTouchFrame(state NavigationModifierType) *gst.Event {
 	var carg1 C.GstNavigationModifierType // in, none, casted
 	var cret  *C.GstEvent                 // return, full, converted
 
@@ -6369,7 +7346,7 @@ func NavigationInstanceEventNewTouchFrame(state NavigationModifierType) *gst.Eve
 	return goret
 }
 
-// NavigationInstanceEventNewTouchMotion wraps gst_navigation_event_new_touch_motion
+// NavigationEventNewTouchMotion wraps gst_navigation_event_new_touch_motion
 // 
 // The function takes the following parameters:
 // 
@@ -6387,7 +7364,7 @@ func NavigationInstanceEventNewTouchFrame(state NavigationModifierType) *gst.Eve
 // 	- goret *gst.Event 
 //
 // Create a new navigation event for a moved touch point.
-func NavigationInstanceEventNewTouchMotion(identifier uint, x float64, y float64, pressure float64, state NavigationModifierType) *gst.Event {
+func NavigationEventNewTouchMotion(identifier uint, x float64, y float64, pressure float64, state NavigationModifierType) *gst.Event {
 	var carg1 C.guint                     // in, none, casted
 	var carg2 C.gdouble                   // in, none, casted
 	var carg3 C.gdouble                   // in, none, casted
@@ -6415,7 +7392,7 @@ func NavigationInstanceEventNewTouchMotion(identifier uint, x float64, y float64
 	return goret
 }
 
-// NavigationInstanceEventNewTouchUp wraps gst_navigation_event_new_touch_up
+// NavigationEventNewTouchUp wraps gst_navigation_event_new_touch_up
 // 
 // The function takes the following parameters:
 // 
@@ -6432,7 +7409,7 @@ func NavigationInstanceEventNewTouchMotion(identifier uint, x float64, y float64
 // 	- goret *gst.Event 
 //
 // Create a new navigation event for a removed touch point.
-func NavigationInstanceEventNewTouchUp(identifier uint, x float64, y float64, state NavigationModifierType) *gst.Event {
+func NavigationEventNewTouchUp(identifier uint, x float64, y float64, state NavigationModifierType) *gst.Event {
 	var carg1 C.guint                     // in, none, casted
 	var carg2 C.gdouble                   // in, none, casted
 	var carg3 C.gdouble                   // in, none, casted
@@ -6457,7 +7434,7 @@ func NavigationInstanceEventNewTouchUp(identifier uint, x float64, y float64, st
 	return goret
 }
 
-// NavigationInstanceEventParseCommand wraps gst_navigation_event_parse_command
+// NavigationEventParseCommand wraps gst_navigation_event_parse_command
 // 
 // The function takes the following parameters:
 // 
@@ -6471,7 +7448,7 @@ func NavigationInstanceEventNewTouchUp(identifier uint, x float64, y float64, st
 //
 // Inspect a #GstNavigation command event and retrieve the enum value of the
 // associated command.
-func NavigationInstanceEventParseCommand(event *gst.Event) (NavigationCommand, bool) {
+func NavigationEventParseCommand(event *gst.Event) (NavigationCommand, bool) {
 	var carg1 *C.GstEvent            // in, none, converted
 	var carg2 C.GstNavigationCommand // out, full, casted
 	var cret  C.gboolean             // return
@@ -6492,7 +7469,7 @@ func NavigationInstanceEventParseCommand(event *gst.Event) (NavigationCommand, b
 	return command, goret
 }
 
-// NavigationInstanceEventParseKeyEvent wraps gst_navigation_event_parse_key_event
+// NavigationEventParseKeyEvent wraps gst_navigation_event_parse_key_event
 // 
 // The function takes the following parameters:
 // 
@@ -6509,7 +7486,7 @@ func NavigationInstanceEventParseCommand(event *gst.Event) (NavigationCommand, b
 // [press](GST_NAVIGATION_EVENT_KEY_PRESS) and
 // [release](GST_NAVIGATION_KEY_PRESS) events are generated even if those states are
 // present on all other related events
-func NavigationInstanceEventParseKeyEvent(event *gst.Event) (string, bool) {
+func NavigationEventParseKeyEvent(event *gst.Event) (string, bool) {
 	var carg1 *C.GstEvent // in, none, converted
 	var carg2 *C.gchar    // out, none, string, casted *C.gchar
 	var cret  C.gboolean  // return
@@ -6530,7 +7507,7 @@ func NavigationInstanceEventParseKeyEvent(event *gst.Event) (string, bool) {
 	return key, goret
 }
 
-// NavigationInstanceEventParseMouseButtonEvent wraps gst_navigation_event_parse_mouse_button_event
+// NavigationEventParseMouseButtonEvent wraps gst_navigation_event_parse_mouse_button_event
 // 
 // The function takes the following parameters:
 // 
@@ -6549,7 +7526,7 @@ func NavigationInstanceEventParseKeyEvent(event *gst.Event) (string, bool) {
 // Retrieve the details of either a #GstNavigation mouse button press event or
 // a mouse button release event. Determine which type the event is using
 // gst_navigation_event_get_type() to retrieve the #GstNavigationEventType.
-func NavigationInstanceEventParseMouseButtonEvent(event *gst.Event) (int, float64, float64, bool) {
+func NavigationEventParseMouseButtonEvent(event *gst.Event) (int, float64, float64, bool) {
 	var carg1 *C.GstEvent // in, none, converted
 	var carg2 C.gint      // out, full, casted
 	var carg3 C.gdouble   // out, full, casted
@@ -6576,7 +7553,7 @@ func NavigationInstanceEventParseMouseButtonEvent(event *gst.Event) (int, float6
 	return button, x, y, goret
 }
 
-// NavigationInstanceEventParseMouseMoveEvent wraps gst_navigation_event_parse_mouse_move_event
+// NavigationEventParseMouseMoveEvent wraps gst_navigation_event_parse_mouse_move_event
 // 
 // The function takes the following parameters:
 // 
@@ -6592,7 +7569,7 @@ func NavigationInstanceEventParseMouseButtonEvent(event *gst.Event) (int, float6
 //
 // Inspect a #GstNavigation mouse movement event and extract the coordinates
 // of the event.
-func NavigationInstanceEventParseMouseMoveEvent(event *gst.Event) (float64, float64, bool) {
+func NavigationEventParseMouseMoveEvent(event *gst.Event) (float64, float64, bool) {
 	var carg1 *C.GstEvent // in, none, converted
 	var carg2 C.gdouble   // out, full, casted
 	var carg3 C.gdouble   // out, full, casted
@@ -6616,7 +7593,7 @@ func NavigationInstanceEventParseMouseMoveEvent(event *gst.Event) (float64, floa
 	return x, y, goret
 }
 
-// NavigationInstanceEventParseMouseScrollEvent wraps gst_navigation_event_parse_mouse_scroll_event
+// NavigationEventParseMouseScrollEvent wraps gst_navigation_event_parse_mouse_scroll_event
 // 
 // The function takes the following parameters:
 // 
@@ -6636,7 +7613,7 @@ func NavigationInstanceEventParseMouseMoveEvent(event *gst.Event) (float64, floa
 //
 // Inspect a #GstNavigation mouse scroll event and extract the coordinates
 // of the event.
-func NavigationInstanceEventParseMouseScrollEvent(event *gst.Event) (float64, float64, float64, float64, bool) {
+func NavigationEventParseMouseScrollEvent(event *gst.Event) (float64, float64, float64, float64, bool) {
 	var carg1 *C.GstEvent // in, none, converted
 	var carg2 C.gdouble   // out, full, casted
 	var carg3 C.gdouble   // out, full, casted
@@ -6666,7 +7643,7 @@ func NavigationInstanceEventParseMouseScrollEvent(event *gst.Event) (float64, fl
 	return x, y, deltaX, deltaY, goret
 }
 
-// NavigationInstanceEventParseTouchEvent wraps gst_navigation_event_parse_touch_event
+// NavigationEventParseTouchEvent wraps gst_navigation_event_parse_touch_event
 // 
 // The function takes the following parameters:
 // 
@@ -6688,7 +7665,7 @@ func NavigationInstanceEventParseMouseScrollEvent(event *gst.Event) (float64, fl
 // Retrieve the details of a #GstNavigation touch-down or touch-motion event.
 // Determine which type the event is using gst_navigation_event_get_type()
 // to retrieve the #GstNavigationEventType.
-func NavigationInstanceEventParseTouchEvent(event *gst.Event) (uint, float64, float64, float64, bool) {
+func NavigationEventParseTouchEvent(event *gst.Event) (uint, float64, float64, float64, bool) {
 	var carg1 *C.GstEvent // in, none, converted
 	var carg2 C.guint     // out, full, casted
 	var carg3 C.gdouble   // out, full, casted
@@ -6718,7 +7695,7 @@ func NavigationInstanceEventParseTouchEvent(event *gst.Event) (uint, float64, fl
 	return identifier, x, y, pressure, goret
 }
 
-// NavigationInstanceEventParseTouchUpEvent wraps gst_navigation_event_parse_touch_up_event
+// NavigationEventParseTouchUpEvent wraps gst_navigation_event_parse_touch_up_event
 // 
 // The function takes the following parameters:
 // 
@@ -6735,7 +7712,7 @@ func NavigationInstanceEventParseTouchEvent(event *gst.Event) (uint, float64, fl
 // 	- goret bool 
 //
 // Retrieve the details of a #GstNavigation touch-up event.
-func NavigationInstanceEventParseTouchUpEvent(event *gst.Event) (uint, float64, float64, bool) {
+func NavigationEventParseTouchUpEvent(event *gst.Event) (uint, float64, float64, bool) {
 	var carg1 *C.GstEvent // in, none, converted
 	var carg2 C.guint     // out, full, casted
 	var carg3 C.gdouble   // out, full, casted
@@ -6762,7 +7739,7 @@ func NavigationInstanceEventParseTouchUpEvent(event *gst.Event) (uint, float64,
 	return identifier, x, y, goret
 }
 
-// NavigationInstanceEventSetCoordinates wraps gst_navigation_event_set_coordinates
+// NavigationEventSetCoordinates wraps gst_navigation_event_set_coordinates
 // 
 // The function takes the following parameters:
 // 
@@ -6776,7 +7753,7 @@ func NavigationInstanceEventParseTouchUpEvent(event *gst.Event) (uint, float64,
 //
 // Try to set x and y coordinates on a #GstNavigation event. The event must
 // be writable.
-func NavigationInstanceEventSetCoordinates(event *gst.Event, x float64, y float64) bool {
+func NavigationEventSetCoordinates(event *gst.Event, x float64, y float64) bool {
 	var carg1 *C.GstEvent // in, none, converted
 	var carg2 C.gdouble   // in, none, casted
 	var carg3 C.gdouble   // in, none, casted
@@ -6800,7 +7777,7 @@ func NavigationInstanceEventSetCoordinates(event *gst.Event, x float64, y float6
 	return goret
 }
 
-// NavigationInstanceMessageGetType wraps gst_navigation_message_get_type
+// NavigationMessageGetType wraps gst_navigation_message_get_type
 // 
 // The function takes the following parameters:
 // 
@@ -6812,7 +7789,7 @@ func NavigationInstanceEventSetCoordinates(event *gst.Event, x float64, y float6
 //
 // Check a bus message to see if it is a #GstNavigation event, and return
 // the #GstNavigationMessageType identifying the type of the message if so.
-func NavigationInstanceMessageGetType(message *gst.Message) NavigationMessageType {
+func NavigationMessageGetType(message *gst.Message) NavigationMessageType {
 	var carg1 *C.GstMessage              // in, none, converted
 	var cret  C.GstNavigationMessageType // return, none, casted
 
@@ -6828,7 +7805,7 @@ func NavigationInstanceMessageGetType(message *gst.Message) NavigationMessageTyp
 	return goret
 }
 
-// NavigationInstanceMessageNewAnglesChanged wraps gst_navigation_message_new_angles_changed
+// NavigationMessageNewAnglesChanged wraps gst_navigation_message_new_angles_changed
 // 
 // The function takes the following parameters:
 // 
@@ -6844,7 +7821,7 @@ func NavigationInstanceMessageGetType(message *gst.Message) NavigationMessageTyp
 // #GST_NAVIGATION_MESSAGE_ANGLES_CHANGED for notifying an application
 // that the current angle, or current number of angles available in a
 // multiangle video has changed.
-func NavigationInstanceMessageNewAnglesChanged(src gst.Object, curAngle uint, nAngles uint) *gst.Message {
+func NavigationMessageNewAnglesChanged(src gst.Object, curAngle uint, nAngles uint) *gst.Message {
 	var carg1 *C.GstObject  // in, none, converted
 	var carg2 C.guint       // in, none, casted
 	var carg3 C.guint       // in, none, casted
@@ -6866,7 +7843,7 @@ func NavigationInstanceMessageNewAnglesChanged(src gst.Object, curAngle uint, nA
 	return goret
 }
 
-// NavigationInstanceMessageNewCommandsChanged wraps gst_navigation_message_new_commands_changed
+// NavigationMessageNewCommandsChanged wraps gst_navigation_message_new_commands_changed
 // 
 // The function takes the following parameters:
 // 
@@ -6878,7 +7855,7 @@ func NavigationInstanceMessageNewAnglesChanged(src gst.Object, curAngle uint, nA
 //
 // Creates a new #GstNavigation message with type
 // #GST_NAVIGATION_MESSAGE_COMMANDS_CHANGED
-func NavigationInstanceMessageNewCommandsChanged(src gst.Object) *gst.Message {
+func NavigationMessageNewCommandsChanged(src gst.Object) *gst.Message {
 	var carg1 *C.GstObject  // in, none, converted
 	var cret  *C.GstMessage // return, full, converted
 
@@ -6894,7 +7871,7 @@ func NavigationInstanceMessageNewCommandsChanged(src gst.Object) *gst.Message {
 	return goret
 }
 
-// NavigationInstanceMessageNewEvent wraps gst_navigation_message_new_event
+// NavigationMessageNewEvent wraps gst_navigation_message_new_event
 // 
 // The function takes the following parameters:
 // 
@@ -6907,7 +7884,7 @@ func NavigationInstanceMessageNewCommandsChanged(src gst.Object) *gst.Message {
 //
 // Creates a new #GstNavigation message with type
 // #GST_NAVIGATION_MESSAGE_EVENT.
-func NavigationInstanceMessageNewEvent(src gst.Object, event *gst.Event) *gst.Message {
+func NavigationMessageNewEvent(src gst.Object, event *gst.Event) *gst.Message {
 	var carg1 *C.GstObject  // in, none, converted
 	var carg2 *C.GstEvent   // in, none, converted
 	var cret  *C.GstMessage // return, full, converted
@@ -6926,7 +7903,7 @@ func NavigationInstanceMessageNewEvent(src gst.Object, event *gst.Event) *gst.Me
 	return goret
 }
 
-// NavigationInstanceMessageNewMouseOver wraps gst_navigation_message_new_mouse_over
+// NavigationMessageNewMouseOver wraps gst_navigation_message_new_mouse_over
 // 
 // The function takes the following parameters:
 // 
@@ -6940,7 +7917,7 @@ func NavigationInstanceMessageNewEvent(src gst.Object, event *gst.Event) *gst.Me
 //
 // Creates a new #GstNavigation message with type
 // #GST_NAVIGATION_MESSAGE_MOUSE_OVER.
-func NavigationInstanceMessageNewMouseOver(src gst.Object, active bool) *gst.Message {
+func NavigationMessageNewMouseOver(src gst.Object, active bool) *gst.Message {
 	var carg1 *C.GstObject  // in, none, converted
 	var carg2 C.gboolean    // in
 	var cret  *C.GstMessage // return, full, converted
@@ -6961,7 +7938,7 @@ func NavigationInstanceMessageNewMouseOver(src gst.Object, active bool) *gst.Mes
 	return goret
 }
 
-// NavigationInstanceMessageParseAnglesChanged wraps gst_navigation_message_parse_angles_changed
+// NavigationMessageParseAnglesChanged wraps gst_navigation_message_parse_angles_changed
 // 
 // The function takes the following parameters:
 // 
@@ -6977,7 +7954,7 @@ func NavigationInstanceMessageNewMouseOver(src gst.Object, active bool) *gst.Mes
 //
 // Parse a #GstNavigation message of type GST_NAVIGATION_MESSAGE_ANGLES_CHANGED
 // and extract the @cur_angle and @n_angles parameters.
-func NavigationInstanceMessageParseAnglesChanged(message *gst.Message) (uint, uint, bool) {
+func NavigationMessageParseAnglesChanged(message *gst.Message) (uint, uint, bool) {
 	var carg1 *C.GstMessage // in, none, converted
 	var carg2 C.guint       // out, full, casted
 	var carg3 C.guint       // out, full, casted
@@ -7001,7 +7978,7 @@ func NavigationInstanceMessageParseAnglesChanged(message *gst.Message) (uint, ui
 	return curAngle, nAngles, goret
 }
 
-// NavigationInstanceMessageParseEvent wraps gst_navigation_message_parse_event
+// NavigationMessageParseEvent wraps gst_navigation_message_parse_event
 // 
 // The function takes the following parameters:
 // 
@@ -7016,7 +7993,7 @@ func NavigationInstanceMessageParseAnglesChanged(message *gst.Message) (uint, ui
 // Parse a #GstNavigation message of type #GST_NAVIGATION_MESSAGE_EVENT
 // and extract contained #GstEvent. The caller must unref the @event when done
 // with it.
-func NavigationInstanceMessageParseEvent(message *gst.Message) (*gst.Event, bool) {
+func NavigationMessageParseEvent(message *gst.Message) (*gst.Event, bool) {
 	var carg1 *C.GstMessage // in, none, converted
 	var carg2 *C.GstEvent   // out, full, converted
 	var cret  C.gboolean    // return
@@ -7037,7 +8014,7 @@ func NavigationInstanceMessageParseEvent(message *gst.Message) (*gst.Event, bool
 	return event, goret
 }
 
-// NavigationInstanceMessageParseMouseOver wraps gst_navigation_message_parse_mouse_over
+// NavigationMessageParseMouseOver wraps gst_navigation_message_parse_mouse_over
 // 
 // The function takes the following parameters:
 // 
@@ -7052,7 +8029,7 @@ func NavigationInstanceMessageParseEvent(message *gst.Message) (*gst.Event, bool
 // Parse a #GstNavigation message of type #GST_NAVIGATION_MESSAGE_MOUSE_OVER
 // and extract the active/inactive flag. If the mouse over event is marked
 // active, it indicates that the mouse is over a clickable area.
-func NavigationInstanceMessageParseMouseOver(message *gst.Message) (bool, bool) {
+func NavigationMessageParseMouseOver(message *gst.Message) (bool, bool) {
 	var carg1 *C.GstMessage // in, none, converted
 	var carg2 C.gboolean    // out
 	var cret  C.gboolean    // return
@@ -7075,7 +8052,7 @@ func NavigationInstanceMessageParseMouseOver(message *gst.Message) (bool, bool)
 	return active, goret
 }
 
-// NavigationInstanceQueryGetType wraps gst_navigation_query_get_type
+// NavigationQueryGetType wraps gst_navigation_query_get_type
 // 
 // The function takes the following parameters:
 // 
@@ -7087,7 +8064,7 @@ func NavigationInstanceMessageParseMouseOver(message *gst.Message) (bool, bool)
 //
 // Inspect a #GstQuery and return the #GstNavigationQueryType associated with
 // it if it is a #GstNavigation query.
-func NavigationInstanceQueryGetType(query *gst.Query) NavigationQueryType {
+func NavigationQueryGetType(query *gst.Query) NavigationQueryType {
 	var carg1 *C.GstQuery              // in, none, converted
 	var cret  C.GstNavigationQueryType // return, none, casted
 
@@ -7103,7 +8080,7 @@ func NavigationInstanceQueryGetType(query *gst.Query) NavigationQueryType {
 	return goret
 }
 
-// NavigationInstanceQueryNewAngles wraps gst_navigation_query_new_angles
+// NavigationQueryNewAngles wraps gst_navigation_query_new_angles
 // The function returns the following values:
 // 
 // 	- goret *gst.Query 
@@ -7111,7 +8088,7 @@ func NavigationInstanceQueryGetType(query *gst.Query) NavigationQueryType {
 // Create a new #GstNavigation angles query. When executed, it will
 // query the pipeline for the set of currently available angles, which may be
 // greater than one in a multiangle video.
-func NavigationInstanceQueryNewAngles() *gst.Query {
+func NavigationQueryNewAngles() *gst.Query {
 	var cret *C.GstQuery // return, full, converted
 
 	cret = C.gst_navigation_query_new_angles()
@@ -7123,14 +8100,14 @@ func NavigationInstanceQueryNewAngles() *gst.Query {
 	return goret
 }
 
-// NavigationInstanceQueryNewCommands wraps gst_navigation_query_new_commands
+// NavigationQueryNewCommands wraps gst_navigation_query_new_commands
 // The function returns the following values:
 // 
 // 	- goret *gst.Query 
 //
 // Create a new #GstNavigation commands query. When executed, it will
 // query the pipeline for the set of currently available commands.
-func NavigationInstanceQueryNewCommands() *gst.Query {
+func NavigationQueryNewCommands() *gst.Query {
 	var cret *C.GstQuery // return, full, converted
 
 	cret = C.gst_navigation_query_new_commands()
@@ -7142,7 +8119,7 @@ func NavigationInstanceQueryNewCommands() *gst.Query {
 	return goret
 }
 
-// NavigationInstanceQueryParseAngles wraps gst_navigation_query_parse_angles
+// NavigationQueryParseAngles wraps gst_navigation_query_parse_angles
 // 
 // The function takes the following parameters:
 // 
@@ -7159,7 +8136,7 @@ func NavigationInstanceQueryNewCommands() *gst.Query {
 // Parse the current angle number in the #GstNavigation angles @query into the
 // #guint pointed to by the @cur_angle variable, and the number of available
 // angles into the #guint pointed to by the @n_angles variable.
-func NavigationInstanceQueryParseAngles(query *gst.Query) (uint, uint, bool) {
+func NavigationQueryParseAngles(query *gst.Query) (uint, uint, bool) {
 	var carg1 *C.GstQuery // in, none, converted
 	var carg2 C.guint     // out, full, casted
 	var carg3 C.guint     // out, full, casted
@@ -7183,7 +8160,7 @@ func NavigationInstanceQueryParseAngles(query *gst.Query) (uint, uint, bool) {
 	return curAngle, nAngles, goret
 }
 
-// NavigationInstanceQueryParseCommandsLength wraps gst_navigation_query_parse_commands_length
+// NavigationQueryParseCommandsLength wraps gst_navigation_query_parse_commands_length
 // 
 // The function takes the following parameters:
 // 
@@ -7195,7 +8172,7 @@ func NavigationInstanceQueryParseAngles(query *gst.Query) (uint, uint, bool) {
 // 	- goret bool 
 //
 // Parse the number of commands in the #GstNavigation commands @query.
-func NavigationInstanceQueryParseCommandsLength(query *gst.Query) (uint, bool) {
+func NavigationQueryParseCommandsLength(query *gst.Query) (uint, bool) {
 	var carg1 *C.GstQuery // in, none, converted
 	var carg2 C.guint     // out, full, casted
 	var cret  C.gboolean  // return
@@ -7216,7 +8193,7 @@ func NavigationInstanceQueryParseCommandsLength(query *gst.Query) (uint, bool) {
 	return nCmds, goret
 }
 
-// NavigationInstanceQueryParseCommandsNth wraps gst_navigation_query_parse_commands_nth
+// NavigationQueryParseCommandsNth wraps gst_navigation_query_parse_commands_nth
 // 
 // The function takes the following parameters:
 // 
@@ -7231,7 +8208,7 @@ func NavigationInstanceQueryParseCommandsLength(query *gst.Query) (uint, bool) {
 // Parse the #GstNavigation command query and retrieve the @nth command from
 // it into @cmd. If the list contains less elements than @nth, @cmd will be
 // set to #GST_NAVIGATION_COMMAND_INVALID.
-func NavigationInstanceQueryParseCommandsNth(query *gst.Query, nth uint) (NavigationCommand, bool) {
+func NavigationQueryParseCommandsNth(query *gst.Query, nth uint) (NavigationCommand, bool) {
 	var carg1 *C.GstQuery            // in, none, converted
 	var carg2 C.guint                // in, none, casted
 	var carg3 C.GstNavigationCommand // out, full, casted
@@ -7255,7 +8232,7 @@ func NavigationInstanceQueryParseCommandsNth(query *gst.Query, nth uint) (Naviga
 	return cmd, goret
 }
 
-// NavigationInstanceQuerySetAngles wraps gst_navigation_query_set_angles
+// NavigationQuerySetAngles wraps gst_navigation_query_set_angles
 // 
 // The function takes the following parameters:
 // 
@@ -7264,7 +8241,7 @@ func NavigationInstanceQueryParseCommandsNth(query *gst.Query, nth uint) (Naviga
 // 	- nAngles uint: the number of viewing angles to set. 
 //
 // Set the #GstNavigation angles query result field in @query.
-func NavigationInstanceQuerySetAngles(query *gst.Query, curAngle uint, nAngles uint) {
+func NavigationQuerySetAngles(query *gst.Query, curAngle uint, nAngles uint) {
 	var carg1 *C.GstQuery // in, none, converted
 	var carg2 C.guint     // in, none, casted
 	var carg3 C.guint     // in, none, casted
@@ -7279,7 +8256,7 @@ func NavigationInstanceQuerySetAngles(query *gst.Query, curAngle uint, nAngles u
 	runtime.KeepAlive(nAngles)
 }
 
-// NavigationInstanceQuerySetCommandsv wraps gst_navigation_query_set_commandsv
+// NavigationQuerySetCommandsv wraps gst_navigation_query_set_commandsv
 // 
 // The function takes the following parameters:
 // 
@@ -7289,7 +8266,7 @@ func NavigationInstanceQuerySetAngles(query *gst.Query, curAngle uint, nAngles u
 //
 // Set the #GstNavigation command query result fields in @query. The number
 // of commands passed must be equal to @n_commands.
-func NavigationInstanceQuerySetCommandsv(query *gst.Query, cmds []NavigationCommand) {
+func NavigationQuerySetCommandsv(query *gst.Query, cmds []NavigationCommand) {
 	var carg1 *C.GstQuery             // in, none, converted
 	var carg2 C.gint                  // implicit
 	var carg3 *C.GstNavigationCommand // in, transfer: none, C Pointers: 1, Name: array[NavigationCommand], array (inner: *typesystem.Enum, length-by: carg2)
@@ -7645,7 +8622,7 @@ func UnsafeVideoOrientationToGlibFull(c VideoOrientation) unsafe.Pointer {
 	return gobject.UnsafeObjectToGlibFull(&i.Instance)
 }
 
-// VideoOrientationInstanceFromTag wraps gst_video_orientation_from_tag
+// VideoOrientationFromTag wraps gst_video_orientation_from_tag
 // 
 // The function takes the following parameters:
 // 
@@ -7658,7 +8635,7 @@ func UnsafeVideoOrientationToGlibFull(c VideoOrientation) unsafe.Pointer {
 //
 // Parses the "image-orientation" tag and transforms it into the
 // #GstVideoOrientationMethod enum.
-func VideoOrientationInstanceFromTag(taglist *gst.TagList) (VideoOrientationMethod, bool) {
+func VideoOrientationFromTag(taglist *gst.TagList) (VideoOrientationMethod, bool) {
 	var carg1 *C.GstTagList               // in, none, converted
 	var carg2 C.GstVideoOrientationMethod // out, full, casted
 	var cret  C.gboolean                  // return
@@ -8309,7 +9286,7 @@ func UnsafeVideoOverlayToGlibFull(c VideoOverlay) unsafe.Pointer {
 	return gobject.UnsafeObjectToGlibFull(&i.Instance)
 }
 
-// VideoOverlayInstanceSetProperty wraps gst_video_overlay_set_property
+// VideoOverlaySetProperty wraps gst_video_overlay_set_property
 // 
 // The function takes the following parameters:
 // 
@@ -8326,7 +9303,7 @@ func UnsafeVideoOverlayToGlibFull(c VideoOverlay) unsafe.Pointer {
 // interface that want the render rectangle to be controllable using
 // properties. This helper will parse and set the render rectangle calling
 // gst_video_overlay_set_render_rectangle().
-func VideoOverlayInstanceSetProperty(object gobject.Object, lastPropId int, propertyId uint, value *gobject.Value) bool {
+func VideoOverlaySetProperty(object gobject.Object, lastPropId int, propertyId uint, value *gobject.Value) bool {
 	var carg1 *C.GObject // in, none, converted
 	var carg2 C.gint     // in, none, casted
 	var carg3 C.guint    // in, none, casted
@@ -8925,14 +9902,14 @@ func UnsafeVideoBufferPoolToGlibFull(c VideoBufferPool) unsafe.Pointer {
 	return gobject.UnsafeObjectToGlibFull(c)
 }
 
-// NewVideoBufferPoolInstance wraps gst_video_buffer_pool_new
+// NewVideoBufferPool wraps gst_video_buffer_pool_new
 // The function returns the following values:
 // 
 // 	- goret gst.BufferPool 
 //
 // Create a new bufferpool that can allocate video frames. This bufferpool
 // supports all the video bufferpool options.
-func NewVideoBufferPoolInstance() gst.BufferPool {
+func NewVideoBufferPool() gst.BufferPool {
 	var cret *C.GstBufferPool // return, full, converted
 
 	cret = C.gst_video_buffer_pool_new()
@@ -11972,7 +12949,7 @@ func UnsafeVideoSinkToGlibFull(c VideoSink) unsafe.Pointer {
 	return gobject.UnsafeObjectToGlibFull(c)
 }
 
-// VideoSinkInstanceCenterRect wraps gst_video_sink_center_rect
+// VideoSinkCenterRect wraps gst_video_sink_center_rect
 // 
 // The function takes the following parameters:
 // 
@@ -11986,7 +12963,7 @@ func UnsafeVideoSinkToGlibFull(c VideoSink) unsafe.Pointer {
 //
 //
 // Deprecated: (since 1.20.0) Use gst_video_center_rect() instead.
-func VideoSinkInstanceCenterRect(src VideoRectangle, dst VideoRectangle, scaling bool) VideoRectangle {
+func VideoSinkCenterRect(src VideoRectangle, dst VideoRectangle, scaling bool) VideoRectangle {
 	var carg1 C.GstVideoRectangle // in, transfer: none, C Pointers: 0, Name: VideoRectangle
 	var carg2 C.GstVideoRectangle // in, transfer: none, C Pointers: 0, Name: VideoRectangle
 	var carg4 C.gboolean          // in
diff --git a/pkg/gstwebrtc/gstwebrtc.gen.go b/pkg/gstwebrtc/gstwebrtc.gen.go
index 4381ae5..96904f8 100644
--- a/pkg/gstwebrtc/gstwebrtc.gen.go
+++ b/pkg/gstwebrtc/gstwebrtc.gen.go
@@ -3,6 +3,7 @@
 package gstwebrtc
 
 import (
+	"fmt"
 	"log"
 	"runtime"
 	"unsafe"
@@ -127,6 +128,16 @@ func (e WebRTCBundlePolicy) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e WebRTCBundlePolicy) String() string {
+	switch e {
+		case WebrtcBundlePolicyNone: return "WebrtcBundlePolicyNone"
+		case WebrtcBundlePolicyBalanced: return "WebrtcBundlePolicyBalanced"
+		case WebrtcBundlePolicyMaxCompat: return "WebrtcBundlePolicyMaxCompat"
+		case WebrtcBundlePolicyMaxBundle: return "WebrtcBundlePolicyMaxBundle"
+		default: return fmt.Sprintf("WebRTCBundlePolicy(%d)", e)
+	}
+}
+
 // WebRTCDTLSSetup wraps GstWebRTCDTLSSetup
 type WebRTCDTLSSetup C.int
 
@@ -160,6 +171,16 @@ func (e WebRTCDTLSSetup) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e WebRTCDTLSSetup) String() string {
+	switch e {
+		case WebrtcDTLSSetupActive: return "WebrtcDTLSSetupActive"
+		case WebrtcDTLSSetupPassive: return "WebrtcDTLSSetupPassive"
+		case WebrtcDTLSSetupNone: return "WebrtcDTLSSetupNone"
+		case WebrtcDTLSSetupActpass: return "WebrtcDTLSSetupActpass"
+		default: return fmt.Sprintf("WebRTCDTLSSetup(%d)", e)
+	}
+}
+
 // WebRTCDTLSTransportState wraps GstWebRTCDTLSTransportState
 type WebRTCDTLSTransportState C.int
 
@@ -197,6 +218,17 @@ func (e WebRTCDTLSTransportState) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e WebRTCDTLSTransportState) String() string {
+	switch e {
+		case NewWebrtcDTLSTransportState: return "NewWebrtcDTLSTransportState"
+		case WebrtcDTLSTransportStateClosed: return "WebrtcDTLSTransportStateClosed"
+		case WebrtcDTLSTransportStateFailed: return "WebrtcDTLSTransportStateFailed"
+		case WebrtcDTLSTransportStateConnecting: return "WebrtcDTLSTransportStateConnecting"
+		case WebrtcDTLSTransportStateConnected: return "WebrtcDTLSTransportStateConnected"
+		default: return fmt.Sprintf("WebRTCDTLSTransportState(%d)", e)
+	}
+}
+
 // WebRTCDataChannelState wraps GstWebRTCDataChannelState
 //
 // See &lt;http://w3c.github.io/webrtc-pc/#dom-rtcdatachannelstate&gt;
@@ -232,6 +264,16 @@ func (e WebRTCDataChannelState) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e WebRTCDataChannelState) String() string {
+	switch e {
+		case WebrtcDataChannelStateConnecting: return "WebrtcDataChannelStateConnecting"
+		case WebrtcDataChannelStateOpen: return "WebrtcDataChannelStateOpen"
+		case WebrtcDataChannelStateClosing: return "WebrtcDataChannelStateClosing"
+		case WebrtcDataChannelStateClosed: return "WebrtcDataChannelStateClosed"
+		default: return fmt.Sprintf("WebRTCDataChannelState(%d)", e)
+	}
+}
+
 // WebRTCError wraps GstWebRTCError
 //
 // See &lt;https://www.w3.org/TR/webrtc/#dom-rtcerrordetailtype&gt; for more information.
@@ -295,6 +337,23 @@ func (e WebRTCError) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e WebRTCError) String() string {
+	switch e {
+		case WebrtcErrorHardwareEncoderNotAvailable: return "WebrtcErrorHardwareEncoderNotAvailable"
+		case WebrtcErrorEncoderError: return "WebrtcErrorEncoderError"
+		case WebrtcErrorInvalidState: return "WebrtcErrorInvalidState"
+		case WebrtcErrorInternalFailure: return "WebrtcErrorInternalFailure"
+		case WebrtcErrorDataChannelFailure: return "WebrtcErrorDataChannelFailure"
+		case WebrtcErrorDTLSFailure: return "WebrtcErrorDTLSFailure"
+		case WebrtcErrorFingerprintFailure: return "WebrtcErrorFingerprintFailure"
+		case WebrtcErrorSdpSyntaxError: return "WebrtcErrorSdpSyntaxError"
+		case WebrtcErrorInvalidModification: return "WebrtcErrorInvalidModification"
+		case WebrtcErrorTypeError: return "WebrtcErrorTypeError"
+		case WebrtcErrorSCTPFailure: return "WebrtcErrorSCTPFailure"
+		default: return fmt.Sprintf("WebRTCError(%d)", e)
+	}
+}
+
 // WebRTCFECType wraps GstWebRTCFECType
 type WebRTCFECType C.int
 
@@ -320,6 +379,14 @@ func (e WebRTCFECType) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e WebRTCFECType) String() string {
+	switch e {
+		case WebrtcFecTypeNone: return "WebrtcFecTypeNone"
+		case WebrtcFecTypeUlpRed: return "WebrtcFecTypeUlpRed"
+		default: return fmt.Sprintf("WebRTCFECType(%d)", e)
+	}
+}
+
 // WebRTCICEComponent wraps GstWebRTCICEComponent
 type WebRTCICEComponent C.int
 
@@ -345,6 +412,14 @@ func (e WebRTCICEComponent) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e WebRTCICEComponent) String() string {
+	switch e {
+		case WebrtcIceComponentRtp: return "WebrtcIceComponentRtp"
+		case WebrtcIceComponentRtcp: return "WebrtcIceComponentRtcp"
+		default: return fmt.Sprintf("WebRTCICEComponent(%d)", e)
+	}
+}
+
 // WebRTCICEConnectionState wraps GstWebRTCICEConnectionState
 //
 // See &lt;http://w3c.github.io/webrtc-pc/#dom-rtciceconnectionstate&gt;
@@ -392,6 +467,19 @@ func (e WebRTCICEConnectionState) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e WebRTCICEConnectionState) String() string {
+	switch e {
+		case NewWebrtcIceConnectionState: return "NewWebrtcIceConnectionState"
+		case WebrtcIceConnectionStateChecking: return "WebrtcIceConnectionStateChecking"
+		case WebrtcIceConnectionStateConnected: return "WebrtcIceConnectionStateConnected"
+		case WebrtcIceConnectionStateCompleted: return "WebrtcIceConnectionStateCompleted"
+		case WebrtcIceConnectionStateFailed: return "WebrtcIceConnectionStateFailed"
+		case WebrtcIceConnectionStateDisconnected: return "WebrtcIceConnectionStateDisconnected"
+		case WebrtcIceConnectionStateClosed: return "WebrtcIceConnectionStateClosed"
+		default: return fmt.Sprintf("WebRTCICEConnectionState(%d)", e)
+	}
+}
+
 // WebRTCICEGatheringState wraps GstWebRTCICEGatheringState
 //
 // See &lt;http://w3c.github.io/webrtc-pc/#dom-rtcicegatheringstate&gt;
@@ -423,6 +511,15 @@ func (e WebRTCICEGatheringState) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e WebRTCICEGatheringState) String() string {
+	switch e {
+		case NewWebrtcIceGatheringState: return "NewWebrtcIceGatheringState"
+		case WebrtcIceGatheringStateGathering: return "WebrtcIceGatheringStateGathering"
+		case WebrtcIceGatheringStateComplete: return "WebrtcIceGatheringStateComplete"
+		default: return fmt.Sprintf("WebRTCICEGatheringState(%d)", e)
+	}
+}
+
 // WebRTCICERole wraps GstWebRTCICERole
 type WebRTCICERole C.int
 
@@ -448,6 +545,14 @@ func (e WebRTCICERole) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e WebRTCICERole) String() string {
+	switch e {
+		case WebrtcIceRoleControlled: return "WebrtcIceRoleControlled"
+		case WebrtcIceRoleControlling: return "WebrtcIceRoleControlling"
+		default: return fmt.Sprintf("WebRTCICERole(%d)", e)
+	}
+}
+
 // WebRTCICETransportPolicy wraps GstWebRTCICETransportPolicy
 //
 // See https://tools.ietf.org/html/draft-ietf-rtcweb-jsep-24#section-4.1.1
@@ -476,6 +581,14 @@ func (e WebRTCICETransportPolicy) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e WebRTCICETransportPolicy) String() string {
+	switch e {
+		case WebrtcIceTransportPolicyAll: return "WebrtcIceTransportPolicyAll"
+		case WebrtcIceTransportPolicyRelay: return "WebrtcIceTransportPolicyRelay"
+		default: return fmt.Sprintf("WebRTCICETransportPolicy(%d)", e)
+	}
+}
+
 // WebRTCKind wraps GstWebRTCKind
 //
 // https://w3c.github.io/mediacapture-main/#dom-mediastreamtrack-kind
@@ -507,6 +620,15 @@ func (e WebRTCKind) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e WebRTCKind) String() string {
+	switch e {
+		case WebrtcKindUnknown: return "WebrtcKindUnknown"
+		case WebrtcKindAudio: return "WebrtcKindAudio"
+		case WebrtcKindVideo: return "WebrtcKindVideo"
+		default: return fmt.Sprintf("WebRTCKind(%d)", e)
+	}
+}
+
 // WebRTCPeerConnectionState wraps GstWebRTCPeerConnectionState
 //
 // See &lt;http://w3c.github.io/webrtc-pc/#dom-rtcpeerconnectionstate&gt;
@@ -550,6 +672,18 @@ func (e WebRTCPeerConnectionState) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e WebRTCPeerConnectionState) String() string {
+	switch e {
+		case NewWebrtcPeerConnectionState: return "NewWebrtcPeerConnectionState"
+		case WebrtcPeerConnectionStateConnecting: return "WebrtcPeerConnectionStateConnecting"
+		case WebrtcPeerConnectionStateConnected: return "WebrtcPeerConnectionStateConnected"
+		case WebrtcPeerConnectionStateDisconnected: return "WebrtcPeerConnectionStateDisconnected"
+		case WebrtcPeerConnectionStateFailed: return "WebrtcPeerConnectionStateFailed"
+		case WebrtcPeerConnectionStateClosed: return "WebrtcPeerConnectionStateClosed"
+		default: return fmt.Sprintf("WebRTCPeerConnectionState(%d)", e)
+	}
+}
+
 // WebRTCPriorityType wraps GstWebRTCPriorityType
 //
 // See &lt;http://w3c.github.io/webrtc-pc/#dom-rtcprioritytype&gt;
@@ -585,6 +719,16 @@ func (e WebRTCPriorityType) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e WebRTCPriorityType) String() string {
+	switch e {
+		case WebrtcPriorityTypeHigh: return "WebrtcPriorityTypeHigh"
+		case WebrtcPriorityTypeVeryLow: return "WebrtcPriorityTypeVeryLow"
+		case WebrtcPriorityTypeLow: return "WebrtcPriorityTypeLow"
+		case WebrtcPriorityTypeMedium: return "WebrtcPriorityTypeMedium"
+		default: return fmt.Sprintf("WebRTCPriorityType(%d)", e)
+	}
+}
+
 // WebRTCRTPTransceiverDirection wraps GstWebRTCRTPTransceiverDirection
 type WebRTCRTPTransceiverDirection C.int
 
@@ -622,6 +766,17 @@ func (e WebRTCRTPTransceiverDirection) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e WebRTCRTPTransceiverDirection) String() string {
+	switch e {
+		case WebrtcRtpTransceiverDirectionNone: return "WebrtcRtpTransceiverDirectionNone"
+		case WebrtcRtpTransceiverDirectionInactive: return "WebrtcRtpTransceiverDirectionInactive"
+		case WebrtcRtpTransceiverDirectionSendonly: return "WebrtcRtpTransceiverDirectionSendonly"
+		case WebrtcRtpTransceiverDirectionRecvonly: return "WebrtcRtpTransceiverDirectionRecvonly"
+		case WebrtcRtpTransceiverDirectionSendrecv: return "WebrtcRtpTransceiverDirectionSendrecv"
+		default: return fmt.Sprintf("WebRTCRTPTransceiverDirection(%d)", e)
+	}
+}
+
 // WebRTCSCTPTransportState wraps GstWebRTCSCTPTransportState
 //
 // See &lt;http://w3c.github.io/webrtc-pc/#dom-rtcsctptransportstate&gt;
@@ -657,6 +812,16 @@ func (e WebRTCSCTPTransportState) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e WebRTCSCTPTransportState) String() string {
+	switch e {
+		case NewWebrtcSCTPTransportState: return "NewWebrtcSCTPTransportState"
+		case WebrtcSCTPTransportStateConnecting: return "WebrtcSCTPTransportStateConnecting"
+		case WebrtcSCTPTransportStateConnected: return "WebrtcSCTPTransportStateConnected"
+		case WebrtcSCTPTransportStateClosed: return "WebrtcSCTPTransportStateClosed"
+		default: return fmt.Sprintf("WebRTCSCTPTransportState(%d)", e)
+	}
+}
+
 // WebRTCSDPType wraps GstWebRTCSDPType
 //
 // See &lt;http://w3c.github.io/webrtc-pc/#rtcsdptype&gt;
@@ -692,6 +857,16 @@ func (e WebRTCSDPType) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e WebRTCSDPType) String() string {
+	switch e {
+		case WebrtcSdpTypeOffer: return "WebrtcSdpTypeOffer"
+		case WebrtcSdpTypePranswer: return "WebrtcSdpTypePranswer"
+		case WebrtcSdpTypeAnswer: return "WebrtcSdpTypeAnswer"
+		case WebrtcSdpTypeRollback: return "WebrtcSdpTypeRollback"
+		default: return fmt.Sprintf("WebRTCSDPType(%d)", e)
+	}
+}
+
 // WebRTCSignalingState wraps GstWebRTCSignalingState
 //
 // See &lt;http://w3c.github.io/webrtc-pc/#dom-rtcsignalingstate&gt;
@@ -735,6 +910,18 @@ func (e WebRTCSignalingState) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e WebRTCSignalingState) String() string {
+	switch e {
+		case WebrtcSignalingStateStable: return "WebrtcSignalingStateStable"
+		case WebrtcSignalingStateClosed: return "WebrtcSignalingStateClosed"
+		case WebrtcSignalingStateHaveLocalOffer: return "WebrtcSignalingStateHaveLocalOffer"
+		case WebrtcSignalingStateHaveRemoteOffer: return "WebrtcSignalingStateHaveRemoteOffer"
+		case WebrtcSignalingStateHaveLocalPranswer: return "WebrtcSignalingStateHaveLocalPranswer"
+		case WebrtcSignalingStateHaveRemotePranswer: return "WebrtcSignalingStateHaveRemotePranswer"
+		default: return fmt.Sprintf("WebRTCSignalingState(%d)", e)
+	}
+}
+
 // WebRTCStatsType wraps GstWebRTCStatsType
 //
 // See &lt;https://w3c.github.io/webrtc-stats/#dom-rtcstatstype&gt;
@@ -810,6 +997,26 @@ func (e WebRTCStatsType) InitGoValue(v *gobject.Value) {
 	v.SetEnum(int(e))
 }
 
+func (e WebRTCStatsType) String() string {
+	switch e {
+		case WebrtcStatsRemoteOutboundRtp: return "WebrtcStatsRemoteOutboundRtp"
+		case WebrtcStatsCsrc: return "WebrtcStatsCsrc"
+		case WebrtcStatsPeerConnection: return "WebrtcStatsPeerConnection"
+		case WebrtcStatsStream: return "WebrtcStatsStream"
+		case WebrtcStatsCandidatePair: return "WebrtcStatsCandidatePair"
+		case WebrtcStatsLocalCandidate: return "WebrtcStatsLocalCandidate"
+		case WebrtcStatsInboundRtp: return "WebrtcStatsInboundRtp"
+		case WebrtcStatsRemoteInboundRtp: return "WebrtcStatsRemoteInboundRtp"
+		case WebrtcStatsDataChannel: return "WebrtcStatsDataChannel"
+		case WebrtcStatsTransport: return "WebrtcStatsTransport"
+		case WebrtcStatsRemoteCandidate: return "WebrtcStatsRemoteCandidate"
+		case WebrtcStatsCertificate: return "WebrtcStatsCertificate"
+		case WebrtcStatsCodec: return "WebrtcStatsCodec"
+		case WebrtcStatsOutboundRtp: return "WebrtcStatsOutboundRtp"
+		default: return fmt.Sprintf("WebRTCStatsType(%d)", e)
+	}
+}
+
 // WebRTCICEOnCandidateFunc wraps GstWebRTCICEOnCandidateFunc
 //
 // Callback function to be triggered on discovery of a new candidate