diff --git a/GI/Gst.hs b/GI/Gst.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst.hs
@@ -0,0 +1,56 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+-}
+
+module GI.Gst
+    (     module GI.Gst.Callbacks                 ,
+    module GI.Gst.Constants                 ,
+    module GI.Gst.Enums                     ,
+    module GI.Gst.Flags                     ,
+    module GI.Gst.Functions                 ,
+    module GI.Gst.Interfaces                ,
+    module GI.Gst.Objects                   ,
+    module GI.Gst.Structs                   ,
+
+
+
+    module Data.GI.Base                     ,
+
+
+    ) where
+
+import GI.Gst.Callbacks
+import GI.Gst.Constants
+import GI.Gst.Enums
+import GI.Gst.Flags
+import GI.Gst.Functions
+import GI.Gst.Interfaces
+import GI.Gst.Objects
+import GI.Gst.Structs
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+import GI.Gst.Callbacks
+
+import Data.GI.Base
+-- APIObject "Bitmask" does not descend from GObject, it will be ignored.
+-- APIObject "DoubleRange" does not descend from GObject, it will be ignored.
+-- APIObject "FlagSet" does not descend from GObject, it will be ignored.
+-- APIObject "Fraction" does not descend from GObject, it will be ignored.
+-- APIObject "FractionRange" does not descend from GObject, it will be ignored.
+-- APIObject "Int64Range" does not descend from GObject, it will be ignored.
+-- APIObject "IntRange" does not descend from GObject, it will be ignored.
+-- APIObject "ParamFraction" does not descend from GObject, it will be ignored.
+-- APIObject "ValueArray" does not descend from GObject, it will be ignored.
+-- APIObject "ValueList" does not descend from GObject, it will be ignored.
+
diff --git a/GI/Gst/Callbacks.hs b/GI/Gst/Callbacks.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Callbacks.hs
@@ -0,0 +1,2873 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+-}
+
+module GI.Gst.Callbacks
+    ( 
+
+ -- * Signals
+-- ** BufferForeachMetaFunc
+    BufferForeachMetaFunc                   ,
+    BufferForeachMetaFuncC                  ,
+    bufferForeachMetaFuncClosure            ,
+    bufferForeachMetaFuncWrapper            ,
+    mkBufferForeachMetaFunc                 ,
+    noBufferForeachMetaFunc                 ,
+
+
+-- ** BufferListFunc
+    BufferListFunc                          ,
+    BufferListFuncC                         ,
+    bufferListFuncClosure                   ,
+    bufferListFuncWrapper                   ,
+    mkBufferListFunc                        ,
+    noBufferListFunc                        ,
+
+
+-- ** BusFunc
+    BusFunc                                 ,
+    BusFuncC                                ,
+    busFuncClosure                          ,
+    busFuncWrapper                          ,
+    mkBusFunc                               ,
+    noBusFunc                               ,
+
+
+-- ** BusSyncHandler
+    BusSyncHandler                          ,
+    BusSyncHandlerC                         ,
+    busSyncHandlerClosure                   ,
+    busSyncHandlerWrapper                   ,
+    mkBusSyncHandler                        ,
+    noBusSyncHandler                        ,
+
+
+-- ** CapsFilterMapFunc
+    CapsFilterMapFunc                       ,
+    CapsFilterMapFuncC                      ,
+    capsFilterMapFuncClosure                ,
+    capsFilterMapFuncWrapper                ,
+    mkCapsFilterMapFunc                     ,
+    noCapsFilterMapFunc                     ,
+
+
+-- ** CapsForeachFunc
+    CapsForeachFunc                         ,
+    CapsForeachFuncC                        ,
+    capsForeachFuncClosure                  ,
+    capsForeachFuncWrapper                  ,
+    mkCapsForeachFunc                       ,
+    noCapsForeachFunc                       ,
+
+
+-- ** CapsMapFunc
+    CapsMapFunc                             ,
+    CapsMapFuncC                            ,
+    capsMapFuncClosure                      ,
+    capsMapFuncWrapper                      ,
+    mkCapsMapFunc                           ,
+    noCapsMapFunc                           ,
+
+
+-- ** ClockCallback
+    ClockCallback                           ,
+    ClockCallbackC                          ,
+    clockCallbackClosure                    ,
+    clockCallbackWrapper                    ,
+    mkClockCallback                         ,
+    noClockCallback                         ,
+
+
+-- ** ControlBindingConvert
+    ControlBindingConvert                   ,
+    ControlBindingConvertC                  ,
+    controlBindingConvertClosure            ,
+    controlBindingConvertWrapper            ,
+    mkControlBindingConvert                 ,
+    noControlBindingConvert                 ,
+
+
+-- ** ControlSourceGetValue
+    ControlSourceGetValue                   ,
+    ControlSourceGetValueC                  ,
+    controlSourceGetValueClosure            ,
+    controlSourceGetValueWrapper            ,
+    mkControlSourceGetValue                 ,
+    noControlSourceGetValue                 ,
+
+
+-- ** ControlSourceGetValueArray
+    ControlSourceGetValueArray              ,
+    ControlSourceGetValueArrayC             ,
+    controlSourceGetValueArrayClosure       ,
+    controlSourceGetValueArrayWrapper       ,
+    mkControlSourceGetValueArray            ,
+    noControlSourceGetValueArray            ,
+
+
+-- ** DebugFuncPtr
+    DebugFuncPtr                            ,
+    DebugFuncPtrC                           ,
+    debugFuncPtrClosure                     ,
+    debugFuncPtrWrapper                     ,
+    mkDebugFuncPtr                          ,
+    noDebugFuncPtr                          ,
+
+
+-- ** IteratorCopyFunction
+    IteratorCopyFunction                    ,
+    IteratorCopyFunctionC                   ,
+    iteratorCopyFunctionClosure             ,
+    iteratorCopyFunctionWrapper             ,
+    mkIteratorCopyFunction                  ,
+    noIteratorCopyFunction                  ,
+
+
+-- ** IteratorFoldFunction
+    IteratorFoldFunction                    ,
+    IteratorFoldFunctionC                   ,
+    iteratorFoldFunctionClosure             ,
+    iteratorFoldFunctionWrapper             ,
+    mkIteratorFoldFunction                  ,
+    noIteratorFoldFunction                  ,
+
+
+-- ** IteratorForeachFunction
+    IteratorForeachFunction                 ,
+    IteratorForeachFunctionC                ,
+    iteratorForeachFunctionClosure          ,
+    iteratorForeachFunctionWrapper          ,
+    mkIteratorForeachFunction               ,
+    noIteratorForeachFunction               ,
+
+
+-- ** IteratorFreeFunction
+    IteratorFreeFunction                    ,
+    IteratorFreeFunctionC                   ,
+    iteratorFreeFunctionClosure             ,
+    iteratorFreeFunctionWrapper             ,
+    mkIteratorFreeFunction                  ,
+    noIteratorFreeFunction                  ,
+
+
+-- ** IteratorItemFunction
+    IteratorItemFunction                    ,
+    IteratorItemFunctionC                   ,
+    iteratorItemFunctionClosure             ,
+    iteratorItemFunctionWrapper             ,
+    mkIteratorItemFunction                  ,
+    noIteratorItemFunction                  ,
+
+
+-- ** IteratorNextFunction
+    IteratorNextFunction                    ,
+    IteratorNextFunctionC                   ,
+    iteratorNextFunctionClosure             ,
+    iteratorNextFunctionWrapper             ,
+    mkIteratorNextFunction                  ,
+    noIteratorNextFunction                  ,
+
+
+-- ** IteratorResyncFunction
+    IteratorResyncFunction                  ,
+    IteratorResyncFunctionC                 ,
+    iteratorResyncFunctionClosure           ,
+    iteratorResyncFunctionWrapper           ,
+    mkIteratorResyncFunction                ,
+    noIteratorResyncFunction                ,
+
+
+-- ** LogFunction
+    LogFunction                             ,
+    LogFunctionC                            ,
+    logFunctionClosure                      ,
+    logFunctionWrapper                      ,
+    mkLogFunction                           ,
+    noLogFunction                           ,
+
+
+-- ** MemoryCopyFunction
+    MemoryCopyFunction                      ,
+    MemoryCopyFunctionC                     ,
+    memoryCopyFunctionClosure               ,
+    memoryCopyFunctionWrapper               ,
+    mkMemoryCopyFunction                    ,
+    noMemoryCopyFunction                    ,
+
+
+-- ** MemoryIsSpanFunction
+    MemoryIsSpanFunction                    ,
+    MemoryIsSpanFunctionC                   ,
+    memoryIsSpanFunctionClosure             ,
+    memoryIsSpanFunctionWrapper             ,
+    mkMemoryIsSpanFunction                  ,
+    noMemoryIsSpanFunction                  ,
+
+
+-- ** MemoryShareFunction
+    MemoryShareFunction                     ,
+    MemoryShareFunctionC                    ,
+    memoryShareFunctionClosure              ,
+    memoryShareFunctionWrapper              ,
+    mkMemoryShareFunction                   ,
+    noMemoryShareFunction                   ,
+
+
+-- ** MemoryUnmapFullFunction
+    MemoryUnmapFullFunction                 ,
+    MemoryUnmapFullFunctionC                ,
+    memoryUnmapFullFunctionClosure          ,
+    memoryUnmapFullFunctionWrapper          ,
+    mkMemoryUnmapFullFunction               ,
+    noMemoryUnmapFullFunction               ,
+
+
+-- ** MemoryUnmapFunction
+    MemoryUnmapFunction                     ,
+    MemoryUnmapFunctionC                    ,
+    memoryUnmapFunctionClosure              ,
+    memoryUnmapFunctionWrapper              ,
+    mkMemoryUnmapFunction                   ,
+    noMemoryUnmapFunction                   ,
+
+
+-- ** MetaFreeFunction
+    MetaFreeFunction                        ,
+    MetaFreeFunctionC                       ,
+    metaFreeFunctionClosure                 ,
+    metaFreeFunctionWrapper                 ,
+    mkMetaFreeFunction                      ,
+    noMetaFreeFunction                      ,
+
+
+-- ** MetaInitFunction
+    MetaInitFunction                        ,
+    MetaInitFunctionC                       ,
+    metaInitFunctionClosure                 ,
+    metaInitFunctionWrapper                 ,
+    mkMetaInitFunction                      ,
+    noMetaInitFunction                      ,
+
+
+-- ** MetaTransformFunction
+    MetaTransformFunction                   ,
+    MetaTransformFunctionC                  ,
+    metaTransformFunctionClosure            ,
+    metaTransformFunctionWrapper            ,
+    mkMetaTransformFunction                 ,
+    noMetaTransformFunction                 ,
+
+
+-- ** MiniObjectDisposeFunction
+    MiniObjectDisposeFunction               ,
+    MiniObjectDisposeFunctionC              ,
+    miniObjectDisposeFunctionClosure        ,
+    miniObjectDisposeFunctionWrapper        ,
+    mkMiniObjectDisposeFunction             ,
+    noMiniObjectDisposeFunction             ,
+
+
+-- ** MiniObjectFreeFunction
+    MiniObjectFreeFunction                  ,
+    MiniObjectFreeFunctionC                 ,
+    miniObjectFreeFunctionClosure           ,
+    miniObjectFreeFunctionWrapper           ,
+    mkMiniObjectFreeFunction                ,
+    noMiniObjectFreeFunction                ,
+
+
+-- ** MiniObjectNotify
+    MiniObjectNotify                        ,
+    MiniObjectNotifyC                       ,
+    miniObjectNotifyClosure                 ,
+    miniObjectNotifyWrapper                 ,
+    mkMiniObjectNotify                      ,
+    noMiniObjectNotify                      ,
+
+
+-- ** PadActivateFunction
+    PadActivateFunction                     ,
+    PadActivateFunctionC                    ,
+    mkPadActivateFunction                   ,
+    noPadActivateFunction                   ,
+    padActivateFunctionClosure              ,
+    padActivateFunctionWrapper              ,
+
+
+-- ** PadActivateModeFunction
+    PadActivateModeFunction                 ,
+    PadActivateModeFunctionC                ,
+    mkPadActivateModeFunction               ,
+    noPadActivateModeFunction               ,
+    padActivateModeFunctionClosure          ,
+    padActivateModeFunctionWrapper          ,
+
+
+-- ** PadChainFunction
+    PadChainFunction                        ,
+    PadChainFunctionC                       ,
+    mkPadChainFunction                      ,
+    noPadChainFunction                      ,
+    padChainFunctionClosure                 ,
+    padChainFunctionWrapper                 ,
+
+
+-- ** PadChainListFunction
+    PadChainListFunction                    ,
+    PadChainListFunctionC                   ,
+    mkPadChainListFunction                  ,
+    noPadChainListFunction                  ,
+    padChainListFunctionClosure             ,
+    padChainListFunctionWrapper             ,
+
+
+-- ** PadEventFunction
+    PadEventFunction                        ,
+    PadEventFunctionC                       ,
+    mkPadEventFunction                      ,
+    noPadEventFunction                      ,
+    padEventFunctionClosure                 ,
+    padEventFunctionWrapper                 ,
+
+
+-- ** PadForwardFunction
+    PadForwardFunction                      ,
+    PadForwardFunctionC                     ,
+    mkPadForwardFunction                    ,
+    noPadForwardFunction                    ,
+    padForwardFunctionClosure               ,
+    padForwardFunctionWrapper               ,
+
+
+-- ** PadGetRangeFunction
+    PadGetRangeFunction                     ,
+    PadGetRangeFunctionC                    ,
+    mkPadGetRangeFunction                   ,
+    noPadGetRangeFunction                   ,
+    padGetRangeFunctionClosure              ,
+    padGetRangeFunctionWrapper              ,
+
+
+-- ** PadIterIntLinkFunction
+    PadIterIntLinkFunction                  ,
+    PadIterIntLinkFunctionC                 ,
+    mkPadIterIntLinkFunction                ,
+    noPadIterIntLinkFunction                ,
+    padIterIntLinkFunctionClosure           ,
+    padIterIntLinkFunctionWrapper           ,
+
+
+-- ** PadLinkFunction
+    PadLinkFunction                         ,
+    PadLinkFunctionC                        ,
+    mkPadLinkFunction                       ,
+    noPadLinkFunction                       ,
+    padLinkFunctionClosure                  ,
+    padLinkFunctionWrapper                  ,
+
+
+-- ** PadProbeCallback
+    PadProbeCallback                        ,
+    PadProbeCallbackC                       ,
+    mkPadProbeCallback                      ,
+    noPadProbeCallback                      ,
+    padProbeCallbackClosure                 ,
+    padProbeCallbackWrapper                 ,
+
+
+-- ** PadQueryFunction
+    PadQueryFunction                        ,
+    PadQueryFunctionC                       ,
+    mkPadQueryFunction                      ,
+    noPadQueryFunction                      ,
+    padQueryFunctionClosure                 ,
+    padQueryFunctionWrapper                 ,
+
+
+-- ** PadStickyEventsForeachFunction
+    PadStickyEventsForeachFunction          ,
+    PadStickyEventsForeachFunctionC         ,
+    mkPadStickyEventsForeachFunction        ,
+    noPadStickyEventsForeachFunction        ,
+    padStickyEventsForeachFunctionClosure   ,
+    padStickyEventsForeachFunctionWrapper   ,
+
+
+-- ** PadUnlinkFunction
+    PadUnlinkFunction                       ,
+    PadUnlinkFunctionC                      ,
+    mkPadUnlinkFunction                     ,
+    noPadUnlinkFunction                     ,
+    padUnlinkFunctionClosure                ,
+    padUnlinkFunctionWrapper                ,
+
+
+-- ** PluginFeatureFilter
+    PluginFeatureFilter                     ,
+    PluginFeatureFilterC                    ,
+    mkPluginFeatureFilter                   ,
+    noPluginFeatureFilter                   ,
+    pluginFeatureFilterClosure              ,
+    pluginFeatureFilterWrapper              ,
+
+
+-- ** PluginFilter
+    PluginFilter                            ,
+    PluginFilterC                           ,
+    mkPluginFilter                          ,
+    noPluginFilter                          ,
+    pluginFilterClosure                     ,
+    pluginFilterWrapper                     ,
+
+
+-- ** PluginInitFullFunc
+    PluginInitFullFunc                      ,
+    PluginInitFullFuncC                     ,
+    mkPluginInitFullFunc                    ,
+    noPluginInitFullFunc                    ,
+    pluginInitFullFuncClosure               ,
+    pluginInitFullFuncWrapper               ,
+
+
+-- ** PluginInitFunc
+    PluginInitFunc                          ,
+    PluginInitFuncC                         ,
+    mkPluginInitFunc                        ,
+    noPluginInitFunc                        ,
+    pluginInitFuncClosure                   ,
+    pluginInitFuncWrapper                   ,
+
+
+-- ** StructureFilterMapFunc
+    StructureFilterMapFunc                  ,
+    StructureFilterMapFuncC                 ,
+    mkStructureFilterMapFunc                ,
+    noStructureFilterMapFunc                ,
+    structureFilterMapFuncClosure           ,
+    structureFilterMapFuncWrapper           ,
+
+
+-- ** StructureForeachFunc
+    StructureForeachFunc                    ,
+    StructureForeachFuncC                   ,
+    mkStructureForeachFunc                  ,
+    noStructureForeachFunc                  ,
+    structureForeachFuncClosure             ,
+    structureForeachFuncWrapper             ,
+
+
+-- ** StructureMapFunc
+    StructureMapFunc                        ,
+    StructureMapFuncC                       ,
+    mkStructureMapFunc                      ,
+    noStructureMapFunc                      ,
+    structureMapFuncClosure                 ,
+    structureMapFuncWrapper                 ,
+
+
+-- ** TagForeachFunc
+    TagForeachFunc                          ,
+    TagForeachFuncC                         ,
+    mkTagForeachFunc                        ,
+    noTagForeachFunc                        ,
+    tagForeachFuncClosure                   ,
+    tagForeachFuncWrapper                   ,
+
+
+-- ** TagMergeFunc
+    TagMergeFunc                            ,
+    TagMergeFuncC                           ,
+    mkTagMergeFunc                          ,
+    noTagMergeFunc                          ,
+    tagMergeFuncClosure                     ,
+    tagMergeFuncWrapper                     ,
+
+
+-- ** TaskFunction
+    TaskFunction                            ,
+    TaskFunctionC                           ,
+    mkTaskFunction                          ,
+    noTaskFunction                          ,
+    taskFunctionClosure                     ,
+    taskFunctionWrapper                     ,
+
+
+-- ** TaskPoolFunction
+    TaskPoolFunction                        ,
+    TaskPoolFunctionC                       ,
+    mkTaskPoolFunction                      ,
+    noTaskPoolFunction                      ,
+    taskPoolFunctionClosure                 ,
+    taskPoolFunctionWrapper                 ,
+
+
+-- ** TaskThreadFunc
+    TaskThreadFunc                          ,
+    TaskThreadFuncC                         ,
+    mkTaskThreadFunc                        ,
+    noTaskThreadFunc                        ,
+    taskThreadFuncClosure                   ,
+    taskThreadFuncWrapper                   ,
+
+
+-- ** TypeFindFunction
+    TypeFindFunction                        ,
+    TypeFindFunctionC                       ,
+    mkTypeFindFunction                      ,
+    noTypeFindFunction                      ,
+    typeFindFunctionClosure                 ,
+    typeFindFunctionWrapper                 ,
+
+
+-- ** TypeFindGetLengthFieldCallback
+    TypeFindGetLengthFieldCallback          ,
+    TypeFindGetLengthFieldCallbackC         ,
+    mkTypeFindGetLengthFieldCallback        ,
+    noTypeFindGetLengthFieldCallback        ,
+    typeFindGetLengthFieldCallbackClosure   ,
+    typeFindGetLengthFieldCallbackWrapper   ,
+
+
+-- ** TypeFindPeekFieldCallback
+    TypeFindPeekFieldCallback               ,
+    TypeFindPeekFieldCallbackC              ,
+    mkTypeFindPeekFieldCallback             ,
+    noTypeFindPeekFieldCallback             ,
+    typeFindPeekFieldCallbackClosure        ,
+    typeFindPeekFieldCallbackWrapper        ,
+
+
+-- ** TypeFindSuggestFieldCallback
+    TypeFindSuggestFieldCallback            ,
+    TypeFindSuggestFieldCallbackC           ,
+    mkTypeFindSuggestFieldCallback          ,
+    noTypeFindSuggestFieldCallback          ,
+    typeFindSuggestFieldCallbackClosure     ,
+    typeFindSuggestFieldCallbackWrapper     ,
+
+
+-- ** ValueCompareFunc
+    ValueCompareFunc                        ,
+    ValueCompareFuncC                       ,
+    mkValueCompareFunc                      ,
+    noValueCompareFunc                      ,
+    valueCompareFuncClosure                 ,
+    valueCompareFuncWrapper                 ,
+
+
+-- ** ValueDeserializeFunc
+    ValueDeserializeFunc                    ,
+    ValueDeserializeFuncC                   ,
+    mkValueDeserializeFunc                  ,
+    noValueDeserializeFunc                  ,
+    valueDeserializeFuncClosure             ,
+    valueDeserializeFuncWrapper             ,
+
+
+-- ** ValueSerializeFunc
+    ValueSerializeFunc                      ,
+    ValueSerializeFuncC                     ,
+    mkValueSerializeFunc                    ,
+    noValueSerializeFunc                    ,
+    valueSerializeFuncClosure               ,
+    valueSerializeFuncWrapper               ,
+
+
+
+
+    ) where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+
+import qualified GI.GLib as GLib
+import qualified GI.GObject as GObject
+
+-- callback ValueSerializeFunc
+valueSerializeFuncClosure :: ValueSerializeFunc -> IO Closure
+valueSerializeFuncClosure cb = newCClosure =<< mkValueSerializeFunc wrapped
+    where wrapped = valueSerializeFuncWrapper Nothing cb
+
+type ValueSerializeFuncC =
+    Ptr GValue ->
+    IO CString
+
+foreign import ccall "wrapper"
+    mkValueSerializeFunc :: ValueSerializeFuncC -> IO (FunPtr ValueSerializeFuncC)
+
+type ValueSerializeFunc =
+    GValue ->
+    IO T.Text
+
+noValueSerializeFunc :: Maybe ValueSerializeFunc
+noValueSerializeFunc = Nothing
+
+valueSerializeFuncWrapper ::
+    Maybe (Ptr (FunPtr (ValueSerializeFuncC))) ->
+    ValueSerializeFunc ->
+    Ptr GValue ->
+    IO CString
+valueSerializeFuncWrapper funptrptr _cb value1 = do
+    value1' <- (newBoxed GValue) value1
+    result <- _cb  value1'
+    maybeReleaseFunPtr funptrptr
+    result' <- textToCString result
+    return result'
+
+-- callback ValueDeserializeFunc
+valueDeserializeFuncClosure :: ValueDeserializeFunc -> IO Closure
+valueDeserializeFuncClosure cb = newCClosure =<< mkValueDeserializeFunc wrapped
+    where wrapped = valueDeserializeFuncWrapper Nothing cb
+
+type ValueDeserializeFuncC =
+    Ptr GValue ->
+    CString ->
+    IO CInt
+
+foreign import ccall "wrapper"
+    mkValueDeserializeFunc :: ValueDeserializeFuncC -> IO (FunPtr ValueDeserializeFuncC)
+
+type ValueDeserializeFunc =
+    GValue ->
+    T.Text ->
+    IO Bool
+
+noValueDeserializeFunc :: Maybe ValueDeserializeFunc
+noValueDeserializeFunc = Nothing
+
+valueDeserializeFuncWrapper ::
+    Maybe (Ptr (FunPtr (ValueDeserializeFuncC))) ->
+    ValueDeserializeFunc ->
+    Ptr GValue ->
+    CString ->
+    IO CInt
+valueDeserializeFuncWrapper funptrptr _cb dest s = do
+    dest' <- (newBoxed GValue) dest
+    s' <- cstringToText s
+    result <- _cb  dest' s'
+    maybeReleaseFunPtr funptrptr
+    let result' = (fromIntegral . fromEnum) result
+    return result'
+
+-- callback ValueCompareFunc
+valueCompareFuncClosure :: ValueCompareFunc -> IO Closure
+valueCompareFuncClosure cb = newCClosure =<< mkValueCompareFunc wrapped
+    where wrapped = valueCompareFuncWrapper Nothing cb
+
+type ValueCompareFuncC =
+    Ptr GValue ->
+    Ptr GValue ->
+    IO Int32
+
+foreign import ccall "wrapper"
+    mkValueCompareFunc :: ValueCompareFuncC -> IO (FunPtr ValueCompareFuncC)
+
+type ValueCompareFunc =
+    GValue ->
+    GValue ->
+    IO Int32
+
+noValueCompareFunc :: Maybe ValueCompareFunc
+noValueCompareFunc = Nothing
+
+valueCompareFuncWrapper ::
+    Maybe (Ptr (FunPtr (ValueCompareFuncC))) ->
+    ValueCompareFunc ->
+    Ptr GValue ->
+    Ptr GValue ->
+    IO Int32
+valueCompareFuncWrapper funptrptr _cb value1 value2 = do
+    value1' <- (newBoxed GValue) value1
+    value2' <- (newBoxed GValue) value2
+    result <- _cb  value1' value2'
+    maybeReleaseFunPtr funptrptr
+    return result
+
+-- callback TypeFindSuggestFieldCallback
+typeFindSuggestFieldCallbackClosure :: TypeFindSuggestFieldCallback -> IO Closure
+typeFindSuggestFieldCallbackClosure cb = newCClosure =<< mkTypeFindSuggestFieldCallback wrapped
+    where wrapped = typeFindSuggestFieldCallbackWrapper Nothing cb
+
+type TypeFindSuggestFieldCallbackC =
+    Ptr () ->
+    Word32 ->
+    Ptr Caps ->
+    IO ()
+
+foreign import ccall "wrapper"
+    mkTypeFindSuggestFieldCallback :: TypeFindSuggestFieldCallbackC -> IO (FunPtr TypeFindSuggestFieldCallbackC)
+
+type TypeFindSuggestFieldCallback =
+    Ptr () ->
+    Word32 ->
+    Caps ->
+    IO ()
+
+noTypeFindSuggestFieldCallback :: Maybe TypeFindSuggestFieldCallback
+noTypeFindSuggestFieldCallback = Nothing
+
+typeFindSuggestFieldCallbackWrapper ::
+    Maybe (Ptr (FunPtr (TypeFindSuggestFieldCallbackC))) ->
+    TypeFindSuggestFieldCallback ->
+    Ptr () ->
+    Word32 ->
+    Ptr Caps ->
+    IO ()
+typeFindSuggestFieldCallbackWrapper funptrptr _cb data_ probability caps = do
+    caps' <- (newBoxed Caps) caps
+    _cb  data_ probability caps'
+    maybeReleaseFunPtr funptrptr
+
+-- callback TypeFindPeekFieldCallback
+typeFindPeekFieldCallbackClosure :: TypeFindPeekFieldCallback -> IO Closure
+typeFindPeekFieldCallbackClosure cb = newCClosure =<< mkTypeFindPeekFieldCallback wrapped
+    where wrapped = typeFindPeekFieldCallbackWrapper Nothing cb
+
+type TypeFindPeekFieldCallbackC =
+    Ptr () ->
+    Int64 ->
+    Word32 ->
+    IO Word8
+
+foreign import ccall "wrapper"
+    mkTypeFindPeekFieldCallback :: TypeFindPeekFieldCallbackC -> IO (FunPtr TypeFindPeekFieldCallbackC)
+
+type TypeFindPeekFieldCallback =
+    Ptr () ->
+    Int64 ->
+    Word32 ->
+    IO Word8
+
+noTypeFindPeekFieldCallback :: Maybe TypeFindPeekFieldCallback
+noTypeFindPeekFieldCallback = Nothing
+
+typeFindPeekFieldCallbackWrapper ::
+    Maybe (Ptr (FunPtr (TypeFindPeekFieldCallbackC))) ->
+    TypeFindPeekFieldCallback ->
+    Ptr () ->
+    Int64 ->
+    Word32 ->
+    IO Word8
+typeFindPeekFieldCallbackWrapper funptrptr _cb data_ offset size = do
+    result <- _cb  data_ offset size
+    maybeReleaseFunPtr funptrptr
+    return result
+
+-- callback TypeFindGetLengthFieldCallback
+typeFindGetLengthFieldCallbackClosure :: TypeFindGetLengthFieldCallback -> IO Closure
+typeFindGetLengthFieldCallbackClosure cb = newCClosure =<< mkTypeFindGetLengthFieldCallback wrapped
+    where wrapped = typeFindGetLengthFieldCallbackWrapper Nothing cb
+
+type TypeFindGetLengthFieldCallbackC =
+    Ptr () ->
+    IO Word64
+
+foreign import ccall "wrapper"
+    mkTypeFindGetLengthFieldCallback :: TypeFindGetLengthFieldCallbackC -> IO (FunPtr TypeFindGetLengthFieldCallbackC)
+
+type TypeFindGetLengthFieldCallback =
+    Ptr () ->
+    IO Word64
+
+noTypeFindGetLengthFieldCallback :: Maybe TypeFindGetLengthFieldCallback
+noTypeFindGetLengthFieldCallback = Nothing
+
+typeFindGetLengthFieldCallbackWrapper ::
+    Maybe (Ptr (FunPtr (TypeFindGetLengthFieldCallbackC))) ->
+    TypeFindGetLengthFieldCallback ->
+    Ptr () ->
+    IO Word64
+typeFindGetLengthFieldCallbackWrapper funptrptr _cb data_ = do
+    result <- _cb  data_
+    maybeReleaseFunPtr funptrptr
+    return result
+
+-- callback TypeFindFunction
+typeFindFunctionClosure :: TypeFindFunction -> IO Closure
+typeFindFunctionClosure cb = newCClosure =<< mkTypeFindFunction wrapped
+    where wrapped = typeFindFunctionWrapper Nothing cb
+
+type TypeFindFunctionC =
+    Ptr TypeFind ->
+    Ptr () ->
+    IO ()
+
+foreign import ccall "wrapper"
+    mkTypeFindFunction :: TypeFindFunctionC -> IO (FunPtr TypeFindFunctionC)
+
+type TypeFindFunction =
+    TypeFind ->
+    IO ()
+
+noTypeFindFunction :: Maybe TypeFindFunction
+noTypeFindFunction = Nothing
+
+typeFindFunctionWrapper ::
+    Maybe (Ptr (FunPtr (TypeFindFunctionC))) ->
+    TypeFindFunction ->
+    Ptr TypeFind ->
+    Ptr () ->
+    IO ()
+typeFindFunctionWrapper funptrptr _cb find _ = do
+    find' <- (newPtr 64 TypeFind) find
+    _cb  find'
+    maybeReleaseFunPtr funptrptr
+
+-- callback TaskThreadFunc
+taskThreadFuncClosure :: TaskThreadFunc -> IO Closure
+taskThreadFuncClosure cb = newCClosure =<< mkTaskThreadFunc wrapped
+    where wrapped = taskThreadFuncWrapper Nothing cb
+
+type TaskThreadFuncC =
+    Ptr Task ->
+    Ptr GLib.Thread ->
+    Ptr () ->
+    IO ()
+
+foreign import ccall "wrapper"
+    mkTaskThreadFunc :: TaskThreadFuncC -> IO (FunPtr TaskThreadFuncC)
+
+type TaskThreadFunc =
+    Task ->
+    GLib.Thread ->
+    IO ()
+
+noTaskThreadFunc :: Maybe TaskThreadFunc
+noTaskThreadFunc = Nothing
+
+taskThreadFuncWrapper ::
+    Maybe (Ptr (FunPtr (TaskThreadFuncC))) ->
+    TaskThreadFunc ->
+    Ptr Task ->
+    Ptr GLib.Thread ->
+    Ptr () ->
+    IO ()
+taskThreadFuncWrapper funptrptr _cb task thread _ = do
+    task' <- (newObject Task) task
+    thread' <- (newBoxed GLib.Thread) thread
+    _cb  task' thread'
+    maybeReleaseFunPtr funptrptr
+
+-- callback TaskPoolFunction
+taskPoolFunctionClosure :: TaskPoolFunction -> IO Closure
+taskPoolFunctionClosure cb = newCClosure =<< mkTaskPoolFunction wrapped
+    where wrapped = taskPoolFunctionWrapper Nothing cb
+
+type TaskPoolFunctionC =
+    Ptr () ->
+    IO ()
+
+foreign import ccall "wrapper"
+    mkTaskPoolFunction :: TaskPoolFunctionC -> IO (FunPtr TaskPoolFunctionC)
+
+type TaskPoolFunction =
+    IO ()
+
+noTaskPoolFunction :: Maybe TaskPoolFunction
+noTaskPoolFunction = Nothing
+
+taskPoolFunctionWrapper ::
+    Maybe (Ptr (FunPtr (TaskPoolFunctionC))) ->
+    TaskPoolFunction ->
+    Ptr () ->
+    IO ()
+taskPoolFunctionWrapper funptrptr _cb _ = do
+    _cb 
+    maybeReleaseFunPtr funptrptr
+
+-- callback TaskFunction
+taskFunctionClosure :: TaskFunction -> IO Closure
+taskFunctionClosure cb = newCClosure =<< mkTaskFunction wrapped
+    where wrapped = taskFunctionWrapper Nothing cb
+
+type TaskFunctionC =
+    Ptr () ->
+    IO ()
+
+foreign import ccall "wrapper"
+    mkTaskFunction :: TaskFunctionC -> IO (FunPtr TaskFunctionC)
+
+type TaskFunction =
+    IO ()
+
+noTaskFunction :: Maybe TaskFunction
+noTaskFunction = Nothing
+
+taskFunctionWrapper ::
+    Maybe (Ptr (FunPtr (TaskFunctionC))) ->
+    TaskFunction ->
+    Ptr () ->
+    IO ()
+taskFunctionWrapper funptrptr _cb _ = do
+    _cb 
+    maybeReleaseFunPtr funptrptr
+
+-- callback TagMergeFunc
+tagMergeFuncClosure :: TagMergeFunc -> IO Closure
+tagMergeFuncClosure cb = newCClosure =<< mkTagMergeFunc wrapped
+    where wrapped = tagMergeFuncWrapper Nothing cb
+
+type TagMergeFuncC =
+    Ptr GValue ->
+    Ptr GValue ->
+    IO ()
+
+foreign import ccall "wrapper"
+    mkTagMergeFunc :: TagMergeFuncC -> IO (FunPtr TagMergeFuncC)
+
+type TagMergeFunc =
+    GValue ->
+    GValue ->
+    IO ()
+
+noTagMergeFunc :: Maybe TagMergeFunc
+noTagMergeFunc = Nothing
+
+tagMergeFuncWrapper ::
+    Maybe (Ptr (FunPtr (TagMergeFuncC))) ->
+    TagMergeFunc ->
+    Ptr GValue ->
+    Ptr GValue ->
+    IO ()
+tagMergeFuncWrapper funptrptr _cb dest src = do
+    dest' <- (newBoxed GValue) dest
+    src' <- (newBoxed GValue) src
+    _cb  dest' src'
+    maybeReleaseFunPtr funptrptr
+
+-- callback TagForeachFunc
+tagForeachFuncClosure :: TagForeachFunc -> IO Closure
+tagForeachFuncClosure cb = newCClosure =<< mkTagForeachFunc wrapped
+    where wrapped = tagForeachFuncWrapper Nothing cb
+
+type TagForeachFuncC =
+    Ptr TagList ->
+    CString ->
+    Ptr () ->
+    IO ()
+
+foreign import ccall "wrapper"
+    mkTagForeachFunc :: TagForeachFuncC -> IO (FunPtr TagForeachFuncC)
+
+type TagForeachFunc =
+    TagList ->
+    T.Text ->
+    IO ()
+
+noTagForeachFunc :: Maybe TagForeachFunc
+noTagForeachFunc = Nothing
+
+tagForeachFuncWrapper ::
+    Maybe (Ptr (FunPtr (TagForeachFuncC))) ->
+    TagForeachFunc ->
+    Ptr TagList ->
+    CString ->
+    Ptr () ->
+    IO ()
+tagForeachFuncWrapper funptrptr _cb list tag _ = do
+    list' <- (newBoxed TagList) list
+    tag' <- cstringToText tag
+    _cb  list' tag'
+    maybeReleaseFunPtr funptrptr
+
+-- callback StructureMapFunc
+structureMapFuncClosure :: StructureMapFunc -> IO Closure
+structureMapFuncClosure cb = newCClosure =<< mkStructureMapFunc wrapped
+    where wrapped = structureMapFuncWrapper Nothing cb
+
+type StructureMapFuncC =
+    Word32 ->
+    Ptr GValue ->
+    Ptr () ->
+    IO CInt
+
+foreign import ccall "wrapper"
+    mkStructureMapFunc :: StructureMapFuncC -> IO (FunPtr StructureMapFuncC)
+
+type StructureMapFunc =
+    Word32 ->
+    GValue ->
+    IO Bool
+
+noStructureMapFunc :: Maybe StructureMapFunc
+noStructureMapFunc = Nothing
+
+structureMapFuncWrapper ::
+    Maybe (Ptr (FunPtr (StructureMapFuncC))) ->
+    StructureMapFunc ->
+    Word32 ->
+    Ptr GValue ->
+    Ptr () ->
+    IO CInt
+structureMapFuncWrapper funptrptr _cb fieldId value _ = do
+    value' <- (newBoxed GValue) value
+    result <- _cb  fieldId value'
+    maybeReleaseFunPtr funptrptr
+    let result' = (fromIntegral . fromEnum) result
+    return result'
+
+-- callback StructureForeachFunc
+structureForeachFuncClosure :: StructureForeachFunc -> IO Closure
+structureForeachFuncClosure cb = newCClosure =<< mkStructureForeachFunc wrapped
+    where wrapped = structureForeachFuncWrapper Nothing cb
+
+type StructureForeachFuncC =
+    Word32 ->
+    Ptr GValue ->
+    Ptr () ->
+    IO CInt
+
+foreign import ccall "wrapper"
+    mkStructureForeachFunc :: StructureForeachFuncC -> IO (FunPtr StructureForeachFuncC)
+
+type StructureForeachFunc =
+    Word32 ->
+    GValue ->
+    IO Bool
+
+noStructureForeachFunc :: Maybe StructureForeachFunc
+noStructureForeachFunc = Nothing
+
+structureForeachFuncWrapper ::
+    Maybe (Ptr (FunPtr (StructureForeachFuncC))) ->
+    StructureForeachFunc ->
+    Word32 ->
+    Ptr GValue ->
+    Ptr () ->
+    IO CInt
+structureForeachFuncWrapper funptrptr _cb fieldId value _ = do
+    value' <- (newBoxed GValue) value
+    result <- _cb  fieldId value'
+    maybeReleaseFunPtr funptrptr
+    let result' = (fromIntegral . fromEnum) result
+    return result'
+
+-- callback StructureFilterMapFunc
+structureFilterMapFuncClosure :: StructureFilterMapFunc -> IO Closure
+structureFilterMapFuncClosure cb = newCClosure =<< mkStructureFilterMapFunc wrapped
+    where wrapped = structureFilterMapFuncWrapper Nothing cb
+
+type StructureFilterMapFuncC =
+    Word32 ->
+    Ptr GValue ->
+    Ptr () ->
+    IO CInt
+
+foreign import ccall "wrapper"
+    mkStructureFilterMapFunc :: StructureFilterMapFuncC -> IO (FunPtr StructureFilterMapFuncC)
+
+type StructureFilterMapFunc =
+    Word32 ->
+    GValue ->
+    IO Bool
+
+noStructureFilterMapFunc :: Maybe StructureFilterMapFunc
+noStructureFilterMapFunc = Nothing
+
+structureFilterMapFuncWrapper ::
+    Maybe (Ptr (FunPtr (StructureFilterMapFuncC))) ->
+    StructureFilterMapFunc ->
+    Word32 ->
+    Ptr GValue ->
+    Ptr () ->
+    IO CInt
+structureFilterMapFuncWrapper funptrptr _cb fieldId value _ = do
+    value' <- (newBoxed GValue) value
+    result <- _cb  fieldId value'
+    maybeReleaseFunPtr funptrptr
+    let result' = (fromIntegral . fromEnum) result
+    return result'
+
+-- callback PluginInitFunc
+pluginInitFuncClosure :: PluginInitFunc -> IO Closure
+pluginInitFuncClosure cb = newCClosure =<< mkPluginInitFunc wrapped
+    where wrapped = pluginInitFuncWrapper Nothing cb
+
+type PluginInitFuncC =
+    Ptr Plugin ->
+    IO CInt
+
+foreign import ccall "wrapper"
+    mkPluginInitFunc :: PluginInitFuncC -> IO (FunPtr PluginInitFuncC)
+
+type PluginInitFunc =
+    Plugin ->
+    IO Bool
+
+noPluginInitFunc :: Maybe PluginInitFunc
+noPluginInitFunc = Nothing
+
+pluginInitFuncWrapper ::
+    Maybe (Ptr (FunPtr (PluginInitFuncC))) ->
+    PluginInitFunc ->
+    Ptr Plugin ->
+    IO CInt
+pluginInitFuncWrapper funptrptr _cb plugin = do
+    plugin' <- (newObject Plugin) plugin
+    result <- _cb  plugin'
+    maybeReleaseFunPtr funptrptr
+    let result' = (fromIntegral . fromEnum) result
+    return result'
+
+-- callback PluginInitFullFunc
+pluginInitFullFuncClosure :: PluginInitFullFunc -> IO Closure
+pluginInitFullFuncClosure cb = newCClosure =<< mkPluginInitFullFunc wrapped
+    where wrapped = pluginInitFullFuncWrapper Nothing cb
+
+type PluginInitFullFuncC =
+    Ptr Plugin ->
+    Ptr () ->
+    IO CInt
+
+foreign import ccall "wrapper"
+    mkPluginInitFullFunc :: PluginInitFullFuncC -> IO (FunPtr PluginInitFullFuncC)
+
+type PluginInitFullFunc =
+    Plugin ->
+    IO Bool
+
+noPluginInitFullFunc :: Maybe PluginInitFullFunc
+noPluginInitFullFunc = Nothing
+
+pluginInitFullFuncWrapper ::
+    Maybe (Ptr (FunPtr (PluginInitFullFuncC))) ->
+    PluginInitFullFunc ->
+    Ptr Plugin ->
+    Ptr () ->
+    IO CInt
+pluginInitFullFuncWrapper funptrptr _cb plugin _ = do
+    plugin' <- (newObject Plugin) plugin
+    result <- _cb  plugin'
+    maybeReleaseFunPtr funptrptr
+    let result' = (fromIntegral . fromEnum) result
+    return result'
+
+-- callback PluginFilter
+pluginFilterClosure :: PluginFilter -> IO Closure
+pluginFilterClosure cb = newCClosure =<< mkPluginFilter wrapped
+    where wrapped = pluginFilterWrapper Nothing cb
+
+type PluginFilterC =
+    Ptr Plugin ->
+    Ptr () ->
+    IO CInt
+
+foreign import ccall "wrapper"
+    mkPluginFilter :: PluginFilterC -> IO (FunPtr PluginFilterC)
+
+type PluginFilter =
+    Plugin ->
+    IO Bool
+
+noPluginFilter :: Maybe PluginFilter
+noPluginFilter = Nothing
+
+pluginFilterWrapper ::
+    Maybe (Ptr (FunPtr (PluginFilterC))) ->
+    PluginFilter ->
+    Ptr Plugin ->
+    Ptr () ->
+    IO CInt
+pluginFilterWrapper funptrptr _cb plugin _ = do
+    plugin' <- (newObject Plugin) plugin
+    result <- _cb  plugin'
+    maybeReleaseFunPtr funptrptr
+    let result' = (fromIntegral . fromEnum) result
+    return result'
+
+-- callback PluginFeatureFilter
+pluginFeatureFilterClosure :: PluginFeatureFilter -> IO Closure
+pluginFeatureFilterClosure cb = newCClosure =<< mkPluginFeatureFilter wrapped
+    where wrapped = pluginFeatureFilterWrapper Nothing cb
+
+type PluginFeatureFilterC =
+    Ptr PluginFeature ->
+    Ptr () ->
+    IO CInt
+
+foreign import ccall "wrapper"
+    mkPluginFeatureFilter :: PluginFeatureFilterC -> IO (FunPtr PluginFeatureFilterC)
+
+type PluginFeatureFilter =
+    PluginFeature ->
+    IO Bool
+
+noPluginFeatureFilter :: Maybe PluginFeatureFilter
+noPluginFeatureFilter = Nothing
+
+pluginFeatureFilterWrapper ::
+    Maybe (Ptr (FunPtr (PluginFeatureFilterC))) ->
+    PluginFeatureFilter ->
+    Ptr PluginFeature ->
+    Ptr () ->
+    IO CInt
+pluginFeatureFilterWrapper funptrptr _cb feature _ = do
+    feature' <- (newObject PluginFeature) feature
+    result <- _cb  feature'
+    maybeReleaseFunPtr funptrptr
+    let result' = (fromIntegral . fromEnum) result
+    return result'
+
+-- callback PadUnlinkFunction
+padUnlinkFunctionClosure :: PadUnlinkFunction -> IO Closure
+padUnlinkFunctionClosure cb = newCClosure =<< mkPadUnlinkFunction wrapped
+    where wrapped = padUnlinkFunctionWrapper Nothing cb
+
+type PadUnlinkFunctionC =
+    Ptr Pad ->
+    Ptr Object ->
+    IO ()
+
+foreign import ccall "wrapper"
+    mkPadUnlinkFunction :: PadUnlinkFunctionC -> IO (FunPtr PadUnlinkFunctionC)
+
+type PadUnlinkFunction =
+    Pad ->
+    Maybe Object ->
+    IO ()
+
+noPadUnlinkFunction :: Maybe PadUnlinkFunction
+noPadUnlinkFunction = Nothing
+
+padUnlinkFunctionWrapper ::
+    Maybe (Ptr (FunPtr (PadUnlinkFunctionC))) ->
+    PadUnlinkFunction ->
+    Ptr Pad ->
+    Ptr Object ->
+    IO ()
+padUnlinkFunctionWrapper funptrptr _cb pad parent = do
+    pad' <- (newObject Pad) pad
+    maybeParent <-
+        if parent == nullPtr
+        then return Nothing
+        else do
+            parent' <- (newObject Object) parent
+            return $ Just parent'
+    _cb  pad' maybeParent
+    maybeReleaseFunPtr funptrptr
+
+-- callback PadStickyEventsForeachFunction
+padStickyEventsForeachFunctionClosure :: PadStickyEventsForeachFunction -> IO Closure
+padStickyEventsForeachFunctionClosure cb = newCClosure =<< mkPadStickyEventsForeachFunction wrapped
+    where wrapped = padStickyEventsForeachFunctionWrapper Nothing cb
+
+type PadStickyEventsForeachFunctionC =
+    Ptr Pad ->
+    Ptr Event ->
+    Ptr () ->
+    IO CInt
+
+foreign import ccall "wrapper"
+    mkPadStickyEventsForeachFunction :: PadStickyEventsForeachFunctionC -> IO (FunPtr PadStickyEventsForeachFunctionC)
+
+type PadStickyEventsForeachFunction =
+    Pad ->
+    Maybe Event ->
+    IO Bool
+
+noPadStickyEventsForeachFunction :: Maybe PadStickyEventsForeachFunction
+noPadStickyEventsForeachFunction = Nothing
+
+padStickyEventsForeachFunctionWrapper ::
+    Maybe (Ptr (FunPtr (PadStickyEventsForeachFunctionC))) ->
+    PadStickyEventsForeachFunction ->
+    Ptr Pad ->
+    Ptr Event ->
+    Ptr () ->
+    IO CInt
+padStickyEventsForeachFunctionWrapper funptrptr _cb pad event _ = do
+    pad' <- (newObject Pad) pad
+    maybeEvent <-
+        if event == nullPtr
+        then return Nothing
+        else do
+            event' <- (newBoxed Event) event
+            return $ Just event'
+    result <- _cb  pad' maybeEvent
+    maybeReleaseFunPtr funptrptr
+    let result' = (fromIntegral . fromEnum) result
+    return result'
+
+-- callback PadQueryFunction
+padQueryFunctionClosure :: PadQueryFunction -> IO Closure
+padQueryFunctionClosure cb = newCClosure =<< mkPadQueryFunction wrapped
+    where wrapped = padQueryFunctionWrapper Nothing cb
+
+type PadQueryFunctionC =
+    Ptr Pad ->
+    Ptr Object ->
+    Ptr Query ->
+    IO CInt
+
+foreign import ccall "wrapper"
+    mkPadQueryFunction :: PadQueryFunctionC -> IO (FunPtr PadQueryFunctionC)
+
+type PadQueryFunction =
+    Pad ->
+    Maybe Object ->
+    Query ->
+    IO Bool
+
+noPadQueryFunction :: Maybe PadQueryFunction
+noPadQueryFunction = Nothing
+
+padQueryFunctionWrapper ::
+    Maybe (Ptr (FunPtr (PadQueryFunctionC))) ->
+    PadQueryFunction ->
+    Ptr Pad ->
+    Ptr Object ->
+    Ptr Query ->
+    IO CInt
+padQueryFunctionWrapper funptrptr _cb pad parent query = do
+    pad' <- (newObject Pad) pad
+    maybeParent <-
+        if parent == nullPtr
+        then return Nothing
+        else do
+            parent' <- (newObject Object) parent
+            return $ Just parent'
+    query' <- (newBoxed Query) query
+    result <- _cb  pad' maybeParent query'
+    maybeReleaseFunPtr funptrptr
+    let result' = (fromIntegral . fromEnum) result
+    return result'
+
+-- callback PadProbeCallback
+padProbeCallbackClosure :: PadProbeCallback -> IO Closure
+padProbeCallbackClosure cb = newCClosure =<< mkPadProbeCallback wrapped
+    where wrapped = padProbeCallbackWrapper Nothing cb
+
+type PadProbeCallbackC =
+    Ptr Pad ->
+    Ptr PadProbeInfo ->
+    Ptr () ->
+    IO CUInt
+
+foreign import ccall "wrapper"
+    mkPadProbeCallback :: PadProbeCallbackC -> IO (FunPtr PadProbeCallbackC)
+
+type PadProbeCallback =
+    Pad ->
+    PadProbeInfo ->
+    IO PadProbeReturn
+
+noPadProbeCallback :: Maybe PadProbeCallback
+noPadProbeCallback = Nothing
+
+padProbeCallbackWrapper ::
+    Maybe (Ptr (FunPtr (PadProbeCallbackC))) ->
+    PadProbeCallback ->
+    Ptr Pad ->
+    Ptr PadProbeInfo ->
+    Ptr () ->
+    IO CUInt
+padProbeCallbackWrapper funptrptr _cb pad info _ = do
+    pad' <- (newObject Pad) pad
+    info' <- (newPtr 40 PadProbeInfo) info
+    result <- _cb  pad' info'
+    maybeReleaseFunPtr funptrptr
+    let result' = (fromIntegral . fromEnum) result
+    return result'
+
+-- callback PadLinkFunction
+padLinkFunctionClosure :: PadLinkFunction -> IO Closure
+padLinkFunctionClosure cb = newCClosure =<< mkPadLinkFunction wrapped
+    where wrapped = padLinkFunctionWrapper Nothing cb
+
+type PadLinkFunctionC =
+    Ptr Pad ->
+    Ptr Object ->
+    Ptr Pad ->
+    IO CUInt
+
+foreign import ccall "wrapper"
+    mkPadLinkFunction :: PadLinkFunctionC -> IO (FunPtr PadLinkFunctionC)
+
+type PadLinkFunction =
+    Pad ->
+    Maybe Object ->
+    Pad ->
+    IO PadLinkReturn
+
+noPadLinkFunction :: Maybe PadLinkFunction
+noPadLinkFunction = Nothing
+
+padLinkFunctionWrapper ::
+    Maybe (Ptr (FunPtr (PadLinkFunctionC))) ->
+    PadLinkFunction ->
+    Ptr Pad ->
+    Ptr Object ->
+    Ptr Pad ->
+    IO CUInt
+padLinkFunctionWrapper funptrptr _cb pad parent peer = do
+    pad' <- (newObject Pad) pad
+    maybeParent <-
+        if parent == nullPtr
+        then return Nothing
+        else do
+            parent' <- (newObject Object) parent
+            return $ Just parent'
+    peer' <- (newObject Pad) peer
+    result <- _cb  pad' maybeParent peer'
+    maybeReleaseFunPtr funptrptr
+    let result' = (fromIntegral . fromEnum) result
+    return result'
+
+-- callback PadIterIntLinkFunction
+padIterIntLinkFunctionClosure :: PadIterIntLinkFunction -> IO Closure
+padIterIntLinkFunctionClosure cb = newCClosure =<< mkPadIterIntLinkFunction wrapped
+    where wrapped = padIterIntLinkFunctionWrapper Nothing cb
+
+type PadIterIntLinkFunctionC =
+    Ptr Pad ->
+    Ptr Object ->
+    IO (Ptr Iterator)
+
+foreign import ccall "wrapper"
+    mkPadIterIntLinkFunction :: PadIterIntLinkFunctionC -> IO (FunPtr PadIterIntLinkFunctionC)
+
+type PadIterIntLinkFunction =
+    Pad ->
+    Maybe Object ->
+    IO Iterator
+
+noPadIterIntLinkFunction :: Maybe PadIterIntLinkFunction
+noPadIterIntLinkFunction = Nothing
+
+padIterIntLinkFunctionWrapper ::
+    Maybe (Ptr (FunPtr (PadIterIntLinkFunctionC))) ->
+    PadIterIntLinkFunction ->
+    Ptr Pad ->
+    Ptr Object ->
+    IO (Ptr Iterator)
+padIterIntLinkFunctionWrapper funptrptr _cb pad parent = do
+    pad' <- (newObject Pad) pad
+    maybeParent <-
+        if parent == nullPtr
+        then return Nothing
+        else do
+            parent' <- (newObject Object) parent
+            return $ Just parent'
+    result <- _cb  pad' maybeParent
+    maybeReleaseFunPtr funptrptr
+    result' <- copyBoxed result
+    return result'
+
+-- callback PadGetRangeFunction
+padGetRangeFunctionClosure :: PadGetRangeFunction -> IO Closure
+padGetRangeFunctionClosure cb = newCClosure =<< mkPadGetRangeFunction wrapped
+    where wrapped = padGetRangeFunctionWrapper Nothing cb
+
+type PadGetRangeFunctionC =
+    Ptr Pad ->
+    Ptr Object ->
+    Word64 ->
+    Word32 ->
+    Ptr Buffer ->
+    IO CUInt
+
+foreign import ccall "wrapper"
+    mkPadGetRangeFunction :: PadGetRangeFunctionC -> IO (FunPtr PadGetRangeFunctionC)
+
+type PadGetRangeFunction =
+    Pad ->
+    Maybe Object ->
+    Word64 ->
+    Word32 ->
+    Buffer ->
+    IO FlowReturn
+
+noPadGetRangeFunction :: Maybe PadGetRangeFunction
+noPadGetRangeFunction = Nothing
+
+padGetRangeFunctionWrapper ::
+    Maybe (Ptr (FunPtr (PadGetRangeFunctionC))) ->
+    PadGetRangeFunction ->
+    Ptr Pad ->
+    Ptr Object ->
+    Word64 ->
+    Word32 ->
+    Ptr Buffer ->
+    IO CUInt
+padGetRangeFunctionWrapper funptrptr _cb pad parent offset length_ buffer = do
+    pad' <- (newObject Pad) pad
+    maybeParent <-
+        if parent == nullPtr
+        then return Nothing
+        else do
+            parent' <- (newObject Object) parent
+            return $ Just parent'
+    buffer' <- (newBoxed Buffer) buffer
+    result <- _cb  pad' maybeParent offset length_ buffer'
+    maybeReleaseFunPtr funptrptr
+    let result' = (fromIntegral . fromEnum) result
+    return result'
+
+-- callback PadForwardFunction
+padForwardFunctionClosure :: PadForwardFunction -> IO Closure
+padForwardFunctionClosure cb = newCClosure =<< mkPadForwardFunction wrapped
+    where wrapped = padForwardFunctionWrapper Nothing cb
+
+type PadForwardFunctionC =
+    Ptr Pad ->
+    Ptr () ->
+    IO CInt
+
+foreign import ccall "wrapper"
+    mkPadForwardFunction :: PadForwardFunctionC -> IO (FunPtr PadForwardFunctionC)
+
+type PadForwardFunction =
+    Pad ->
+    IO Bool
+
+noPadForwardFunction :: Maybe PadForwardFunction
+noPadForwardFunction = Nothing
+
+padForwardFunctionWrapper ::
+    Maybe (Ptr (FunPtr (PadForwardFunctionC))) ->
+    PadForwardFunction ->
+    Ptr Pad ->
+    Ptr () ->
+    IO CInt
+padForwardFunctionWrapper funptrptr _cb pad _ = do
+    pad' <- (newObject Pad) pad
+    result <- _cb  pad'
+    maybeReleaseFunPtr funptrptr
+    let result' = (fromIntegral . fromEnum) result
+    return result'
+
+-- callback PadEventFunction
+padEventFunctionClosure :: PadEventFunction -> IO Closure
+padEventFunctionClosure cb = newCClosure =<< mkPadEventFunction wrapped
+    where wrapped = padEventFunctionWrapper Nothing cb
+
+type PadEventFunctionC =
+    Ptr Pad ->
+    Ptr Object ->
+    Ptr Event ->
+    IO CInt
+
+foreign import ccall "wrapper"
+    mkPadEventFunction :: PadEventFunctionC -> IO (FunPtr PadEventFunctionC)
+
+type PadEventFunction =
+    Pad ->
+    Maybe Object ->
+    Event ->
+    IO Bool
+
+noPadEventFunction :: Maybe PadEventFunction
+noPadEventFunction = Nothing
+
+padEventFunctionWrapper ::
+    Maybe (Ptr (FunPtr (PadEventFunctionC))) ->
+    PadEventFunction ->
+    Ptr Pad ->
+    Ptr Object ->
+    Ptr Event ->
+    IO CInt
+padEventFunctionWrapper funptrptr _cb pad parent event = do
+    pad' <- (newObject Pad) pad
+    maybeParent <-
+        if parent == nullPtr
+        then return Nothing
+        else do
+            parent' <- (newObject Object) parent
+            return $ Just parent'
+    event' <- (wrapBoxed Event) event
+    result <- _cb  pad' maybeParent event'
+    maybeReleaseFunPtr funptrptr
+    let result' = (fromIntegral . fromEnum) result
+    return result'
+
+-- callback PadChainListFunction
+padChainListFunctionClosure :: PadChainListFunction -> IO Closure
+padChainListFunctionClosure cb = newCClosure =<< mkPadChainListFunction wrapped
+    where wrapped = padChainListFunctionWrapper Nothing cb
+
+type PadChainListFunctionC =
+    Ptr Pad ->
+    Ptr Object ->
+    Ptr BufferList ->
+    IO CUInt
+
+foreign import ccall "wrapper"
+    mkPadChainListFunction :: PadChainListFunctionC -> IO (FunPtr PadChainListFunctionC)
+
+type PadChainListFunction =
+    Pad ->
+    Maybe Object ->
+    BufferList ->
+    IO FlowReturn
+
+noPadChainListFunction :: Maybe PadChainListFunction
+noPadChainListFunction = Nothing
+
+padChainListFunctionWrapper ::
+    Maybe (Ptr (FunPtr (PadChainListFunctionC))) ->
+    PadChainListFunction ->
+    Ptr Pad ->
+    Ptr Object ->
+    Ptr BufferList ->
+    IO CUInt
+padChainListFunctionWrapper funptrptr _cb pad parent list = do
+    pad' <- (newObject Pad) pad
+    maybeParent <-
+        if parent == nullPtr
+        then return Nothing
+        else do
+            parent' <- (newObject Object) parent
+            return $ Just parent'
+    list' <- (wrapBoxed BufferList) list
+    result <- _cb  pad' maybeParent list'
+    maybeReleaseFunPtr funptrptr
+    let result' = (fromIntegral . fromEnum) result
+    return result'
+
+-- callback PadChainFunction
+padChainFunctionClosure :: PadChainFunction -> IO Closure
+padChainFunctionClosure cb = newCClosure =<< mkPadChainFunction wrapped
+    where wrapped = padChainFunctionWrapper Nothing cb
+
+type PadChainFunctionC =
+    Ptr Pad ->
+    Ptr Object ->
+    Ptr Buffer ->
+    IO CUInt
+
+foreign import ccall "wrapper"
+    mkPadChainFunction :: PadChainFunctionC -> IO (FunPtr PadChainFunctionC)
+
+type PadChainFunction =
+    Pad ->
+    Maybe Object ->
+    Buffer ->
+    IO FlowReturn
+
+noPadChainFunction :: Maybe PadChainFunction
+noPadChainFunction = Nothing
+
+padChainFunctionWrapper ::
+    Maybe (Ptr (FunPtr (PadChainFunctionC))) ->
+    PadChainFunction ->
+    Ptr Pad ->
+    Ptr Object ->
+    Ptr Buffer ->
+    IO CUInt
+padChainFunctionWrapper funptrptr _cb pad parent buffer = do
+    pad' <- (newObject Pad) pad
+    maybeParent <-
+        if parent == nullPtr
+        then return Nothing
+        else do
+            parent' <- (newObject Object) parent
+            return $ Just parent'
+    buffer' <- (wrapBoxed Buffer) buffer
+    result <- _cb  pad' maybeParent buffer'
+    maybeReleaseFunPtr funptrptr
+    let result' = (fromIntegral . fromEnum) result
+    return result'
+
+-- callback PadActivateModeFunction
+padActivateModeFunctionClosure :: PadActivateModeFunction -> IO Closure
+padActivateModeFunctionClosure cb = newCClosure =<< mkPadActivateModeFunction wrapped
+    where wrapped = padActivateModeFunctionWrapper Nothing cb
+
+type PadActivateModeFunctionC =
+    Ptr Pad ->
+    Ptr Object ->
+    CUInt ->
+    CInt ->
+    IO CInt
+
+foreign import ccall "wrapper"
+    mkPadActivateModeFunction :: PadActivateModeFunctionC -> IO (FunPtr PadActivateModeFunctionC)
+
+type PadActivateModeFunction =
+    Pad ->
+    Object ->
+    PadMode ->
+    Bool ->
+    IO Bool
+
+noPadActivateModeFunction :: Maybe PadActivateModeFunction
+noPadActivateModeFunction = Nothing
+
+padActivateModeFunctionWrapper ::
+    Maybe (Ptr (FunPtr (PadActivateModeFunctionC))) ->
+    PadActivateModeFunction ->
+    Ptr Pad ->
+    Ptr Object ->
+    CUInt ->
+    CInt ->
+    IO CInt
+padActivateModeFunctionWrapper funptrptr _cb pad parent mode active = do
+    pad' <- (newObject Pad) pad
+    parent' <- (newObject Object) parent
+    let mode' = (toEnum . fromIntegral) mode
+    let active' = (/= 0) active
+    result <- _cb  pad' parent' mode' active'
+    maybeReleaseFunPtr funptrptr
+    let result' = (fromIntegral . fromEnum) result
+    return result'
+
+-- callback PadActivateFunction
+padActivateFunctionClosure :: PadActivateFunction -> IO Closure
+padActivateFunctionClosure cb = newCClosure =<< mkPadActivateFunction wrapped
+    where wrapped = padActivateFunctionWrapper Nothing cb
+
+type PadActivateFunctionC =
+    Ptr Pad ->
+    Ptr Object ->
+    IO CInt
+
+foreign import ccall "wrapper"
+    mkPadActivateFunction :: PadActivateFunctionC -> IO (FunPtr PadActivateFunctionC)
+
+type PadActivateFunction =
+    Pad ->
+    Object ->
+    IO Bool
+
+noPadActivateFunction :: Maybe PadActivateFunction
+noPadActivateFunction = Nothing
+
+padActivateFunctionWrapper ::
+    Maybe (Ptr (FunPtr (PadActivateFunctionC))) ->
+    PadActivateFunction ->
+    Ptr Pad ->
+    Ptr Object ->
+    IO CInt
+padActivateFunctionWrapper funptrptr _cb pad parent = do
+    pad' <- (newObject Pad) pad
+    parent' <- (newObject Object) parent
+    result <- _cb  pad' parent'
+    maybeReleaseFunPtr funptrptr
+    let result' = (fromIntegral . fromEnum) result
+    return result'
+
+-- callback MiniObjectNotify
+miniObjectNotifyClosure :: MiniObjectNotify -> IO Closure
+miniObjectNotifyClosure cb = newCClosure =<< mkMiniObjectNotify wrapped
+    where wrapped = miniObjectNotifyWrapper Nothing cb
+
+type MiniObjectNotifyC =
+    Ptr () ->
+    Ptr MiniObject ->
+    IO ()
+
+foreign import ccall "wrapper"
+    mkMiniObjectNotify :: MiniObjectNotifyC -> IO (FunPtr MiniObjectNotifyC)
+
+type MiniObjectNotify =
+    MiniObject ->
+    IO ()
+
+noMiniObjectNotify :: Maybe MiniObjectNotify
+noMiniObjectNotify = Nothing
+
+miniObjectNotifyWrapper ::
+    Maybe (Ptr (FunPtr (MiniObjectNotifyC))) ->
+    MiniObjectNotify ->
+    Ptr () ->
+    Ptr MiniObject ->
+    IO ()
+miniObjectNotifyWrapper funptrptr _cb _ obj = do
+    obj' <- (newPtr 64 MiniObject) obj
+    _cb  obj'
+    maybeReleaseFunPtr funptrptr
+
+-- callback MiniObjectFreeFunction
+miniObjectFreeFunctionClosure :: MiniObjectFreeFunction -> IO Closure
+miniObjectFreeFunctionClosure cb = newCClosure =<< mkMiniObjectFreeFunction wrapped
+    where wrapped = miniObjectFreeFunctionWrapper Nothing cb
+
+type MiniObjectFreeFunctionC =
+    Ptr MiniObject ->
+    IO ()
+
+foreign import ccall "wrapper"
+    mkMiniObjectFreeFunction :: MiniObjectFreeFunctionC -> IO (FunPtr MiniObjectFreeFunctionC)
+
+type MiniObjectFreeFunction =
+    MiniObject ->
+    IO ()
+
+noMiniObjectFreeFunction :: Maybe MiniObjectFreeFunction
+noMiniObjectFreeFunction = Nothing
+
+miniObjectFreeFunctionWrapper ::
+    Maybe (Ptr (FunPtr (MiniObjectFreeFunctionC))) ->
+    MiniObjectFreeFunction ->
+    Ptr MiniObject ->
+    IO ()
+miniObjectFreeFunctionWrapper funptrptr _cb obj = do
+    obj' <- (newPtr 64 MiniObject) obj
+    _cb  obj'
+    maybeReleaseFunPtr funptrptr
+
+-- callback MiniObjectDisposeFunction
+miniObjectDisposeFunctionClosure :: MiniObjectDisposeFunction -> IO Closure
+miniObjectDisposeFunctionClosure cb = newCClosure =<< mkMiniObjectDisposeFunction wrapped
+    where wrapped = miniObjectDisposeFunctionWrapper Nothing cb
+
+type MiniObjectDisposeFunctionC =
+    Ptr MiniObject ->
+    IO CInt
+
+foreign import ccall "wrapper"
+    mkMiniObjectDisposeFunction :: MiniObjectDisposeFunctionC -> IO (FunPtr MiniObjectDisposeFunctionC)
+
+type MiniObjectDisposeFunction =
+    MiniObject ->
+    IO Bool
+
+noMiniObjectDisposeFunction :: Maybe MiniObjectDisposeFunction
+noMiniObjectDisposeFunction = Nothing
+
+miniObjectDisposeFunctionWrapper ::
+    Maybe (Ptr (FunPtr (MiniObjectDisposeFunctionC))) ->
+    MiniObjectDisposeFunction ->
+    Ptr MiniObject ->
+    IO CInt
+miniObjectDisposeFunctionWrapper funptrptr _cb obj = do
+    obj' <- (newPtr 64 MiniObject) obj
+    result <- _cb  obj'
+    maybeReleaseFunPtr funptrptr
+    let result' = (fromIntegral . fromEnum) result
+    return result'
+
+-- callback MetaTransformFunction
+metaTransformFunctionClosure :: MetaTransformFunction -> IO Closure
+metaTransformFunctionClosure cb = newCClosure =<< mkMetaTransformFunction wrapped
+    where wrapped = metaTransformFunctionWrapper Nothing cb
+
+type MetaTransformFunctionC =
+    Ptr Buffer ->
+    Ptr Meta ->
+    Ptr Buffer ->
+    Word32 ->
+    Ptr () ->
+    IO CInt
+
+foreign import ccall "wrapper"
+    mkMetaTransformFunction :: MetaTransformFunctionC -> IO (FunPtr MetaTransformFunctionC)
+
+type MetaTransformFunction =
+    Buffer ->
+    Meta ->
+    Buffer ->
+    Word32 ->
+    Ptr () ->
+    IO Bool
+
+noMetaTransformFunction :: Maybe MetaTransformFunction
+noMetaTransformFunction = Nothing
+
+metaTransformFunctionWrapper ::
+    Maybe (Ptr (FunPtr (MetaTransformFunctionC))) ->
+    MetaTransformFunction ->
+    Ptr Buffer ->
+    Ptr Meta ->
+    Ptr Buffer ->
+    Word32 ->
+    Ptr () ->
+    IO CInt
+metaTransformFunctionWrapper funptrptr _cb transbuf meta buffer type_ data_ = do
+    transbuf' <- (newBoxed Buffer) transbuf
+    meta' <- (newPtr 16 Meta) meta
+    buffer' <- (newBoxed Buffer) buffer
+    result <- _cb  transbuf' meta' buffer' type_ data_
+    maybeReleaseFunPtr funptrptr
+    let result' = (fromIntegral . fromEnum) result
+    return result'
+
+-- callback MetaInitFunction
+metaInitFunctionClosure :: MetaInitFunction -> IO Closure
+metaInitFunctionClosure cb = newCClosure =<< mkMetaInitFunction wrapped
+    where wrapped = metaInitFunctionWrapper Nothing cb
+
+type MetaInitFunctionC =
+    Ptr Meta ->
+    Ptr () ->
+    Ptr Buffer ->
+    IO CInt
+
+foreign import ccall "wrapper"
+    mkMetaInitFunction :: MetaInitFunctionC -> IO (FunPtr MetaInitFunctionC)
+
+type MetaInitFunction =
+    Meta ->
+    Ptr () ->
+    Buffer ->
+    IO Bool
+
+noMetaInitFunction :: Maybe MetaInitFunction
+noMetaInitFunction = Nothing
+
+metaInitFunctionWrapper ::
+    Maybe (Ptr (FunPtr (MetaInitFunctionC))) ->
+    MetaInitFunction ->
+    Ptr Meta ->
+    Ptr () ->
+    Ptr Buffer ->
+    IO CInt
+metaInitFunctionWrapper funptrptr _cb meta params buffer = do
+    meta' <- (newPtr 16 Meta) meta
+    buffer' <- (newBoxed Buffer) buffer
+    result <- _cb  meta' params buffer'
+    maybeReleaseFunPtr funptrptr
+    let result' = (fromIntegral . fromEnum) result
+    return result'
+
+-- callback MetaFreeFunction
+metaFreeFunctionClosure :: MetaFreeFunction -> IO Closure
+metaFreeFunctionClosure cb = newCClosure =<< mkMetaFreeFunction wrapped
+    where wrapped = metaFreeFunctionWrapper Nothing cb
+
+type MetaFreeFunctionC =
+    Ptr Meta ->
+    Ptr Buffer ->
+    IO ()
+
+foreign import ccall "wrapper"
+    mkMetaFreeFunction :: MetaFreeFunctionC -> IO (FunPtr MetaFreeFunctionC)
+
+type MetaFreeFunction =
+    Meta ->
+    Buffer ->
+    IO ()
+
+noMetaFreeFunction :: Maybe MetaFreeFunction
+noMetaFreeFunction = Nothing
+
+metaFreeFunctionWrapper ::
+    Maybe (Ptr (FunPtr (MetaFreeFunctionC))) ->
+    MetaFreeFunction ->
+    Ptr Meta ->
+    Ptr Buffer ->
+    IO ()
+metaFreeFunctionWrapper funptrptr _cb meta buffer = do
+    meta' <- (newPtr 16 Meta) meta
+    buffer' <- (newBoxed Buffer) buffer
+    _cb  meta' buffer'
+    maybeReleaseFunPtr funptrptr
+
+-- callback MemoryUnmapFunction
+memoryUnmapFunctionClosure :: MemoryUnmapFunction -> IO Closure
+memoryUnmapFunctionClosure cb = newCClosure =<< mkMemoryUnmapFunction wrapped
+    where wrapped = memoryUnmapFunctionWrapper Nothing cb
+
+type MemoryUnmapFunctionC =
+    Ptr Memory ->
+    IO ()
+
+foreign import ccall "wrapper"
+    mkMemoryUnmapFunction :: MemoryUnmapFunctionC -> IO (FunPtr MemoryUnmapFunctionC)
+
+type MemoryUnmapFunction =
+    Memory ->
+    IO ()
+
+noMemoryUnmapFunction :: Maybe MemoryUnmapFunction
+noMemoryUnmapFunction = Nothing
+
+memoryUnmapFunctionWrapper ::
+    Maybe (Ptr (FunPtr (MemoryUnmapFunctionC))) ->
+    MemoryUnmapFunction ->
+    Ptr Memory ->
+    IO ()
+memoryUnmapFunctionWrapper funptrptr _cb mem = do
+    mem' <- (newBoxed Memory) mem
+    _cb  mem'
+    maybeReleaseFunPtr funptrptr
+
+-- callback MemoryUnmapFullFunction
+memoryUnmapFullFunctionClosure :: MemoryUnmapFullFunction -> IO Closure
+memoryUnmapFullFunctionClosure cb = newCClosure =<< mkMemoryUnmapFullFunction wrapped
+    where wrapped = memoryUnmapFullFunctionWrapper Nothing cb
+
+type MemoryUnmapFullFunctionC =
+    Ptr Memory ->
+    Ptr MapInfo ->
+    IO ()
+
+foreign import ccall "wrapper"
+    mkMemoryUnmapFullFunction :: MemoryUnmapFullFunctionC -> IO (FunPtr MemoryUnmapFullFunctionC)
+
+type MemoryUnmapFullFunction =
+    Memory ->
+    MapInfo ->
+    IO ()
+
+noMemoryUnmapFullFunction :: Maybe MemoryUnmapFullFunction
+noMemoryUnmapFullFunction = Nothing
+
+memoryUnmapFullFunctionWrapper ::
+    Maybe (Ptr (FunPtr (MemoryUnmapFullFunctionC))) ->
+    MemoryUnmapFullFunction ->
+    Ptr Memory ->
+    Ptr MapInfo ->
+    IO ()
+memoryUnmapFullFunctionWrapper funptrptr _cb mem info = do
+    mem' <- (newBoxed Memory) mem
+    info' <- (newPtr 104 MapInfo) info
+    _cb  mem' info'
+    maybeReleaseFunPtr funptrptr
+
+-- callback MemoryShareFunction
+memoryShareFunctionClosure :: MemoryShareFunction -> IO Closure
+memoryShareFunctionClosure cb = newCClosure =<< mkMemoryShareFunction wrapped
+    where wrapped = memoryShareFunctionWrapper Nothing cb
+
+type MemoryShareFunctionC =
+    Ptr Memory ->
+    Int64 ->
+    Int64 ->
+    IO (Ptr Memory)
+
+foreign import ccall "wrapper"
+    mkMemoryShareFunction :: MemoryShareFunctionC -> IO (FunPtr MemoryShareFunctionC)
+
+type MemoryShareFunction =
+    Memory ->
+    Int64 ->
+    Int64 ->
+    IO Memory
+
+noMemoryShareFunction :: Maybe MemoryShareFunction
+noMemoryShareFunction = Nothing
+
+memoryShareFunctionWrapper ::
+    Maybe (Ptr (FunPtr (MemoryShareFunctionC))) ->
+    MemoryShareFunction ->
+    Ptr Memory ->
+    Int64 ->
+    Int64 ->
+    IO (Ptr Memory)
+memoryShareFunctionWrapper funptrptr _cb mem offset size = do
+    mem' <- (newBoxed Memory) mem
+    result <- _cb  mem' offset size
+    maybeReleaseFunPtr funptrptr
+    result' <- copyBoxed result
+    return result'
+
+-- callback MemoryIsSpanFunction
+memoryIsSpanFunctionClosure :: MemoryIsSpanFunction -> IO Closure
+memoryIsSpanFunctionClosure cb = newCClosure =<< mkMemoryIsSpanFunction wrapped
+    where wrapped = memoryIsSpanFunctionWrapper Nothing cb
+
+type MemoryIsSpanFunctionC =
+    Ptr Memory ->
+    Ptr Memory ->
+    Word64 ->
+    IO CInt
+
+foreign import ccall "wrapper"
+    mkMemoryIsSpanFunction :: MemoryIsSpanFunctionC -> IO (FunPtr MemoryIsSpanFunctionC)
+
+type MemoryIsSpanFunction =
+    Memory ->
+    Memory ->
+    Word64 ->
+    IO Bool
+
+noMemoryIsSpanFunction :: Maybe MemoryIsSpanFunction
+noMemoryIsSpanFunction = Nothing
+
+memoryIsSpanFunctionWrapper ::
+    Maybe (Ptr (FunPtr (MemoryIsSpanFunctionC))) ->
+    MemoryIsSpanFunction ->
+    Ptr Memory ->
+    Ptr Memory ->
+    Word64 ->
+    IO CInt
+memoryIsSpanFunctionWrapper funptrptr _cb mem1 mem2 offset = do
+    mem1' <- (newBoxed Memory) mem1
+    mem2' <- (newBoxed Memory) mem2
+    result <- _cb  mem1' mem2' offset
+    maybeReleaseFunPtr funptrptr
+    let result' = (fromIntegral . fromEnum) result
+    return result'
+
+-- callback MemoryCopyFunction
+memoryCopyFunctionClosure :: MemoryCopyFunction -> IO Closure
+memoryCopyFunctionClosure cb = newCClosure =<< mkMemoryCopyFunction wrapped
+    where wrapped = memoryCopyFunctionWrapper Nothing cb
+
+type MemoryCopyFunctionC =
+    Ptr Memory ->
+    Int64 ->
+    Int64 ->
+    IO (Ptr Memory)
+
+foreign import ccall "wrapper"
+    mkMemoryCopyFunction :: MemoryCopyFunctionC -> IO (FunPtr MemoryCopyFunctionC)
+
+type MemoryCopyFunction =
+    Memory ->
+    Int64 ->
+    Int64 ->
+    IO Memory
+
+noMemoryCopyFunction :: Maybe MemoryCopyFunction
+noMemoryCopyFunction = Nothing
+
+memoryCopyFunctionWrapper ::
+    Maybe (Ptr (FunPtr (MemoryCopyFunctionC))) ->
+    MemoryCopyFunction ->
+    Ptr Memory ->
+    Int64 ->
+    Int64 ->
+    IO (Ptr Memory)
+memoryCopyFunctionWrapper funptrptr _cb mem offset size = do
+    mem' <- (newBoxed Memory) mem
+    result <- _cb  mem' offset size
+    maybeReleaseFunPtr funptrptr
+    result' <- copyBoxed result
+    return result'
+
+-- callback LogFunction
+logFunctionClosure :: LogFunction -> IO Closure
+logFunctionClosure cb = newCClosure =<< mkLogFunction wrapped
+    where wrapped = logFunctionWrapper Nothing cb
+
+type LogFunctionC =
+    Ptr DebugCategory ->
+    CUInt ->
+    CString ->
+    CString ->
+    Int32 ->
+    Ptr GObject.Object ->
+    Ptr DebugMessage ->
+    Ptr () ->
+    IO ()
+
+foreign import ccall "wrapper"
+    mkLogFunction :: LogFunctionC -> IO (FunPtr LogFunctionC)
+
+type LogFunction =
+    DebugCategory ->
+    DebugLevel ->
+    T.Text ->
+    T.Text ->
+    Int32 ->
+    GObject.Object ->
+    DebugMessage ->
+    IO ()
+
+noLogFunction :: Maybe LogFunction
+noLogFunction = Nothing
+
+logFunctionWrapper ::
+    Maybe (Ptr (FunPtr (LogFunctionC))) ->
+    LogFunction ->
+    Ptr DebugCategory ->
+    CUInt ->
+    CString ->
+    CString ->
+    Int32 ->
+    Ptr GObject.Object ->
+    Ptr DebugMessage ->
+    Ptr () ->
+    IO ()
+logFunctionWrapper funptrptr _cb category level file function line object message _ = do
+    category' <- (newPtr 24 DebugCategory) category
+    let level' = (toEnum . fromIntegral) level
+    file' <- cstringToText file
+    function' <- cstringToText function
+    object' <- (newObject GObject.Object) object
+    -- XXX Wrapping a foreign struct/union with no known destructor, leak?
+    message' <- (\x -> DebugMessage <$> newForeignPtr_ x) message
+    _cb  category' level' file' function' line object' message'
+    maybeReleaseFunPtr funptrptr
+
+-- callback IteratorResyncFunction
+iteratorResyncFunctionClosure :: IteratorResyncFunction -> IO Closure
+iteratorResyncFunctionClosure cb = newCClosure =<< mkIteratorResyncFunction wrapped
+    where wrapped = iteratorResyncFunctionWrapper Nothing cb
+
+type IteratorResyncFunctionC =
+    Ptr Iterator ->
+    IO ()
+
+foreign import ccall "wrapper"
+    mkIteratorResyncFunction :: IteratorResyncFunctionC -> IO (FunPtr IteratorResyncFunctionC)
+
+type IteratorResyncFunction =
+    Iterator ->
+    IO ()
+
+noIteratorResyncFunction :: Maybe IteratorResyncFunction
+noIteratorResyncFunction = Nothing
+
+iteratorResyncFunctionWrapper ::
+    Maybe (Ptr (FunPtr (IteratorResyncFunctionC))) ->
+    IteratorResyncFunction ->
+    Ptr Iterator ->
+    IO ()
+iteratorResyncFunctionWrapper funptrptr _cb it = do
+    it' <- (newBoxed Iterator) it
+    _cb  it'
+    maybeReleaseFunPtr funptrptr
+
+-- callback IteratorNextFunction
+iteratorNextFunctionClosure :: IteratorNextFunction -> IO Closure
+iteratorNextFunctionClosure cb = newCClosure =<< mkIteratorNextFunction wrapped
+    where wrapped = iteratorNextFunctionWrapper Nothing cb
+
+type IteratorNextFunctionC =
+    Ptr Iterator ->
+    Ptr GValue ->
+    IO CUInt
+
+foreign import ccall "wrapper"
+    mkIteratorNextFunction :: IteratorNextFunctionC -> IO (FunPtr IteratorNextFunctionC)
+
+type IteratorNextFunction =
+    Iterator ->
+    GValue ->
+    IO IteratorResult
+
+noIteratorNextFunction :: Maybe IteratorNextFunction
+noIteratorNextFunction = Nothing
+
+iteratorNextFunctionWrapper ::
+    Maybe (Ptr (FunPtr (IteratorNextFunctionC))) ->
+    IteratorNextFunction ->
+    Ptr Iterator ->
+    Ptr GValue ->
+    IO CUInt
+iteratorNextFunctionWrapper funptrptr _cb it result_ = do
+    it' <- (newBoxed Iterator) it
+    result_' <- (newBoxed GValue) result_
+    result <- _cb  it' result_'
+    maybeReleaseFunPtr funptrptr
+    let result' = (fromIntegral . fromEnum) result
+    return result'
+
+-- callback IteratorItemFunction
+iteratorItemFunctionClosure :: IteratorItemFunction -> IO Closure
+iteratorItemFunctionClosure cb = newCClosure =<< mkIteratorItemFunction wrapped
+    where wrapped = iteratorItemFunctionWrapper Nothing cb
+
+type IteratorItemFunctionC =
+    Ptr Iterator ->
+    Ptr GValue ->
+    IO CUInt
+
+foreign import ccall "wrapper"
+    mkIteratorItemFunction :: IteratorItemFunctionC -> IO (FunPtr IteratorItemFunctionC)
+
+type IteratorItemFunction =
+    Iterator ->
+    GValue ->
+    IO IteratorItem
+
+noIteratorItemFunction :: Maybe IteratorItemFunction
+noIteratorItemFunction = Nothing
+
+iteratorItemFunctionWrapper ::
+    Maybe (Ptr (FunPtr (IteratorItemFunctionC))) ->
+    IteratorItemFunction ->
+    Ptr Iterator ->
+    Ptr GValue ->
+    IO CUInt
+iteratorItemFunctionWrapper funptrptr _cb it item = do
+    it' <- (newBoxed Iterator) it
+    item' <- (newBoxed GValue) item
+    result <- _cb  it' item'
+    maybeReleaseFunPtr funptrptr
+    let result' = (fromIntegral . fromEnum) result
+    return result'
+
+-- callback IteratorFreeFunction
+iteratorFreeFunctionClosure :: IteratorFreeFunction -> IO Closure
+iteratorFreeFunctionClosure cb = newCClosure =<< mkIteratorFreeFunction wrapped
+    where wrapped = iteratorFreeFunctionWrapper Nothing cb
+
+type IteratorFreeFunctionC =
+    Ptr Iterator ->
+    IO ()
+
+foreign import ccall "wrapper"
+    mkIteratorFreeFunction :: IteratorFreeFunctionC -> IO (FunPtr IteratorFreeFunctionC)
+
+type IteratorFreeFunction =
+    Iterator ->
+    IO ()
+
+noIteratorFreeFunction :: Maybe IteratorFreeFunction
+noIteratorFreeFunction = Nothing
+
+iteratorFreeFunctionWrapper ::
+    Maybe (Ptr (FunPtr (IteratorFreeFunctionC))) ->
+    IteratorFreeFunction ->
+    Ptr Iterator ->
+    IO ()
+iteratorFreeFunctionWrapper funptrptr _cb it = do
+    it' <- (newBoxed Iterator) it
+    _cb  it'
+    maybeReleaseFunPtr funptrptr
+
+-- callback IteratorForeachFunction
+iteratorForeachFunctionClosure :: IteratorForeachFunction -> IO Closure
+iteratorForeachFunctionClosure cb = newCClosure =<< mkIteratorForeachFunction wrapped
+    where wrapped = iteratorForeachFunctionWrapper Nothing cb
+
+type IteratorForeachFunctionC =
+    Ptr GValue ->
+    Ptr () ->
+    IO ()
+
+foreign import ccall "wrapper"
+    mkIteratorForeachFunction :: IteratorForeachFunctionC -> IO (FunPtr IteratorForeachFunctionC)
+
+type IteratorForeachFunction =
+    GValue ->
+    IO ()
+
+noIteratorForeachFunction :: Maybe IteratorForeachFunction
+noIteratorForeachFunction = Nothing
+
+iteratorForeachFunctionWrapper ::
+    Maybe (Ptr (FunPtr (IteratorForeachFunctionC))) ->
+    IteratorForeachFunction ->
+    Ptr GValue ->
+    Ptr () ->
+    IO ()
+iteratorForeachFunctionWrapper funptrptr _cb item _ = do
+    item' <- (newBoxed GValue) item
+    _cb  item'
+    maybeReleaseFunPtr funptrptr
+
+-- callback IteratorFoldFunction
+iteratorFoldFunctionClosure :: IteratorFoldFunction -> IO Closure
+iteratorFoldFunctionClosure cb = newCClosure =<< mkIteratorFoldFunction wrapped
+    where wrapped = iteratorFoldFunctionWrapper Nothing cb
+
+type IteratorFoldFunctionC =
+    Ptr GValue ->
+    Ptr GValue ->
+    Ptr () ->
+    IO CInt
+
+foreign import ccall "wrapper"
+    mkIteratorFoldFunction :: IteratorFoldFunctionC -> IO (FunPtr IteratorFoldFunctionC)
+
+type IteratorFoldFunction =
+    GValue ->
+    GValue ->
+    IO Bool
+
+noIteratorFoldFunction :: Maybe IteratorFoldFunction
+noIteratorFoldFunction = Nothing
+
+iteratorFoldFunctionWrapper ::
+    Maybe (Ptr (FunPtr (IteratorFoldFunctionC))) ->
+    IteratorFoldFunction ->
+    Ptr GValue ->
+    Ptr GValue ->
+    Ptr () ->
+    IO CInt
+iteratorFoldFunctionWrapper funptrptr _cb item ret _ = do
+    item' <- (newBoxed GValue) item
+    ret' <- (newBoxed GValue) ret
+    result <- _cb  item' ret'
+    maybeReleaseFunPtr funptrptr
+    let result' = (fromIntegral . fromEnum) result
+    return result'
+
+-- callback IteratorCopyFunction
+iteratorCopyFunctionClosure :: IteratorCopyFunction -> IO Closure
+iteratorCopyFunctionClosure cb = newCClosure =<< mkIteratorCopyFunction wrapped
+    where wrapped = iteratorCopyFunctionWrapper Nothing cb
+
+type IteratorCopyFunctionC =
+    Ptr Iterator ->
+    Ptr Iterator ->
+    IO ()
+
+foreign import ccall "wrapper"
+    mkIteratorCopyFunction :: IteratorCopyFunctionC -> IO (FunPtr IteratorCopyFunctionC)
+
+type IteratorCopyFunction =
+    Iterator ->
+    Iterator ->
+    IO ()
+
+noIteratorCopyFunction :: Maybe IteratorCopyFunction
+noIteratorCopyFunction = Nothing
+
+iteratorCopyFunctionWrapper ::
+    Maybe (Ptr (FunPtr (IteratorCopyFunctionC))) ->
+    IteratorCopyFunction ->
+    Ptr Iterator ->
+    Ptr Iterator ->
+    IO ()
+iteratorCopyFunctionWrapper funptrptr _cb it copy = do
+    it' <- (newBoxed Iterator) it
+    copy' <- (newBoxed Iterator) copy
+    _cb  it' copy'
+    maybeReleaseFunPtr funptrptr
+
+-- callback DebugFuncPtr
+debugFuncPtrClosure :: DebugFuncPtr -> IO Closure
+debugFuncPtrClosure cb = newCClosure =<< mkDebugFuncPtr wrapped
+    where wrapped = debugFuncPtrWrapper Nothing cb
+
+type DebugFuncPtrC =
+    IO ()
+
+foreign import ccall "wrapper"
+    mkDebugFuncPtr :: DebugFuncPtrC -> IO (FunPtr DebugFuncPtrC)
+
+type DebugFuncPtr =
+    IO ()
+
+noDebugFuncPtr :: Maybe DebugFuncPtr
+noDebugFuncPtr = Nothing
+
+debugFuncPtrWrapper ::
+    Maybe (Ptr (FunPtr (DebugFuncPtrC))) ->
+    DebugFuncPtr ->
+    IO ()
+debugFuncPtrWrapper funptrptr _cb = do
+    _cb 
+    maybeReleaseFunPtr funptrptr
+
+-- callback ControlSourceGetValueArray
+controlSourceGetValueArrayClosure :: ControlSourceGetValueArray -> IO Closure
+controlSourceGetValueArrayClosure cb = newCClosure =<< mkControlSourceGetValueArray wrapped
+    where wrapped = controlSourceGetValueArrayWrapper Nothing cb
+
+type ControlSourceGetValueArrayC =
+    Ptr ControlSource ->
+    Word64 ->
+    Word64 ->
+    Word32 ->
+    CDouble ->
+    IO CInt
+
+foreign import ccall "wrapper"
+    mkControlSourceGetValueArray :: ControlSourceGetValueArrayC -> IO (FunPtr ControlSourceGetValueArrayC)
+
+type ControlSourceGetValueArray =
+    ControlSource ->
+    Word64 ->
+    Word64 ->
+    Word32 ->
+    Double ->
+    IO Bool
+
+noControlSourceGetValueArray :: Maybe ControlSourceGetValueArray
+noControlSourceGetValueArray = Nothing
+
+controlSourceGetValueArrayWrapper ::
+    Maybe (Ptr (FunPtr (ControlSourceGetValueArrayC))) ->
+    ControlSourceGetValueArray ->
+    Ptr ControlSource ->
+    Word64 ->
+    Word64 ->
+    Word32 ->
+    CDouble ->
+    IO CInt
+controlSourceGetValueArrayWrapper funptrptr _cb self timestamp interval nValues values = do
+    self' <- (newObject ControlSource) self
+    let values' = realToFrac values
+    result <- _cb  self' timestamp interval nValues values'
+    maybeReleaseFunPtr funptrptr
+    let result' = (fromIntegral . fromEnum) result
+    return result'
+
+-- callback ControlSourceGetValue
+controlSourceGetValueClosure :: ControlSourceGetValue -> IO Closure
+controlSourceGetValueClosure cb = newCClosure =<< mkControlSourceGetValue wrapped
+    where wrapped = controlSourceGetValueWrapper Nothing cb
+
+type ControlSourceGetValueC =
+    Ptr ControlSource ->
+    Word64 ->
+    CDouble ->
+    IO CInt
+
+foreign import ccall "wrapper"
+    mkControlSourceGetValue :: ControlSourceGetValueC -> IO (FunPtr ControlSourceGetValueC)
+
+type ControlSourceGetValue =
+    ControlSource ->
+    Word64 ->
+    Double ->
+    IO Bool
+
+noControlSourceGetValue :: Maybe ControlSourceGetValue
+noControlSourceGetValue = Nothing
+
+controlSourceGetValueWrapper ::
+    Maybe (Ptr (FunPtr (ControlSourceGetValueC))) ->
+    ControlSourceGetValue ->
+    Ptr ControlSource ->
+    Word64 ->
+    CDouble ->
+    IO CInt
+controlSourceGetValueWrapper funptrptr _cb self timestamp value = do
+    self' <- (newObject ControlSource) self
+    let value' = realToFrac value
+    result <- _cb  self' timestamp value'
+    maybeReleaseFunPtr funptrptr
+    let result' = (fromIntegral . fromEnum) result
+    return result'
+
+-- callback ControlBindingConvert
+controlBindingConvertClosure :: ControlBindingConvert -> IO Closure
+controlBindingConvertClosure cb = newCClosure =<< mkControlBindingConvert wrapped
+    where wrapped = controlBindingConvertWrapper Nothing cb
+
+type ControlBindingConvertC =
+    Ptr ControlBinding ->
+    CDouble ->
+    Ptr GValue ->
+    IO ()
+
+foreign import ccall "wrapper"
+    mkControlBindingConvert :: ControlBindingConvertC -> IO (FunPtr ControlBindingConvertC)
+
+type ControlBindingConvert =
+    ControlBinding ->
+    Double ->
+    GValue ->
+    IO ()
+
+noControlBindingConvert :: Maybe ControlBindingConvert
+noControlBindingConvert = Nothing
+
+controlBindingConvertWrapper ::
+    Maybe (Ptr (FunPtr (ControlBindingConvertC))) ->
+    ControlBindingConvert ->
+    Ptr ControlBinding ->
+    CDouble ->
+    Ptr GValue ->
+    IO ()
+controlBindingConvertWrapper funptrptr _cb binding srcValue destValue = do
+    binding' <- (newObject ControlBinding) binding
+    let srcValue' = realToFrac srcValue
+    destValue' <- (newBoxed GValue) destValue
+    _cb  binding' srcValue' destValue'
+    maybeReleaseFunPtr funptrptr
+
+-- callback ClockCallback
+clockCallbackClosure :: ClockCallback -> IO Closure
+clockCallbackClosure cb = newCClosure =<< mkClockCallback wrapped
+    where wrapped = clockCallbackWrapper Nothing cb
+
+type ClockCallbackC =
+    Ptr Clock ->
+    Word64 ->
+    Ptr () ->
+    Ptr () ->
+    IO CInt
+
+foreign import ccall "wrapper"
+    mkClockCallback :: ClockCallbackC -> IO (FunPtr ClockCallbackC)
+
+type ClockCallback =
+    Clock ->
+    Word64 ->
+    Ptr () ->
+    IO Bool
+
+noClockCallback :: Maybe ClockCallback
+noClockCallback = Nothing
+
+clockCallbackWrapper ::
+    Maybe (Ptr (FunPtr (ClockCallbackC))) ->
+    ClockCallback ->
+    Ptr Clock ->
+    Word64 ->
+    Ptr () ->
+    Ptr () ->
+    IO CInt
+clockCallbackWrapper funptrptr _cb clock time id _ = do
+    clock' <- (newObject Clock) clock
+    result <- _cb  clock' time id
+    maybeReleaseFunPtr funptrptr
+    let result' = (fromIntegral . fromEnum) result
+    return result'
+
+-- callback CapsMapFunc
+capsMapFuncClosure :: CapsMapFunc -> IO Closure
+capsMapFuncClosure cb = newCClosure =<< mkCapsMapFunc wrapped
+    where wrapped = capsMapFuncWrapper Nothing cb
+
+type CapsMapFuncC =
+    Ptr CapsFeatures ->
+    Ptr Structure ->
+    Ptr () ->
+    IO CInt
+
+foreign import ccall "wrapper"
+    mkCapsMapFunc :: CapsMapFuncC -> IO (FunPtr CapsMapFuncC)
+
+type CapsMapFunc =
+    CapsFeatures ->
+    Structure ->
+    IO Bool
+
+noCapsMapFunc :: Maybe CapsMapFunc
+noCapsMapFunc = Nothing
+
+capsMapFuncWrapper ::
+    Maybe (Ptr (FunPtr (CapsMapFuncC))) ->
+    CapsMapFunc ->
+    Ptr CapsFeatures ->
+    Ptr Structure ->
+    Ptr () ->
+    IO CInt
+capsMapFuncWrapper funptrptr _cb features structure _ = do
+    features' <- (newBoxed CapsFeatures) features
+    structure' <- (newBoxed Structure) structure
+    result <- _cb  features' structure'
+    maybeReleaseFunPtr funptrptr
+    let result' = (fromIntegral . fromEnum) result
+    return result'
+
+-- callback CapsForeachFunc
+capsForeachFuncClosure :: CapsForeachFunc -> IO Closure
+capsForeachFuncClosure cb = newCClosure =<< mkCapsForeachFunc wrapped
+    where wrapped = capsForeachFuncWrapper Nothing cb
+
+type CapsForeachFuncC =
+    Ptr CapsFeatures ->
+    Ptr Structure ->
+    Ptr () ->
+    IO CInt
+
+foreign import ccall "wrapper"
+    mkCapsForeachFunc :: CapsForeachFuncC -> IO (FunPtr CapsForeachFuncC)
+
+type CapsForeachFunc =
+    CapsFeatures ->
+    Structure ->
+    IO Bool
+
+noCapsForeachFunc :: Maybe CapsForeachFunc
+noCapsForeachFunc = Nothing
+
+capsForeachFuncWrapper ::
+    Maybe (Ptr (FunPtr (CapsForeachFuncC))) ->
+    CapsForeachFunc ->
+    Ptr CapsFeatures ->
+    Ptr Structure ->
+    Ptr () ->
+    IO CInt
+capsForeachFuncWrapper funptrptr _cb features structure _ = do
+    features' <- (newBoxed CapsFeatures) features
+    structure' <- (newBoxed Structure) structure
+    result <- _cb  features' structure'
+    maybeReleaseFunPtr funptrptr
+    let result' = (fromIntegral . fromEnum) result
+    return result'
+
+-- callback CapsFilterMapFunc
+capsFilterMapFuncClosure :: CapsFilterMapFunc -> IO Closure
+capsFilterMapFuncClosure cb = newCClosure =<< mkCapsFilterMapFunc wrapped
+    where wrapped = capsFilterMapFuncWrapper Nothing cb
+
+type CapsFilterMapFuncC =
+    Ptr CapsFeatures ->
+    Ptr Structure ->
+    Ptr () ->
+    IO CInt
+
+foreign import ccall "wrapper"
+    mkCapsFilterMapFunc :: CapsFilterMapFuncC -> IO (FunPtr CapsFilterMapFuncC)
+
+type CapsFilterMapFunc =
+    CapsFeatures ->
+    Structure ->
+    IO Bool
+
+noCapsFilterMapFunc :: Maybe CapsFilterMapFunc
+noCapsFilterMapFunc = Nothing
+
+capsFilterMapFuncWrapper ::
+    Maybe (Ptr (FunPtr (CapsFilterMapFuncC))) ->
+    CapsFilterMapFunc ->
+    Ptr CapsFeatures ->
+    Ptr Structure ->
+    Ptr () ->
+    IO CInt
+capsFilterMapFuncWrapper funptrptr _cb features structure _ = do
+    features' <- (newBoxed CapsFeatures) features
+    structure' <- (newBoxed Structure) structure
+    result <- _cb  features' structure'
+    maybeReleaseFunPtr funptrptr
+    let result' = (fromIntegral . fromEnum) result
+    return result'
+
+-- callback BusSyncHandler
+busSyncHandlerClosure :: BusSyncHandler -> IO Closure
+busSyncHandlerClosure cb = newCClosure =<< mkBusSyncHandler wrapped
+    where wrapped = busSyncHandlerWrapper Nothing cb
+
+type BusSyncHandlerC =
+    Ptr Bus ->
+    Ptr Message ->
+    Ptr () ->
+    IO CUInt
+
+foreign import ccall "wrapper"
+    mkBusSyncHandler :: BusSyncHandlerC -> IO (FunPtr BusSyncHandlerC)
+
+type BusSyncHandler =
+    Bus ->
+    Message ->
+    IO BusSyncReply
+
+noBusSyncHandler :: Maybe BusSyncHandler
+noBusSyncHandler = Nothing
+
+busSyncHandlerWrapper ::
+    Maybe (Ptr (FunPtr (BusSyncHandlerC))) ->
+    BusSyncHandler ->
+    Ptr Bus ->
+    Ptr Message ->
+    Ptr () ->
+    IO CUInt
+busSyncHandlerWrapper funptrptr _cb bus message _ = do
+    bus' <- (newObject Bus) bus
+    message' <- (newBoxed Message) message
+    result <- _cb  bus' message'
+    maybeReleaseFunPtr funptrptr
+    let result' = (fromIntegral . fromEnum) result
+    return result'
+
+-- callback BusFunc
+busFuncClosure :: BusFunc -> IO Closure
+busFuncClosure cb = newCClosure =<< mkBusFunc wrapped
+    where wrapped = busFuncWrapper Nothing cb
+
+type BusFuncC =
+    Ptr Bus ->
+    Ptr Message ->
+    Ptr () ->
+    IO CInt
+
+foreign import ccall "wrapper"
+    mkBusFunc :: BusFuncC -> IO (FunPtr BusFuncC)
+
+type BusFunc =
+    Bus ->
+    Message ->
+    IO Bool
+
+noBusFunc :: Maybe BusFunc
+noBusFunc = Nothing
+
+busFuncWrapper ::
+    Maybe (Ptr (FunPtr (BusFuncC))) ->
+    BusFunc ->
+    Ptr Bus ->
+    Ptr Message ->
+    Ptr () ->
+    IO CInt
+busFuncWrapper funptrptr _cb bus message _ = do
+    bus' <- (newObject Bus) bus
+    message' <- (newBoxed Message) message
+    result <- _cb  bus' message'
+    maybeReleaseFunPtr funptrptr
+    let result' = (fromIntegral . fromEnum) result
+    return result'
+
+-- callback BufferListFunc
+bufferListFuncClosure :: BufferListFunc -> IO Closure
+bufferListFuncClosure cb = newCClosure =<< mkBufferListFunc wrapped
+    where wrapped = bufferListFuncWrapper Nothing cb
+
+type BufferListFuncC =
+    Ptr (Ptr Buffer) ->
+    Word32 ->
+    Ptr () ->
+    IO CInt
+
+foreign import ccall "wrapper"
+    mkBufferListFunc :: BufferListFuncC -> IO (FunPtr BufferListFuncC)
+
+type BufferListFunc =
+    Word32 ->
+    IO (Bool,(Maybe Buffer))
+
+noBufferListFunc :: Maybe BufferListFunc
+noBufferListFunc = Nothing
+
+bufferListFuncWrapper ::
+    Maybe (Ptr (FunPtr (BufferListFuncC))) ->
+    BufferListFunc ->
+    Ptr (Ptr Buffer) ->
+    Word32 ->
+    Ptr () ->
+    IO CInt
+bufferListFuncWrapper funptrptr _cb buffer idx _ = do
+    (result, outbuffer) <- _cb  idx
+    outbuffer' <- case outbuffer of
+        Nothing -> return nullPtr
+        Just outbuffer' -> do
+            outbuffer'' <- copyBoxed outbuffer'
+            return outbuffer''
+    poke buffer outbuffer'
+    maybeReleaseFunPtr funptrptr
+    let result' = (fromIntegral . fromEnum) result
+    return result'
+
+-- callback BufferForeachMetaFunc
+bufferForeachMetaFuncClosure :: BufferForeachMetaFunc -> IO Closure
+bufferForeachMetaFuncClosure cb = newCClosure =<< mkBufferForeachMetaFunc wrapped
+    where wrapped = bufferForeachMetaFuncWrapper Nothing cb
+
+type BufferForeachMetaFuncC =
+    Ptr Buffer ->
+    Ptr (Ptr Meta) ->
+    Ptr () ->
+    IO CInt
+
+foreign import ccall "wrapper"
+    mkBufferForeachMetaFunc :: BufferForeachMetaFuncC -> IO (FunPtr BufferForeachMetaFuncC)
+
+type BufferForeachMetaFunc =
+    Buffer ->
+    IO (Bool,(Maybe Meta))
+
+noBufferForeachMetaFunc :: Maybe BufferForeachMetaFunc
+noBufferForeachMetaFunc = Nothing
+
+bufferForeachMetaFuncWrapper ::
+    Maybe (Ptr (FunPtr (BufferForeachMetaFuncC))) ->
+    BufferForeachMetaFunc ->
+    Ptr Buffer ->
+    Ptr (Ptr Meta) ->
+    Ptr () ->
+    IO CInt
+bufferForeachMetaFuncWrapper funptrptr _cb buffer meta _ = do
+    buffer' <- (newBoxed Buffer) buffer
+    (result, outmeta) <- _cb  buffer'
+    outmeta' <- case outmeta of
+        Nothing -> return nullPtr
+        Just outmeta' -> do
+            let outmeta'' = unsafeManagedPtrGetPtr outmeta'
+            return outmeta''
+    poke meta outmeta'
+    maybeReleaseFunPtr funptrptr
+    let result' = (fromIntegral . fromEnum) result
+    return result'
+
+
diff --git a/GI/Gst/Constants.hs b/GI/Gst/Constants.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Constants.hs
@@ -0,0 +1,734 @@
+{-# LANGUAGE PatternSynonyms, ScopedTypeVariables, ViewPatterns #-}
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+-}
+
+module GI.Gst.Constants
+    ( 
+    pattern VERSION_NANO                    ,
+    pattern VERSION_MINOR                   ,
+    pattern VERSION_MICRO                   ,
+    pattern VERSION_MAJOR                   ,
+    pattern VALUE_UNORDERED                 ,
+    pattern VALUE_LESS_THAN                 ,
+    pattern VALUE_GREATER_THAN              ,
+    pattern VALUE_EQUAL                     ,
+    pattern USECOND                         ,
+    pattern URI_NO_PORT                     ,
+    pattern TOC_REPEAT_COUNT_INFINITE       ,
+    pattern TIME_FORMAT                     ,
+    pattern TAG_VIDEO_CODEC                 ,
+    pattern TAG_VERSION                     ,
+    pattern TAG_USER_RATING                 ,
+    pattern TAG_TRACK_PEAK                  ,
+    pattern TAG_TRACK_NUMBER                ,
+    pattern TAG_TRACK_GAIN                  ,
+    pattern TAG_TRACK_COUNT                 ,
+    pattern TAG_TITLE_SORTNAME              ,
+    pattern TAG_TITLE                       ,
+    pattern TAG_SUBTITLE_CODEC              ,
+    pattern TAG_SHOW_SORTNAME               ,
+    pattern TAG_SHOW_SEASON_NUMBER          ,
+    pattern TAG_SHOW_NAME                   ,
+    pattern TAG_SHOW_EPISODE_NUMBER         ,
+    pattern TAG_SERIAL                      ,
+    pattern TAG_REFERENCE_LEVEL             ,
+    pattern TAG_PUBLISHER                   ,
+    pattern TAG_PREVIEW_IMAGE               ,
+    pattern TAG_PERFORMER                   ,
+    pattern TAG_ORGANIZATION                ,
+    pattern TAG_NOMINAL_BITRATE             ,
+    pattern TAG_MINIMUM_BITRATE             ,
+    pattern TAG_MIDI_BASE_NOTE              ,
+    pattern TAG_MAXIMUM_BITRATE             ,
+    pattern TAG_LYRICS                      ,
+    pattern TAG_LOCATION                    ,
+    pattern TAG_LICENSE_URI                 ,
+    pattern TAG_LICENSE                     ,
+    pattern TAG_LANGUAGE_NAME               ,
+    pattern TAG_LANGUAGE_CODE               ,
+    pattern TAG_KEYWORDS                    ,
+    pattern TAG_ISRC                        ,
+    pattern TAG_INTERPRETED_BY              ,
+    pattern TAG_IMAGE_ORIENTATION           ,
+    pattern TAG_IMAGE                       ,
+    pattern TAG_HOMEPAGE                    ,
+    pattern TAG_GROUPING                    ,
+    pattern TAG_GEO_LOCATION_SUBLOCATION    ,
+    pattern TAG_GEO_LOCATION_NAME           ,
+    pattern TAG_GEO_LOCATION_MOVEMENT_SPEED ,
+    pattern TAG_GEO_LOCATION_MOVEMENT_DIRECTION,
+    pattern TAG_GEO_LOCATION_LONGITUDE      ,
+    pattern TAG_GEO_LOCATION_LATITUDE       ,
+    pattern TAG_GEO_LOCATION_HORIZONTAL_ERROR,
+    pattern TAG_GEO_LOCATION_ELEVATION      ,
+    pattern TAG_GEO_LOCATION_COUNTRY        ,
+    pattern TAG_GEO_LOCATION_CITY           ,
+    pattern TAG_GEO_LOCATION_CAPTURE_DIRECTION,
+    pattern TAG_GENRE                       ,
+    pattern TAG_EXTENDED_COMMENT            ,
+    pattern TAG_ENCODER_VERSION             ,
+    pattern TAG_ENCODER                     ,
+    pattern TAG_ENCODED_BY                  ,
+    pattern TAG_DURATION                    ,
+    pattern TAG_DEVICE_MODEL                ,
+    pattern TAG_DEVICE_MANUFACTURER         ,
+    pattern TAG_DESCRIPTION                 ,
+    pattern TAG_DATE_TIME                   ,
+    pattern TAG_DATE                        ,
+    pattern TAG_COPYRIGHT_URI               ,
+    pattern TAG_COPYRIGHT                   ,
+    pattern TAG_CONTAINER_FORMAT            ,
+    pattern TAG_CONTACT                     ,
+    pattern TAG_COMPOSER_SORTNAME           ,
+    pattern TAG_COMPOSER                    ,
+    pattern TAG_COMMENT                     ,
+    pattern TAG_CODEC                       ,
+    pattern TAG_BITRATE                     ,
+    pattern TAG_BEATS_PER_MINUTE            ,
+    pattern TAG_AUDIO_CODEC                 ,
+    pattern TAG_ATTACHMENT                  ,
+    pattern TAG_ARTIST_SORTNAME             ,
+    pattern TAG_ARTIST                      ,
+    pattern TAG_APPLICATION_NAME            ,
+    pattern TAG_APPLICATION_DATA            ,
+    pattern TAG_ALBUM_VOLUME_NUMBER         ,
+    pattern TAG_ALBUM_VOLUME_COUNT          ,
+    pattern TAG_ALBUM_SORTNAME              ,
+    pattern TAG_ALBUM_PEAK                  ,
+    pattern TAG_ALBUM_GAIN                  ,
+    pattern TAG_ALBUM_ARTIST_SORTNAME       ,
+    pattern TAG_ALBUM_ARTIST                ,
+    pattern TAG_ALBUM                       ,
+    pattern STIME_FORMAT                    ,
+    pattern SEGMENT_FORMAT                  ,
+    pattern SECOND                          ,
+    pattern QUERY_TYPE_BOTH                 ,
+    pattern QUERY_NUM_SHIFT                 ,
+    pattern PTR_FORMAT                      ,
+    pattern PROTECTION_SYSTEM_ID_CAPS_FIELD ,
+    pattern PARAM_USER_SHIFT                ,
+    pattern PARAM_MUTABLE_READY             ,
+    pattern PARAM_MUTABLE_PLAYING           ,
+    pattern PARAM_MUTABLE_PAUSED            ,
+    pattern PARAM_CONTROLLABLE              ,
+    pattern NSECOND                         ,
+    pattern MSECOND                         ,
+    pattern META_TAG_MEMORY_STR             ,
+    pattern MAP_READWRITE                   ,
+    pattern LOCK_FLAG_READWRITE             ,
+    pattern LICENSE_UNKNOWN                 ,
+    pattern FOURCC_FORMAT                   ,
+    pattern FORMAT_PERCENT_SCALE            ,
+    pattern FORMAT_PERCENT_MAX              ,
+    pattern FLAG_SET_MASK_EXACT             ,
+    pattern EVENT_TYPE_BOTH                 ,
+    pattern EVENT_NUM_SHIFT                 ,
+    pattern ERROR_SYSTEM                    ,
+    pattern ELEMENT_METADATA_LONGNAME       ,
+    pattern ELEMENT_METADATA_KLASS          ,
+    pattern ELEMENT_METADATA_ICON_NAME      ,
+    pattern ELEMENT_METADATA_DOC_URI        ,
+    pattern ELEMENT_METADATA_DESCRIPTION    ,
+    pattern ELEMENT_METADATA_AUTHOR         ,
+    pattern ELEMENT_FACTORY_TYPE_VIDEO_ENCODER,
+    pattern ELEMENT_FACTORY_TYPE_SRC        ,
+    pattern ELEMENT_FACTORY_TYPE_SINK       ,
+    pattern ELEMENT_FACTORY_TYPE_PAYLOADER  ,
+    pattern ELEMENT_FACTORY_TYPE_PARSER     ,
+    pattern ELEMENT_FACTORY_TYPE_MUXER      ,
+    pattern ELEMENT_FACTORY_TYPE_MEDIA_VIDEO,
+    pattern ELEMENT_FACTORY_TYPE_MEDIA_SUBTITLE,
+    pattern ELEMENT_FACTORY_TYPE_MEDIA_METADATA,
+    pattern ELEMENT_FACTORY_TYPE_MEDIA_IMAGE,
+    pattern ELEMENT_FACTORY_TYPE_MEDIA_AUDIO,
+    pattern ELEMENT_FACTORY_TYPE_MEDIA_ANY  ,
+    pattern ELEMENT_FACTORY_TYPE_MAX_ELEMENTS,
+    pattern ELEMENT_FACTORY_TYPE_FORMATTER  ,
+    pattern ELEMENT_FACTORY_TYPE_ENCRYPTOR  ,
+    pattern ELEMENT_FACTORY_TYPE_ENCODER    ,
+    pattern ELEMENT_FACTORY_TYPE_DEPAYLOADER,
+    pattern ELEMENT_FACTORY_TYPE_DEMUXER    ,
+    pattern ELEMENT_FACTORY_TYPE_DECRYPTOR  ,
+    pattern ELEMENT_FACTORY_TYPE_DECODER    ,
+    pattern ELEMENT_FACTORY_TYPE_DECODABLE  ,
+    pattern ELEMENT_FACTORY_TYPE_AUDIO_ENCODER,
+    pattern ELEMENT_FACTORY_TYPE_AUDIOVIDEO_SINKS,
+    pattern ELEMENT_FACTORY_TYPE_ANY        ,
+    pattern ELEMENT_FACTORY_KLASS_SRC       ,
+    pattern ELEMENT_FACTORY_KLASS_SINK      ,
+    pattern ELEMENT_FACTORY_KLASS_PAYLOADER ,
+    pattern ELEMENT_FACTORY_KLASS_PARSER    ,
+    pattern ELEMENT_FACTORY_KLASS_MUXER     ,
+    pattern ELEMENT_FACTORY_KLASS_MEDIA_VIDEO,
+    pattern ELEMENT_FACTORY_KLASS_MEDIA_SUBTITLE,
+    pattern ELEMENT_FACTORY_KLASS_MEDIA_METADATA,
+    pattern ELEMENT_FACTORY_KLASS_MEDIA_IMAGE,
+    pattern ELEMENT_FACTORY_KLASS_MEDIA_AUDIO,
+    pattern ELEMENT_FACTORY_KLASS_FORMATTER ,
+    pattern ELEMENT_FACTORY_KLASS_ENCRYPTOR ,
+    pattern ELEMENT_FACTORY_KLASS_ENCODER   ,
+    pattern ELEMENT_FACTORY_KLASS_DEPAYLOADER,
+    pattern ELEMENT_FACTORY_KLASS_DEMUXER   ,
+    pattern ELEMENT_FACTORY_KLASS_DECRYPTOR ,
+    pattern ELEMENT_FACTORY_KLASS_DECODER   ,
+    pattern DEBUG_FORMAT_MASK               ,
+    pattern DEBUG_FG_MASK                   ,
+    pattern DEBUG_BG_MASK                   ,
+    pattern CLOCK_TIME_NONE                 ,
+    pattern CAPS_FEATURE_MEMORY_SYSTEM_MEMORY,
+    pattern CAN_INLINE                      ,
+    pattern BUFFER_OFFSET_NONE              ,
+    pattern BUFFER_COPY_METADATA            ,
+    pattern BUFFER_COPY_ALL                 ,
+    pattern ALLOCATOR_SYSMEM                ,
+
+    ) where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+import GI.Gst.Callbacks
+
+
+pattern VERSION_NANO = 0 :: Int32
+
+
+pattern VERSION_MINOR = 6 :: Int32
+
+
+pattern VERSION_MICRO = 3 :: Int32
+
+
+pattern VERSION_MAJOR = 1 :: Int32
+
+
+pattern VALUE_UNORDERED = 2 :: Int32
+
+
+pattern VALUE_LESS_THAN = -1 :: Int32
+
+
+pattern VALUE_GREATER_THAN = 1 :: Int32
+
+
+pattern VALUE_EQUAL = 0 :: Int32
+
+
+pattern USECOND = 1000 :: Int32
+
+
+pattern URI_NO_PORT = 0 :: Int32
+
+
+pattern TOC_REPEAT_COUNT_INFINITE = -1 :: Int32
+
+
+pattern TIME_FORMAT = "u:%02u:%02u.%09u" :: T.Text
+
+
+pattern TAG_VIDEO_CODEC = "video-codec" :: T.Text
+
+
+pattern TAG_VERSION = "version" :: T.Text
+
+
+pattern TAG_USER_RATING = "user-rating" :: T.Text
+
+
+pattern TAG_TRACK_PEAK = "replaygain-track-peak" :: T.Text
+
+
+pattern TAG_TRACK_NUMBER = "track-number" :: T.Text
+
+
+pattern TAG_TRACK_GAIN = "replaygain-track-gain" :: T.Text
+
+
+pattern TAG_TRACK_COUNT = "track-count" :: T.Text
+
+
+pattern TAG_TITLE_SORTNAME = "title-sortname" :: T.Text
+
+
+pattern TAG_TITLE = "title" :: T.Text
+
+
+pattern TAG_SUBTITLE_CODEC = "subtitle-codec" :: T.Text
+
+
+pattern TAG_SHOW_SORTNAME = "show-sortname" :: T.Text
+
+
+pattern TAG_SHOW_SEASON_NUMBER = "show-season-number" :: T.Text
+
+
+pattern TAG_SHOW_NAME = "show-name" :: T.Text
+
+
+pattern TAG_SHOW_EPISODE_NUMBER = "show-episode-number" :: T.Text
+
+
+pattern TAG_SERIAL = "serial" :: T.Text
+
+
+pattern TAG_REFERENCE_LEVEL = "replaygain-reference-level" :: T.Text
+
+
+pattern TAG_PUBLISHER = "publisher" :: T.Text
+
+
+pattern TAG_PREVIEW_IMAGE = "preview-image" :: T.Text
+
+
+pattern TAG_PERFORMER = "performer" :: T.Text
+
+
+pattern TAG_ORGANIZATION = "organization" :: T.Text
+
+
+pattern TAG_NOMINAL_BITRATE = "nominal-bitrate" :: T.Text
+
+
+pattern TAG_MINIMUM_BITRATE = "minimum-bitrate" :: T.Text
+
+
+pattern TAG_MIDI_BASE_NOTE = "midi-base-note" :: T.Text
+
+
+pattern TAG_MAXIMUM_BITRATE = "maximum-bitrate" :: T.Text
+
+
+pattern TAG_LYRICS = "lyrics" :: T.Text
+
+
+pattern TAG_LOCATION = "location" :: T.Text
+
+
+pattern TAG_LICENSE_URI = "license-uri" :: T.Text
+
+
+pattern TAG_LICENSE = "license" :: T.Text
+
+
+pattern TAG_LANGUAGE_NAME = "language-name" :: T.Text
+
+
+pattern TAG_LANGUAGE_CODE = "language-code" :: T.Text
+
+
+pattern TAG_KEYWORDS = "keywords" :: T.Text
+
+
+pattern TAG_ISRC = "isrc" :: T.Text
+
+
+pattern TAG_INTERPRETED_BY = "interpreted-by" :: T.Text
+
+
+pattern TAG_IMAGE_ORIENTATION = "image-orientation" :: T.Text
+
+
+pattern TAG_IMAGE = "image" :: T.Text
+
+
+pattern TAG_HOMEPAGE = "homepage" :: T.Text
+
+
+pattern TAG_GROUPING = "grouping" :: T.Text
+
+
+pattern TAG_GEO_LOCATION_SUBLOCATION = "geo-location-sublocation" :: T.Text
+
+
+pattern TAG_GEO_LOCATION_NAME = "geo-location-name" :: T.Text
+
+
+pattern TAG_GEO_LOCATION_MOVEMENT_SPEED = "geo-location-movement-speed" :: T.Text
+
+
+pattern TAG_GEO_LOCATION_MOVEMENT_DIRECTION = "geo-location-movement-direction" :: T.Text
+
+
+pattern TAG_GEO_LOCATION_LONGITUDE = "geo-location-longitude" :: T.Text
+
+
+pattern TAG_GEO_LOCATION_LATITUDE = "geo-location-latitude" :: T.Text
+
+
+pattern TAG_GEO_LOCATION_HORIZONTAL_ERROR = "geo-location-horizontal-error" :: T.Text
+
+
+pattern TAG_GEO_LOCATION_ELEVATION = "geo-location-elevation" :: T.Text
+
+
+pattern TAG_GEO_LOCATION_COUNTRY = "geo-location-country" :: T.Text
+
+
+pattern TAG_GEO_LOCATION_CITY = "geo-location-city" :: T.Text
+
+
+pattern TAG_GEO_LOCATION_CAPTURE_DIRECTION = "geo-location-capture-direction" :: T.Text
+
+
+pattern TAG_GENRE = "genre" :: T.Text
+
+
+pattern TAG_EXTENDED_COMMENT = "extended-comment" :: T.Text
+
+
+pattern TAG_ENCODER_VERSION = "encoder-version" :: T.Text
+
+
+pattern TAG_ENCODER = "encoder" :: T.Text
+
+
+pattern TAG_ENCODED_BY = "encoded-by" :: T.Text
+
+
+pattern TAG_DURATION = "duration" :: T.Text
+
+
+pattern TAG_DEVICE_MODEL = "device-model" :: T.Text
+
+
+pattern TAG_DEVICE_MANUFACTURER = "device-manufacturer" :: T.Text
+
+
+pattern TAG_DESCRIPTION = "description" :: T.Text
+
+
+pattern TAG_DATE_TIME = "datetime" :: T.Text
+
+
+pattern TAG_DATE = "date" :: T.Text
+
+
+pattern TAG_COPYRIGHT_URI = "copyright-uri" :: T.Text
+
+
+pattern TAG_COPYRIGHT = "copyright" :: T.Text
+
+
+pattern TAG_CONTAINER_FORMAT = "container-format" :: T.Text
+
+
+pattern TAG_CONTACT = "contact" :: T.Text
+
+
+pattern TAG_COMPOSER_SORTNAME = "composer-sortname" :: T.Text
+
+
+pattern TAG_COMPOSER = "composer" :: T.Text
+
+
+pattern TAG_COMMENT = "comment" :: T.Text
+
+
+pattern TAG_CODEC = "codec" :: T.Text
+
+
+pattern TAG_BITRATE = "bitrate" :: T.Text
+
+
+pattern TAG_BEATS_PER_MINUTE = "beats-per-minute" :: T.Text
+
+
+pattern TAG_AUDIO_CODEC = "audio-codec" :: T.Text
+
+
+pattern TAG_ATTACHMENT = "attachment" :: T.Text
+
+
+pattern TAG_ARTIST_SORTNAME = "artist-sortname" :: T.Text
+
+
+pattern TAG_ARTIST = "artist" :: T.Text
+
+
+pattern TAG_APPLICATION_NAME = "application-name" :: T.Text
+
+
+pattern TAG_APPLICATION_DATA = "application-data" :: T.Text
+
+
+pattern TAG_ALBUM_VOLUME_NUMBER = "album-disc-number" :: T.Text
+
+
+pattern TAG_ALBUM_VOLUME_COUNT = "album-disc-count" :: T.Text
+
+
+pattern TAG_ALBUM_SORTNAME = "album-sortname" :: T.Text
+
+
+pattern TAG_ALBUM_PEAK = "replaygain-album-peak" :: T.Text
+
+
+pattern TAG_ALBUM_GAIN = "replaygain-album-gain" :: T.Text
+
+
+pattern TAG_ALBUM_ARTIST_SORTNAME = "album-artist-sortname" :: T.Text
+
+
+pattern TAG_ALBUM_ARTIST = "album-artist" :: T.Text
+
+
+pattern TAG_ALBUM = "album" :: T.Text
+
+
+pattern STIME_FORMAT = "c%" :: T.Text
+
+
+pattern SEGMENT_FORMAT = "paB" :: T.Text
+
+
+pattern SECOND = 1000000000 :: Int32
+
+
+pattern QUERY_TYPE_BOTH = 0 :: Int32
+
+
+pattern QUERY_NUM_SHIFT = 8 :: Int32
+
+
+pattern PTR_FORMAT = "paA" :: T.Text
+
+
+pattern PROTECTION_SYSTEM_ID_CAPS_FIELD = "protection-system" :: T.Text
+
+
+pattern PARAM_USER_SHIFT = 256 :: Int32
+
+
+pattern PARAM_MUTABLE_READY = 4 :: Int32
+
+
+pattern PARAM_MUTABLE_PLAYING = 16 :: Int32
+
+
+pattern PARAM_MUTABLE_PAUSED = 8 :: Int32
+
+
+pattern PARAM_CONTROLLABLE = 2 :: Int32
+
+
+pattern NSECOND = 1 :: Int32
+
+
+pattern MSECOND = 1000000 :: Int32
+
+
+pattern META_TAG_MEMORY_STR = "memory" :: T.Text
+
+
+pattern MAP_READWRITE = 0 :: Int32
+
+
+pattern LOCK_FLAG_READWRITE = 0 :: Int32
+
+
+pattern LICENSE_UNKNOWN = "unknown" :: T.Text
+
+
+pattern FOURCC_FORMAT = "c%c%c%c" :: T.Text
+
+
+pattern FORMAT_PERCENT_SCALE = 10000 :: Int64
+
+
+pattern FORMAT_PERCENT_MAX = 1000000 :: Int64
+
+
+pattern FLAG_SET_MASK_EXACT = -1 :: Word32
+
+
+pattern EVENT_TYPE_BOTH = 0 :: Int32
+
+
+pattern EVENT_NUM_SHIFT = 8 :: Int32
+
+
+pattern ERROR_SYSTEM = "system error: %s" :: T.Text
+
+
+pattern ELEMENT_METADATA_LONGNAME = "long-name" :: T.Text
+
+
+pattern ELEMENT_METADATA_KLASS = "klass" :: T.Text
+
+
+pattern ELEMENT_METADATA_ICON_NAME = "icon-name" :: T.Text
+
+
+pattern ELEMENT_METADATA_DOC_URI = "doc-uri" :: T.Text
+
+
+pattern ELEMENT_METADATA_DESCRIPTION = "description" :: T.Text
+
+
+pattern ELEMENT_METADATA_AUTHOR = "author" :: T.Text
+
+
+pattern ELEMENT_FACTORY_TYPE_VIDEO_ENCODER = 2814749767106562 :: Int32
+
+
+pattern ELEMENT_FACTORY_TYPE_SRC = 8 :: Int32
+
+
+pattern ELEMENT_FACTORY_TYPE_SINK = 4 :: Int32
+
+
+pattern ELEMENT_FACTORY_TYPE_PAYLOADER = 128 :: Int32
+
+
+pattern ELEMENT_FACTORY_TYPE_PARSER = 64 :: Int32
+
+
+pattern ELEMENT_FACTORY_TYPE_MUXER = 16 :: Int32
+
+
+pattern ELEMENT_FACTORY_TYPE_MEDIA_VIDEO = 562949953421312 :: Int32
+
+
+pattern ELEMENT_FACTORY_TYPE_MEDIA_SUBTITLE = 4503599627370496 :: Int32
+
+
+pattern ELEMENT_FACTORY_TYPE_MEDIA_METADATA = 9007199254740992 :: Int32
+
+
+pattern ELEMENT_FACTORY_TYPE_MEDIA_IMAGE = 2251799813685248 :: Int32
+
+
+pattern ELEMENT_FACTORY_TYPE_MEDIA_AUDIO = 1125899906842624 :: Int32
+
+
+pattern ELEMENT_FACTORY_TYPE_MEDIA_ANY = 18446462598732840960 :: Int32
+
+
+pattern ELEMENT_FACTORY_TYPE_MAX_ELEMENTS = 281474976710656 :: Int32
+
+
+pattern ELEMENT_FACTORY_TYPE_FORMATTER = 512 :: Int32
+
+
+pattern ELEMENT_FACTORY_TYPE_ENCRYPTOR = 2048 :: Int32
+
+
+pattern ELEMENT_FACTORY_TYPE_ENCODER = 2 :: Int32
+
+
+pattern ELEMENT_FACTORY_TYPE_DEPAYLOADER = 256 :: Int32
+
+
+pattern ELEMENT_FACTORY_TYPE_DEMUXER = 32 :: Int32
+
+
+pattern ELEMENT_FACTORY_TYPE_DECRYPTOR = 1024 :: Int32
+
+
+pattern ELEMENT_FACTORY_TYPE_DECODER = 1 :: Int32
+
+
+pattern ELEMENT_FACTORY_TYPE_DECODABLE = 353 :: Int32
+
+
+pattern ELEMENT_FACTORY_TYPE_AUDIO_ENCODER = 1125899906842626 :: Int32
+
+
+pattern ELEMENT_FACTORY_TYPE_AUDIOVIDEO_SINKS = 3940649673949188 :: Int32
+
+
+pattern ELEMENT_FACTORY_TYPE_ANY = 562949953421311 :: Int32
+
+
+pattern ELEMENT_FACTORY_KLASS_SRC = "Source" :: T.Text
+
+
+pattern ELEMENT_FACTORY_KLASS_SINK = "Sink" :: T.Text
+
+
+pattern ELEMENT_FACTORY_KLASS_PAYLOADER = "Payloader" :: T.Text
+
+
+pattern ELEMENT_FACTORY_KLASS_PARSER = "Parser" :: T.Text
+
+
+pattern ELEMENT_FACTORY_KLASS_MUXER = "Muxer" :: T.Text
+
+
+pattern ELEMENT_FACTORY_KLASS_MEDIA_VIDEO = "Video" :: T.Text
+
+
+pattern ELEMENT_FACTORY_KLASS_MEDIA_SUBTITLE = "Subtitle" :: T.Text
+
+
+pattern ELEMENT_FACTORY_KLASS_MEDIA_METADATA = "Metadata" :: T.Text
+
+
+pattern ELEMENT_FACTORY_KLASS_MEDIA_IMAGE = "Image" :: T.Text
+
+
+pattern ELEMENT_FACTORY_KLASS_MEDIA_AUDIO = "Audio" :: T.Text
+
+
+pattern ELEMENT_FACTORY_KLASS_FORMATTER = "Formatter" :: T.Text
+
+
+pattern ELEMENT_FACTORY_KLASS_ENCRYPTOR = "Encryptor" :: T.Text
+
+
+pattern ELEMENT_FACTORY_KLASS_ENCODER = "Encoder" :: T.Text
+
+
+pattern ELEMENT_FACTORY_KLASS_DEPAYLOADER = "Depayloader" :: T.Text
+
+
+pattern ELEMENT_FACTORY_KLASS_DEMUXER = "Demuxer" :: T.Text
+
+
+pattern ELEMENT_FACTORY_KLASS_DECRYPTOR = "Decryptor" :: T.Text
+
+
+pattern ELEMENT_FACTORY_KLASS_DECODER = "Decoder" :: T.Text
+
+
+pattern DEBUG_FORMAT_MASK = 65280 :: Int32
+
+
+pattern DEBUG_FG_MASK = 15 :: Int32
+
+
+pattern DEBUG_BG_MASK = 240 :: Int32
+
+
+pattern CLOCK_TIME_NONE = 18446744073709551615 :: Word64
+
+
+pattern CAPS_FEATURE_MEMORY_SYSTEM_MEMORY = "memory:SystemMemory" :: T.Text
+
+
+pattern CAN_INLINE = 1 :: Int32
+
+
+pattern BUFFER_OFFSET_NONE = 18446744073709551615 :: Word64
+
+
+pattern BUFFER_COPY_METADATA = 0 :: Int32
+
+
+pattern BUFFER_COPY_ALL <- (gflagsToWord -> (0 :: Word64)) :: [BufferCopyFlags] where
+    BUFFER_COPY_ALL = wordToGFlags (0 :: Word64) :: [BufferCopyFlags]
+
+
+pattern ALLOCATOR_SYSMEM = "SystemMemory" :: T.Text
+
+
diff --git a/GI/Gst/Enums.hs b/GI/Gst/Enums.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Enums.hs
@@ -0,0 +1,1855 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+-}
+
+module GI.Gst.Enums
+    ( 
+    catchURIError                           ,
+    handleURIError                          ,
+    catchStreamError                        ,
+    handleStreamError                       ,
+    catchResourceError                      ,
+    handleResourceError                     ,
+    catchPluginError                        ,
+    handlePluginError                       ,
+    catchParseError                         ,
+    handleParseError                        ,
+    catchLibraryError                       ,
+    handleLibraryError                      ,
+    catchCoreError                          ,
+    handleCoreError                         ,
+
+-- * Exported types
+    URIType(..)                             ,
+    URIError(..)                            ,
+    TypeFindProbability(..)                 ,
+    TocScope(..)                            ,
+    TocLoopType(..)                         ,
+    TocEntryType(..)                        ,
+    TaskState(..)                           ,
+    TagScope(..)                            ,
+    TagMergeMode(..)                        ,
+    TagFlag(..)                             ,
+    StructureChangeType(..)                 ,
+    StreamStatusType(..)                    ,
+    StreamError(..)                         ,
+    StateChangeReturn(..)                   ,
+    StateChange(..)                         ,
+    State(..)                               ,
+    SeekType(..)                            ,
+    SearchMode(..)                          ,
+    ResourceError(..)                       ,
+    Rank(..)                                ,
+    QueryType(..)                           ,
+    QOSType(..)                             ,
+    ProgressType(..)                        ,
+    PluginError(..)                         ,
+    ParseError(..)                          ,
+    PadProbeReturn(..)                      ,
+    PadPresence(..)                         ,
+    PadMode(..)                             ,
+    PadLinkReturn(..)                       ,
+    PadDirection(..)                        ,
+    LibraryError(..)                        ,
+    IteratorResult(..)                      ,
+    IteratorItem(..)                        ,
+    Format(..)                              ,
+    FlowReturn(..)                          ,
+    EventType(..)                           ,
+    DebugLevel(..)                          ,
+    DebugColorMode(..)                      ,
+    DebugColorFlags(..)                     ,
+    CoreError(..)                           ,
+    ClockType(..)                           ,
+    ClockReturn(..)                         ,
+    ClockEntryType(..)                      ,
+    CapsIntersectMode(..)                   ,
+    BusSyncReply(..)                        ,
+    BufferingMode(..)                       ,
+
+
+    ) where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+
+
+
+-- Enum URIType
+
+data URIType = 
+      URITypeUnknown
+    | URITypeSink
+    | URITypeSrc
+    | AnotherURIType Int
+    deriving (Show, Eq)
+
+instance Enum URIType where
+    fromEnum URITypeUnknown = 0
+    fromEnum URITypeSink = 1
+    fromEnum URITypeSrc = 2
+    fromEnum (AnotherURIType k) = k
+
+    toEnum 0 = URITypeUnknown
+    toEnum 1 = URITypeSink
+    toEnum 2 = URITypeSrc
+    toEnum k = AnotherURIType k
+
+foreign import ccall "gst_uri_type_get_type" c_gst_uri_type_get_type :: 
+    IO GType
+
+instance BoxedEnum URIType where
+    boxedEnumType _ = c_gst_uri_type_get_type
+
+-- Enum URIError
+
+data URIError = 
+      URIErrorUnsupportedProtocol
+    | URIErrorBadUri
+    | URIErrorBadState
+    | URIErrorBadReference
+    | AnotherURIError Int
+    deriving (Show, Eq)
+
+instance Enum URIError where
+    fromEnum URIErrorUnsupportedProtocol = 0
+    fromEnum URIErrorBadUri = 1
+    fromEnum URIErrorBadState = 2
+    fromEnum URIErrorBadReference = 3
+    fromEnum (AnotherURIError k) = k
+
+    toEnum 0 = URIErrorUnsupportedProtocol
+    toEnum 1 = URIErrorBadUri
+    toEnum 2 = URIErrorBadState
+    toEnum 3 = URIErrorBadReference
+    toEnum k = AnotherURIError k
+
+instance GErrorClass URIError where
+    gerrorClassDomain _ = "gst-uri-error-quark"
+
+catchURIError ::
+    IO a ->
+    (URIError -> GErrorMessage -> IO a) ->
+    IO a
+catchURIError = catchGErrorJustDomain
+
+handleURIError ::
+    (URIError -> GErrorMessage -> IO a) ->
+    IO a ->
+    IO a
+handleURIError = handleGErrorJustDomain
+
+foreign import ccall "gst_uri_error_get_type" c_gst_uri_error_get_type :: 
+    IO GType
+
+instance BoxedEnum URIError where
+    boxedEnumType _ = c_gst_uri_error_get_type
+
+-- Enum TypeFindProbability
+
+data TypeFindProbability = 
+      TypeFindProbabilityNone
+    | TypeFindProbabilityMinimum
+    | TypeFindProbabilityPossible
+    | TypeFindProbabilityLikely
+    | TypeFindProbabilityNearlyCertain
+    | TypeFindProbabilityMaximum
+    | AnotherTypeFindProbability Int
+    deriving (Show, Eq)
+
+instance Enum TypeFindProbability where
+    fromEnum TypeFindProbabilityNone = 0
+    fromEnum TypeFindProbabilityMinimum = 1
+    fromEnum TypeFindProbabilityPossible = 50
+    fromEnum TypeFindProbabilityLikely = 80
+    fromEnum TypeFindProbabilityNearlyCertain = 99
+    fromEnum TypeFindProbabilityMaximum = 100
+    fromEnum (AnotherTypeFindProbability k) = k
+
+    toEnum 0 = TypeFindProbabilityNone
+    toEnum 1 = TypeFindProbabilityMinimum
+    toEnum 50 = TypeFindProbabilityPossible
+    toEnum 80 = TypeFindProbabilityLikely
+    toEnum 99 = TypeFindProbabilityNearlyCertain
+    toEnum 100 = TypeFindProbabilityMaximum
+    toEnum k = AnotherTypeFindProbability k
+
+foreign import ccall "gst_type_find_probability_get_type" c_gst_type_find_probability_get_type :: 
+    IO GType
+
+instance BoxedEnum TypeFindProbability where
+    boxedEnumType _ = c_gst_type_find_probability_get_type
+
+-- Enum TocScope
+
+data TocScope = 
+      TocScopeGlobal
+    | TocScopeCurrent
+    | AnotherTocScope Int
+    deriving (Show, Eq)
+
+instance Enum TocScope where
+    fromEnum TocScopeGlobal = 1
+    fromEnum TocScopeCurrent = 2
+    fromEnum (AnotherTocScope k) = k
+
+    toEnum 1 = TocScopeGlobal
+    toEnum 2 = TocScopeCurrent
+    toEnum k = AnotherTocScope k
+
+foreign import ccall "gst_toc_scope_get_type" c_gst_toc_scope_get_type :: 
+    IO GType
+
+instance BoxedEnum TocScope where
+    boxedEnumType _ = c_gst_toc_scope_get_type
+
+-- Enum TocLoopType
+
+data TocLoopType = 
+      TocLoopTypeNone
+    | TocLoopTypeForward
+    | TocLoopTypeReverse
+    | TocLoopTypePingPong
+    | AnotherTocLoopType Int
+    deriving (Show, Eq)
+
+instance Enum TocLoopType where
+    fromEnum TocLoopTypeNone = 0
+    fromEnum TocLoopTypeForward = 1
+    fromEnum TocLoopTypeReverse = 2
+    fromEnum TocLoopTypePingPong = 3
+    fromEnum (AnotherTocLoopType k) = k
+
+    toEnum 0 = TocLoopTypeNone
+    toEnum 1 = TocLoopTypeForward
+    toEnum 2 = TocLoopTypeReverse
+    toEnum 3 = TocLoopTypePingPong
+    toEnum k = AnotherTocLoopType k
+
+foreign import ccall "gst_toc_loop_type_get_type" c_gst_toc_loop_type_get_type :: 
+    IO GType
+
+instance BoxedEnum TocLoopType where
+    boxedEnumType _ = c_gst_toc_loop_type_get_type
+
+-- Enum TocEntryType
+
+data TocEntryType = 
+      TocEntryTypeAngle
+    | TocEntryTypeVersion
+    | TocEntryTypeEdition
+    | TocEntryTypeInvalid
+    | TocEntryTypeTitle
+    | TocEntryTypeTrack
+    | TocEntryTypeChapter
+    | AnotherTocEntryType Int
+    deriving (Show, Eq)
+
+instance Enum TocEntryType where
+    fromEnum TocEntryTypeAngle = -3
+    fromEnum TocEntryTypeVersion = -2
+    fromEnum TocEntryTypeEdition = -1
+    fromEnum TocEntryTypeInvalid = 0
+    fromEnum TocEntryTypeTitle = 1
+    fromEnum TocEntryTypeTrack = 2
+    fromEnum TocEntryTypeChapter = 3
+    fromEnum (AnotherTocEntryType k) = k
+
+    toEnum -3 = TocEntryTypeAngle
+    toEnum -2 = TocEntryTypeVersion
+    toEnum -1 = TocEntryTypeEdition
+    toEnum 0 = TocEntryTypeInvalid
+    toEnum 1 = TocEntryTypeTitle
+    toEnum 2 = TocEntryTypeTrack
+    toEnum 3 = TocEntryTypeChapter
+    toEnum k = AnotherTocEntryType k
+
+foreign import ccall "gst_toc_entry_type_get_type" c_gst_toc_entry_type_get_type :: 
+    IO GType
+
+instance BoxedEnum TocEntryType where
+    boxedEnumType _ = c_gst_toc_entry_type_get_type
+
+-- Enum TaskState
+
+data TaskState = 
+      TaskStateStarted
+    | TaskStateStopped
+    | TaskStatePaused
+    | AnotherTaskState Int
+    deriving (Show, Eq)
+
+instance Enum TaskState where
+    fromEnum TaskStateStarted = 0
+    fromEnum TaskStateStopped = 1
+    fromEnum TaskStatePaused = 2
+    fromEnum (AnotherTaskState k) = k
+
+    toEnum 0 = TaskStateStarted
+    toEnum 1 = TaskStateStopped
+    toEnum 2 = TaskStatePaused
+    toEnum k = AnotherTaskState k
+
+foreign import ccall "gst_task_state_get_type" c_gst_task_state_get_type :: 
+    IO GType
+
+instance BoxedEnum TaskState where
+    boxedEnumType _ = c_gst_task_state_get_type
+
+-- Enum TagScope
+
+data TagScope = 
+      TagScopeStream
+    | TagScopeGlobal
+    | AnotherTagScope Int
+    deriving (Show, Eq)
+
+instance Enum TagScope where
+    fromEnum TagScopeStream = 0
+    fromEnum TagScopeGlobal = 1
+    fromEnum (AnotherTagScope k) = k
+
+    toEnum 0 = TagScopeStream
+    toEnum 1 = TagScopeGlobal
+    toEnum k = AnotherTagScope k
+
+foreign import ccall "gst_tag_scope_get_type" c_gst_tag_scope_get_type :: 
+    IO GType
+
+instance BoxedEnum TagScope where
+    boxedEnumType _ = c_gst_tag_scope_get_type
+
+-- Enum TagMergeMode
+
+data TagMergeMode = 
+      TagMergeModeUndefined
+    | TagMergeModeReplaceAll
+    | TagMergeModeReplace
+    | TagMergeModeAppend
+    | TagMergeModePrepend
+    | TagMergeModeKeep
+    | TagMergeModeKeepAll
+    | TagMergeModeCount
+    | AnotherTagMergeMode Int
+    deriving (Show, Eq)
+
+instance Enum TagMergeMode where
+    fromEnum TagMergeModeUndefined = 0
+    fromEnum TagMergeModeReplaceAll = 1
+    fromEnum TagMergeModeReplace = 2
+    fromEnum TagMergeModeAppend = 3
+    fromEnum TagMergeModePrepend = 4
+    fromEnum TagMergeModeKeep = 5
+    fromEnum TagMergeModeKeepAll = 6
+    fromEnum TagMergeModeCount = 7
+    fromEnum (AnotherTagMergeMode k) = k
+
+    toEnum 0 = TagMergeModeUndefined
+    toEnum 1 = TagMergeModeReplaceAll
+    toEnum 2 = TagMergeModeReplace
+    toEnum 3 = TagMergeModeAppend
+    toEnum 4 = TagMergeModePrepend
+    toEnum 5 = TagMergeModeKeep
+    toEnum 6 = TagMergeModeKeepAll
+    toEnum 7 = TagMergeModeCount
+    toEnum k = AnotherTagMergeMode k
+
+foreign import ccall "gst_tag_merge_mode_get_type" c_gst_tag_merge_mode_get_type :: 
+    IO GType
+
+instance BoxedEnum TagMergeMode where
+    boxedEnumType _ = c_gst_tag_merge_mode_get_type
+
+-- Enum TagFlag
+
+data TagFlag = 
+      TagFlagUndefined
+    | TagFlagMeta
+    | TagFlagEncoded
+    | TagFlagDecoded
+    | TagFlagCount
+    | AnotherTagFlag Int
+    deriving (Show, Eq)
+
+instance Enum TagFlag where
+    fromEnum TagFlagUndefined = 0
+    fromEnum TagFlagMeta = 1
+    fromEnum TagFlagEncoded = 2
+    fromEnum TagFlagDecoded = 3
+    fromEnum TagFlagCount = 4
+    fromEnum (AnotherTagFlag k) = k
+
+    toEnum 0 = TagFlagUndefined
+    toEnum 1 = TagFlagMeta
+    toEnum 2 = TagFlagEncoded
+    toEnum 3 = TagFlagDecoded
+    toEnum 4 = TagFlagCount
+    toEnum k = AnotherTagFlag k
+
+foreign import ccall "gst_tag_flag_get_type" c_gst_tag_flag_get_type :: 
+    IO GType
+
+instance BoxedEnum TagFlag where
+    boxedEnumType _ = c_gst_tag_flag_get_type
+
+-- Enum StructureChangeType
+
+data StructureChangeType = 
+      StructureChangeTypeLink
+    | StructureChangeTypeUnlink
+    | AnotherStructureChangeType Int
+    deriving (Show, Eq)
+
+instance Enum StructureChangeType where
+    fromEnum StructureChangeTypeLink = 0
+    fromEnum StructureChangeTypeUnlink = 1
+    fromEnum (AnotherStructureChangeType k) = k
+
+    toEnum 0 = StructureChangeTypeLink
+    toEnum 1 = StructureChangeTypeUnlink
+    toEnum k = AnotherStructureChangeType k
+
+foreign import ccall "gst_structure_change_type_get_type" c_gst_structure_change_type_get_type :: 
+    IO GType
+
+instance BoxedEnum StructureChangeType where
+    boxedEnumType _ = c_gst_structure_change_type_get_type
+
+-- Enum StreamStatusType
+
+data StreamStatusType = 
+      StreamStatusTypeCreate
+    | StreamStatusTypeEnter
+    | StreamStatusTypeLeave
+    | StreamStatusTypeDestroy
+    | StreamStatusTypeStart
+    | StreamStatusTypePause
+    | StreamStatusTypeStop
+    | AnotherStreamStatusType Int
+    deriving (Show, Eq)
+
+instance Enum StreamStatusType where
+    fromEnum StreamStatusTypeCreate = 0
+    fromEnum StreamStatusTypeEnter = 1
+    fromEnum StreamStatusTypeLeave = 2
+    fromEnum StreamStatusTypeDestroy = 3
+    fromEnum StreamStatusTypeStart = 8
+    fromEnum StreamStatusTypePause = 9
+    fromEnum StreamStatusTypeStop = 10
+    fromEnum (AnotherStreamStatusType k) = k
+
+    toEnum 0 = StreamStatusTypeCreate
+    toEnum 1 = StreamStatusTypeEnter
+    toEnum 2 = StreamStatusTypeLeave
+    toEnum 3 = StreamStatusTypeDestroy
+    toEnum 8 = StreamStatusTypeStart
+    toEnum 9 = StreamStatusTypePause
+    toEnum 10 = StreamStatusTypeStop
+    toEnum k = AnotherStreamStatusType k
+
+foreign import ccall "gst_stream_status_type_get_type" c_gst_stream_status_type_get_type :: 
+    IO GType
+
+instance BoxedEnum StreamStatusType where
+    boxedEnumType _ = c_gst_stream_status_type_get_type
+
+-- Enum StreamError
+
+data StreamError = 
+      StreamErrorFailed
+    | StreamErrorTooLazy
+    | StreamErrorNotImplemented
+    | StreamErrorTypeNotFound
+    | StreamErrorWrongType
+    | StreamErrorCodecNotFound
+    | StreamErrorDecode
+    | StreamErrorEncode
+    | StreamErrorDemux
+    | StreamErrorMux
+    | StreamErrorFormat
+    | StreamErrorDecrypt
+    | StreamErrorDecryptNokey
+    | StreamErrorNumErrors
+    | AnotherStreamError Int
+    deriving (Show, Eq)
+
+instance Enum StreamError where
+    fromEnum StreamErrorFailed = 1
+    fromEnum StreamErrorTooLazy = 2
+    fromEnum StreamErrorNotImplemented = 3
+    fromEnum StreamErrorTypeNotFound = 4
+    fromEnum StreamErrorWrongType = 5
+    fromEnum StreamErrorCodecNotFound = 6
+    fromEnum StreamErrorDecode = 7
+    fromEnum StreamErrorEncode = 8
+    fromEnum StreamErrorDemux = 9
+    fromEnum StreamErrorMux = 10
+    fromEnum StreamErrorFormat = 11
+    fromEnum StreamErrorDecrypt = 12
+    fromEnum StreamErrorDecryptNokey = 13
+    fromEnum StreamErrorNumErrors = 14
+    fromEnum (AnotherStreamError k) = k
+
+    toEnum 1 = StreamErrorFailed
+    toEnum 2 = StreamErrorTooLazy
+    toEnum 3 = StreamErrorNotImplemented
+    toEnum 4 = StreamErrorTypeNotFound
+    toEnum 5 = StreamErrorWrongType
+    toEnum 6 = StreamErrorCodecNotFound
+    toEnum 7 = StreamErrorDecode
+    toEnum 8 = StreamErrorEncode
+    toEnum 9 = StreamErrorDemux
+    toEnum 10 = StreamErrorMux
+    toEnum 11 = StreamErrorFormat
+    toEnum 12 = StreamErrorDecrypt
+    toEnum 13 = StreamErrorDecryptNokey
+    toEnum 14 = StreamErrorNumErrors
+    toEnum k = AnotherStreamError k
+
+instance GErrorClass StreamError where
+    gerrorClassDomain _ = "gst-stream-error-quark"
+
+catchStreamError ::
+    IO a ->
+    (StreamError -> GErrorMessage -> IO a) ->
+    IO a
+catchStreamError = catchGErrorJustDomain
+
+handleStreamError ::
+    (StreamError -> GErrorMessage -> IO a) ->
+    IO a ->
+    IO a
+handleStreamError = handleGErrorJustDomain
+
+foreign import ccall "gst_stream_error_get_type" c_gst_stream_error_get_type :: 
+    IO GType
+
+instance BoxedEnum StreamError where
+    boxedEnumType _ = c_gst_stream_error_get_type
+
+-- Enum StateChangeReturn
+
+data StateChangeReturn = 
+      StateChangeReturnFailure
+    | StateChangeReturnSuccess
+    | StateChangeReturnAsync
+    | StateChangeReturnNoPreroll
+    | AnotherStateChangeReturn Int
+    deriving (Show, Eq)
+
+instance Enum StateChangeReturn where
+    fromEnum StateChangeReturnFailure = 0
+    fromEnum StateChangeReturnSuccess = 1
+    fromEnum StateChangeReturnAsync = 2
+    fromEnum StateChangeReturnNoPreroll = 3
+    fromEnum (AnotherStateChangeReturn k) = k
+
+    toEnum 0 = StateChangeReturnFailure
+    toEnum 1 = StateChangeReturnSuccess
+    toEnum 2 = StateChangeReturnAsync
+    toEnum 3 = StateChangeReturnNoPreroll
+    toEnum k = AnotherStateChangeReturn k
+
+foreign import ccall "gst_state_change_return_get_type" c_gst_state_change_return_get_type :: 
+    IO GType
+
+instance BoxedEnum StateChangeReturn where
+    boxedEnumType _ = c_gst_state_change_return_get_type
+
+-- Enum StateChange
+
+data StateChange = 
+      StateChangeNullToReady
+    | StateChangeReadyToPaused
+    | StateChangePausedToPlaying
+    | StateChangePlayingToPaused
+    | StateChangePausedToReady
+    | StateChangeReadyToNull
+    | AnotherStateChange Int
+    deriving (Show, Eq)
+
+instance Enum StateChange where
+    fromEnum StateChangeNullToReady = 10
+    fromEnum StateChangeReadyToPaused = 19
+    fromEnum StateChangePausedToPlaying = 28
+    fromEnum StateChangePlayingToPaused = 35
+    fromEnum StateChangePausedToReady = 26
+    fromEnum StateChangeReadyToNull = 17
+    fromEnum (AnotherStateChange k) = k
+
+    toEnum 10 = StateChangeNullToReady
+    toEnum 17 = StateChangeReadyToNull
+    toEnum 19 = StateChangeReadyToPaused
+    toEnum 26 = StateChangePausedToReady
+    toEnum 28 = StateChangePausedToPlaying
+    toEnum 35 = StateChangePlayingToPaused
+    toEnum k = AnotherStateChange k
+
+foreign import ccall "gst_state_change_get_type" c_gst_state_change_get_type :: 
+    IO GType
+
+instance BoxedEnum StateChange where
+    boxedEnumType _ = c_gst_state_change_get_type
+
+-- Enum State
+
+data State = 
+      StateVoidPending
+    | StateNull
+    | StateReady
+    | StatePaused
+    | StatePlaying
+    | AnotherState Int
+    deriving (Show, Eq)
+
+instance Enum State where
+    fromEnum StateVoidPending = 0
+    fromEnum StateNull = 1
+    fromEnum StateReady = 2
+    fromEnum StatePaused = 3
+    fromEnum StatePlaying = 4
+    fromEnum (AnotherState k) = k
+
+    toEnum 0 = StateVoidPending
+    toEnum 1 = StateNull
+    toEnum 2 = StateReady
+    toEnum 3 = StatePaused
+    toEnum 4 = StatePlaying
+    toEnum k = AnotherState k
+
+foreign import ccall "gst_state_get_type" c_gst_state_get_type :: 
+    IO GType
+
+instance BoxedEnum State where
+    boxedEnumType _ = c_gst_state_get_type
+
+-- Enum SeekType
+
+data SeekType = 
+      SeekTypeNone
+    | SeekTypeSet
+    | SeekTypeEnd
+    | AnotherSeekType Int
+    deriving (Show, Eq)
+
+instance Enum SeekType where
+    fromEnum SeekTypeNone = 0
+    fromEnum SeekTypeSet = 1
+    fromEnum SeekTypeEnd = 2
+    fromEnum (AnotherSeekType k) = k
+
+    toEnum 0 = SeekTypeNone
+    toEnum 1 = SeekTypeSet
+    toEnum 2 = SeekTypeEnd
+    toEnum k = AnotherSeekType k
+
+foreign import ccall "gst_seek_type_get_type" c_gst_seek_type_get_type :: 
+    IO GType
+
+instance BoxedEnum SeekType where
+    boxedEnumType _ = c_gst_seek_type_get_type
+
+-- Enum SearchMode
+
+data SearchMode = 
+      SearchModeExact
+    | SearchModeBefore
+    | SearchModeAfter
+    | AnotherSearchMode Int
+    deriving (Show, Eq)
+
+instance Enum SearchMode where
+    fromEnum SearchModeExact = 0
+    fromEnum SearchModeBefore = 1
+    fromEnum SearchModeAfter = 2
+    fromEnum (AnotherSearchMode k) = k
+
+    toEnum 0 = SearchModeExact
+    toEnum 1 = SearchModeBefore
+    toEnum 2 = SearchModeAfter
+    toEnum k = AnotherSearchMode k
+
+foreign import ccall "gst_search_mode_get_type" c_gst_search_mode_get_type :: 
+    IO GType
+
+instance BoxedEnum SearchMode where
+    boxedEnumType _ = c_gst_search_mode_get_type
+
+-- Enum ResourceError
+
+data ResourceError = 
+      ResourceErrorFailed
+    | ResourceErrorTooLazy
+    | ResourceErrorNotFound
+    | ResourceErrorBusy
+    | ResourceErrorOpenRead
+    | ResourceErrorOpenWrite
+    | ResourceErrorOpenReadWrite
+    | ResourceErrorClose
+    | ResourceErrorRead
+    | ResourceErrorWrite
+    | ResourceErrorSeek
+    | ResourceErrorSync
+    | ResourceErrorSettings
+    | ResourceErrorNoSpaceLeft
+    | ResourceErrorNotAuthorized
+    | ResourceErrorNumErrors
+    | AnotherResourceError Int
+    deriving (Show, Eq)
+
+instance Enum ResourceError where
+    fromEnum ResourceErrorFailed = 1
+    fromEnum ResourceErrorTooLazy = 2
+    fromEnum ResourceErrorNotFound = 3
+    fromEnum ResourceErrorBusy = 4
+    fromEnum ResourceErrorOpenRead = 5
+    fromEnum ResourceErrorOpenWrite = 6
+    fromEnum ResourceErrorOpenReadWrite = 7
+    fromEnum ResourceErrorClose = 8
+    fromEnum ResourceErrorRead = 9
+    fromEnum ResourceErrorWrite = 10
+    fromEnum ResourceErrorSeek = 11
+    fromEnum ResourceErrorSync = 12
+    fromEnum ResourceErrorSettings = 13
+    fromEnum ResourceErrorNoSpaceLeft = 14
+    fromEnum ResourceErrorNotAuthorized = 15
+    fromEnum ResourceErrorNumErrors = 16
+    fromEnum (AnotherResourceError k) = k
+
+    toEnum 1 = ResourceErrorFailed
+    toEnum 2 = ResourceErrorTooLazy
+    toEnum 3 = ResourceErrorNotFound
+    toEnum 4 = ResourceErrorBusy
+    toEnum 5 = ResourceErrorOpenRead
+    toEnum 6 = ResourceErrorOpenWrite
+    toEnum 7 = ResourceErrorOpenReadWrite
+    toEnum 8 = ResourceErrorClose
+    toEnum 9 = ResourceErrorRead
+    toEnum 10 = ResourceErrorWrite
+    toEnum 11 = ResourceErrorSeek
+    toEnum 12 = ResourceErrorSync
+    toEnum 13 = ResourceErrorSettings
+    toEnum 14 = ResourceErrorNoSpaceLeft
+    toEnum 15 = ResourceErrorNotAuthorized
+    toEnum 16 = ResourceErrorNumErrors
+    toEnum k = AnotherResourceError k
+
+instance GErrorClass ResourceError where
+    gerrorClassDomain _ = "gst-resource-error-quark"
+
+catchResourceError ::
+    IO a ->
+    (ResourceError -> GErrorMessage -> IO a) ->
+    IO a
+catchResourceError = catchGErrorJustDomain
+
+handleResourceError ::
+    (ResourceError -> GErrorMessage -> IO a) ->
+    IO a ->
+    IO a
+handleResourceError = handleGErrorJustDomain
+
+foreign import ccall "gst_resource_error_get_type" c_gst_resource_error_get_type :: 
+    IO GType
+
+instance BoxedEnum ResourceError where
+    boxedEnumType _ = c_gst_resource_error_get_type
+
+-- Enum Rank
+
+data Rank = 
+      RankNone
+    | RankMarginal
+    | RankSecondary
+    | RankPrimary
+    | AnotherRank Int
+    deriving (Show, Eq)
+
+instance Enum Rank where
+    fromEnum RankNone = 0
+    fromEnum RankMarginal = 64
+    fromEnum RankSecondary = 128
+    fromEnum RankPrimary = 256
+    fromEnum (AnotherRank k) = k
+
+    toEnum 0 = RankNone
+    toEnum 64 = RankMarginal
+    toEnum 128 = RankSecondary
+    toEnum 256 = RankPrimary
+    toEnum k = AnotherRank k
+
+foreign import ccall "gst_rank_get_type" c_gst_rank_get_type :: 
+    IO GType
+
+instance BoxedEnum Rank where
+    boxedEnumType _ = c_gst_rank_get_type
+
+-- Enum QueryType
+
+data QueryType = 
+      QueryTypeUnknown
+    | QueryTypePosition
+    | QueryTypeDuration
+    | QueryTypeLatency
+    | QueryTypeJitter
+    | QueryTypeRate
+    | QueryTypeSeeking
+    | QueryTypeSegment
+    | QueryTypeConvert
+    | QueryTypeFormats
+    | QueryTypeBuffering
+    | QueryTypeCustom
+    | QueryTypeUri
+    | QueryTypeAllocation
+    | QueryTypeScheduling
+    | QueryTypeAcceptCaps
+    | QueryTypeCaps
+    | QueryTypeDrain
+    | QueryTypeContext
+    | AnotherQueryType Int
+    deriving (Show, Eq)
+
+instance Enum QueryType where
+    fromEnum QueryTypeUnknown = 0
+    fromEnum QueryTypePosition = 2563
+    fromEnum QueryTypeDuration = 5123
+    fromEnum QueryTypeLatency = 7683
+    fromEnum QueryTypeJitter = 10243
+    fromEnum QueryTypeRate = 12803
+    fromEnum QueryTypeSeeking = 15363
+    fromEnum QueryTypeSegment = 17923
+    fromEnum QueryTypeConvert = 20483
+    fromEnum QueryTypeFormats = 23043
+    fromEnum QueryTypeBuffering = 28163
+    fromEnum QueryTypeCustom = 30723
+    fromEnum QueryTypeUri = 33283
+    fromEnum QueryTypeAllocation = 35846
+    fromEnum QueryTypeScheduling = 38401
+    fromEnum QueryTypeAcceptCaps = 40963
+    fromEnum QueryTypeCaps = 43523
+    fromEnum QueryTypeDrain = 46086
+    fromEnum QueryTypeContext = 48643
+    fromEnum (AnotherQueryType k) = k
+
+    toEnum 0 = QueryTypeUnknown
+    toEnum 2563 = QueryTypePosition
+    toEnum 5123 = QueryTypeDuration
+    toEnum 7683 = QueryTypeLatency
+    toEnum 10243 = QueryTypeJitter
+    toEnum 12803 = QueryTypeRate
+    toEnum 15363 = QueryTypeSeeking
+    toEnum 17923 = QueryTypeSegment
+    toEnum 20483 = QueryTypeConvert
+    toEnum 23043 = QueryTypeFormats
+    toEnum 28163 = QueryTypeBuffering
+    toEnum 30723 = QueryTypeCustom
+    toEnum 33283 = QueryTypeUri
+    toEnum 35846 = QueryTypeAllocation
+    toEnum 38401 = QueryTypeScheduling
+    toEnum 40963 = QueryTypeAcceptCaps
+    toEnum 43523 = QueryTypeCaps
+    toEnum 46086 = QueryTypeDrain
+    toEnum 48643 = QueryTypeContext
+    toEnum k = AnotherQueryType k
+
+foreign import ccall "gst_query_type_get_type" c_gst_query_type_get_type :: 
+    IO GType
+
+instance BoxedEnum QueryType where
+    boxedEnumType _ = c_gst_query_type_get_type
+
+-- Enum QOSType
+
+data QOSType = 
+      QOSTypeOverflow
+    | QOSTypeUnderflow
+    | QOSTypeThrottle
+    | AnotherQOSType Int
+    deriving (Show, Eq)
+
+instance Enum QOSType where
+    fromEnum QOSTypeOverflow = 0
+    fromEnum QOSTypeUnderflow = 1
+    fromEnum QOSTypeThrottle = 2
+    fromEnum (AnotherQOSType k) = k
+
+    toEnum 0 = QOSTypeOverflow
+    toEnum 1 = QOSTypeUnderflow
+    toEnum 2 = QOSTypeThrottle
+    toEnum k = AnotherQOSType k
+
+foreign import ccall "gst_qos_type_get_type" c_gst_qos_type_get_type :: 
+    IO GType
+
+instance BoxedEnum QOSType where
+    boxedEnumType _ = c_gst_qos_type_get_type
+
+-- Enum ProgressType
+
+data ProgressType = 
+      ProgressTypeStart
+    | ProgressTypeContinue
+    | ProgressTypeComplete
+    | ProgressTypeCanceled
+    | ProgressTypeError
+    | AnotherProgressType Int
+    deriving (Show, Eq)
+
+instance Enum ProgressType where
+    fromEnum ProgressTypeStart = 0
+    fromEnum ProgressTypeContinue = 1
+    fromEnum ProgressTypeComplete = 2
+    fromEnum ProgressTypeCanceled = 3
+    fromEnum ProgressTypeError = 4
+    fromEnum (AnotherProgressType k) = k
+
+    toEnum 0 = ProgressTypeStart
+    toEnum 1 = ProgressTypeContinue
+    toEnum 2 = ProgressTypeComplete
+    toEnum 3 = ProgressTypeCanceled
+    toEnum 4 = ProgressTypeError
+    toEnum k = AnotherProgressType k
+
+foreign import ccall "gst_progress_type_get_type" c_gst_progress_type_get_type :: 
+    IO GType
+
+instance BoxedEnum ProgressType where
+    boxedEnumType _ = c_gst_progress_type_get_type
+
+-- Enum PluginError
+
+data PluginError = 
+      PluginErrorModule
+    | PluginErrorDependencies
+    | PluginErrorNameMismatch
+    | AnotherPluginError Int
+    deriving (Show, Eq)
+
+instance Enum PluginError where
+    fromEnum PluginErrorModule = 0
+    fromEnum PluginErrorDependencies = 1
+    fromEnum PluginErrorNameMismatch = 2
+    fromEnum (AnotherPluginError k) = k
+
+    toEnum 0 = PluginErrorModule
+    toEnum 1 = PluginErrorDependencies
+    toEnum 2 = PluginErrorNameMismatch
+    toEnum k = AnotherPluginError k
+
+instance GErrorClass PluginError where
+    gerrorClassDomain _ = "gst_plugin_error"
+
+catchPluginError ::
+    IO a ->
+    (PluginError -> GErrorMessage -> IO a) ->
+    IO a
+catchPluginError = catchGErrorJustDomain
+
+handlePluginError ::
+    (PluginError -> GErrorMessage -> IO a) ->
+    IO a ->
+    IO a
+handlePluginError = handleGErrorJustDomain
+
+foreign import ccall "gst_plugin_error_get_type" c_gst_plugin_error_get_type :: 
+    IO GType
+
+instance BoxedEnum PluginError where
+    boxedEnumType _ = c_gst_plugin_error_get_type
+
+-- Enum ParseError
+
+data ParseError = 
+      ParseErrorSyntax
+    | ParseErrorNoSuchElement
+    | ParseErrorNoSuchProperty
+    | ParseErrorLink
+    | ParseErrorCouldNotSetProperty
+    | ParseErrorEmptyBin
+    | ParseErrorEmpty
+    | AnotherParseError Int
+    deriving (Show, Eq)
+
+instance Enum ParseError where
+    fromEnum ParseErrorSyntax = 0
+    fromEnum ParseErrorNoSuchElement = 1
+    fromEnum ParseErrorNoSuchProperty = 2
+    fromEnum ParseErrorLink = 3
+    fromEnum ParseErrorCouldNotSetProperty = 4
+    fromEnum ParseErrorEmptyBin = 5
+    fromEnum ParseErrorEmpty = 6
+    fromEnum (AnotherParseError k) = k
+
+    toEnum 0 = ParseErrorSyntax
+    toEnum 1 = ParseErrorNoSuchElement
+    toEnum 2 = ParseErrorNoSuchProperty
+    toEnum 3 = ParseErrorLink
+    toEnum 4 = ParseErrorCouldNotSetProperty
+    toEnum 5 = ParseErrorEmptyBin
+    toEnum 6 = ParseErrorEmpty
+    toEnum k = AnotherParseError k
+
+instance GErrorClass ParseError where
+    gerrorClassDomain _ = "gst_parse_error"
+
+catchParseError ::
+    IO a ->
+    (ParseError -> GErrorMessage -> IO a) ->
+    IO a
+catchParseError = catchGErrorJustDomain
+
+handleParseError ::
+    (ParseError -> GErrorMessage -> IO a) ->
+    IO a ->
+    IO a
+handleParseError = handleGErrorJustDomain
+
+foreign import ccall "gst_parse_error_get_type" c_gst_parse_error_get_type :: 
+    IO GType
+
+instance BoxedEnum ParseError where
+    boxedEnumType _ = c_gst_parse_error_get_type
+
+-- Enum PadProbeReturn
+
+data PadProbeReturn = 
+      PadProbeReturnDrop
+    | PadProbeReturnOk
+    | PadProbeReturnRemove
+    | PadProbeReturnPass
+    | PadProbeReturnHandled
+    | AnotherPadProbeReturn Int
+    deriving (Show, Eq)
+
+instance Enum PadProbeReturn where
+    fromEnum PadProbeReturnDrop = 0
+    fromEnum PadProbeReturnOk = 1
+    fromEnum PadProbeReturnRemove = 2
+    fromEnum PadProbeReturnPass = 3
+    fromEnum PadProbeReturnHandled = 4
+    fromEnum (AnotherPadProbeReturn k) = k
+
+    toEnum 0 = PadProbeReturnDrop
+    toEnum 1 = PadProbeReturnOk
+    toEnum 2 = PadProbeReturnRemove
+    toEnum 3 = PadProbeReturnPass
+    toEnum 4 = PadProbeReturnHandled
+    toEnum k = AnotherPadProbeReturn k
+
+foreign import ccall "gst_pad_probe_return_get_type" c_gst_pad_probe_return_get_type :: 
+    IO GType
+
+instance BoxedEnum PadProbeReturn where
+    boxedEnumType _ = c_gst_pad_probe_return_get_type
+
+-- Enum PadPresence
+
+data PadPresence = 
+      PadPresenceAlways
+    | PadPresenceSometimes
+    | PadPresenceRequest
+    | AnotherPadPresence Int
+    deriving (Show, Eq)
+
+instance Enum PadPresence where
+    fromEnum PadPresenceAlways = 0
+    fromEnum PadPresenceSometimes = 1
+    fromEnum PadPresenceRequest = 2
+    fromEnum (AnotherPadPresence k) = k
+
+    toEnum 0 = PadPresenceAlways
+    toEnum 1 = PadPresenceSometimes
+    toEnum 2 = PadPresenceRequest
+    toEnum k = AnotherPadPresence k
+
+foreign import ccall "gst_pad_presence_get_type" c_gst_pad_presence_get_type :: 
+    IO GType
+
+instance BoxedEnum PadPresence where
+    boxedEnumType _ = c_gst_pad_presence_get_type
+
+-- Enum PadMode
+
+data PadMode = 
+      PadModeNone
+    | PadModePush
+    | PadModePull
+    | AnotherPadMode Int
+    deriving (Show, Eq)
+
+instance Enum PadMode where
+    fromEnum PadModeNone = 0
+    fromEnum PadModePush = 1
+    fromEnum PadModePull = 2
+    fromEnum (AnotherPadMode k) = k
+
+    toEnum 0 = PadModeNone
+    toEnum 1 = PadModePush
+    toEnum 2 = PadModePull
+    toEnum k = AnotherPadMode k
+
+foreign import ccall "gst_pad_mode_get_type" c_gst_pad_mode_get_type :: 
+    IO GType
+
+instance BoxedEnum PadMode where
+    boxedEnumType _ = c_gst_pad_mode_get_type
+
+-- Enum PadLinkReturn
+
+data PadLinkReturn = 
+      PadLinkReturnOk
+    | PadLinkReturnWrongHierarchy
+    | PadLinkReturnWasLinked
+    | PadLinkReturnWrongDirection
+    | PadLinkReturnNoformat
+    | PadLinkReturnNosched
+    | PadLinkReturnRefused
+    | AnotherPadLinkReturn Int
+    deriving (Show, Eq)
+
+instance Enum PadLinkReturn where
+    fromEnum PadLinkReturnOk = 0
+    fromEnum PadLinkReturnWrongHierarchy = -1
+    fromEnum PadLinkReturnWasLinked = -2
+    fromEnum PadLinkReturnWrongDirection = -3
+    fromEnum PadLinkReturnNoformat = -4
+    fromEnum PadLinkReturnNosched = -5
+    fromEnum PadLinkReturnRefused = -6
+    fromEnum (AnotherPadLinkReturn k) = k
+
+    toEnum -6 = PadLinkReturnRefused
+    toEnum -5 = PadLinkReturnNosched
+    toEnum -4 = PadLinkReturnNoformat
+    toEnum -3 = PadLinkReturnWrongDirection
+    toEnum -2 = PadLinkReturnWasLinked
+    toEnum -1 = PadLinkReturnWrongHierarchy
+    toEnum 0 = PadLinkReturnOk
+    toEnum k = AnotherPadLinkReturn k
+
+foreign import ccall "gst_pad_link_return_get_type" c_gst_pad_link_return_get_type :: 
+    IO GType
+
+instance BoxedEnum PadLinkReturn where
+    boxedEnumType _ = c_gst_pad_link_return_get_type
+
+-- Enum PadDirection
+
+data PadDirection = 
+      PadDirectionUnknown
+    | PadDirectionSrc
+    | PadDirectionSink
+    | AnotherPadDirection Int
+    deriving (Show, Eq)
+
+instance Enum PadDirection where
+    fromEnum PadDirectionUnknown = 0
+    fromEnum PadDirectionSrc = 1
+    fromEnum PadDirectionSink = 2
+    fromEnum (AnotherPadDirection k) = k
+
+    toEnum 0 = PadDirectionUnknown
+    toEnum 1 = PadDirectionSrc
+    toEnum 2 = PadDirectionSink
+    toEnum k = AnotherPadDirection k
+
+foreign import ccall "gst_pad_direction_get_type" c_gst_pad_direction_get_type :: 
+    IO GType
+
+instance BoxedEnum PadDirection where
+    boxedEnumType _ = c_gst_pad_direction_get_type
+
+-- Enum LibraryError
+
+data LibraryError = 
+      LibraryErrorFailed
+    | LibraryErrorTooLazy
+    | LibraryErrorInit
+    | LibraryErrorShutdown
+    | LibraryErrorSettings
+    | LibraryErrorEncode
+    | LibraryErrorNumErrors
+    | AnotherLibraryError Int
+    deriving (Show, Eq)
+
+instance Enum LibraryError where
+    fromEnum LibraryErrorFailed = 1
+    fromEnum LibraryErrorTooLazy = 2
+    fromEnum LibraryErrorInit = 3
+    fromEnum LibraryErrorShutdown = 4
+    fromEnum LibraryErrorSettings = 5
+    fromEnum LibraryErrorEncode = 6
+    fromEnum LibraryErrorNumErrors = 7
+    fromEnum (AnotherLibraryError k) = k
+
+    toEnum 1 = LibraryErrorFailed
+    toEnum 2 = LibraryErrorTooLazy
+    toEnum 3 = LibraryErrorInit
+    toEnum 4 = LibraryErrorShutdown
+    toEnum 5 = LibraryErrorSettings
+    toEnum 6 = LibraryErrorEncode
+    toEnum 7 = LibraryErrorNumErrors
+    toEnum k = AnotherLibraryError k
+
+instance GErrorClass LibraryError where
+    gerrorClassDomain _ = "gst-library-error-quark"
+
+catchLibraryError ::
+    IO a ->
+    (LibraryError -> GErrorMessage -> IO a) ->
+    IO a
+catchLibraryError = catchGErrorJustDomain
+
+handleLibraryError ::
+    (LibraryError -> GErrorMessage -> IO a) ->
+    IO a ->
+    IO a
+handleLibraryError = handleGErrorJustDomain
+
+foreign import ccall "gst_library_error_get_type" c_gst_library_error_get_type :: 
+    IO GType
+
+instance BoxedEnum LibraryError where
+    boxedEnumType _ = c_gst_library_error_get_type
+
+-- Enum IteratorResult
+
+data IteratorResult = 
+      IteratorResultDone
+    | IteratorResultOk
+    | IteratorResultResync
+    | IteratorResultError
+    | AnotherIteratorResult Int
+    deriving (Show, Eq)
+
+instance Enum IteratorResult where
+    fromEnum IteratorResultDone = 0
+    fromEnum IteratorResultOk = 1
+    fromEnum IteratorResultResync = 2
+    fromEnum IteratorResultError = 3
+    fromEnum (AnotherIteratorResult k) = k
+
+    toEnum 0 = IteratorResultDone
+    toEnum 1 = IteratorResultOk
+    toEnum 2 = IteratorResultResync
+    toEnum 3 = IteratorResultError
+    toEnum k = AnotherIteratorResult k
+
+foreign import ccall "gst_iterator_result_get_type" c_gst_iterator_result_get_type :: 
+    IO GType
+
+instance BoxedEnum IteratorResult where
+    boxedEnumType _ = c_gst_iterator_result_get_type
+
+-- Enum IteratorItem
+
+data IteratorItem = 
+      IteratorItemSkip
+    | IteratorItemPass
+    | IteratorItemEnd
+    | AnotherIteratorItem Int
+    deriving (Show, Eq)
+
+instance Enum IteratorItem where
+    fromEnum IteratorItemSkip = 0
+    fromEnum IteratorItemPass = 1
+    fromEnum IteratorItemEnd = 2
+    fromEnum (AnotherIteratorItem k) = k
+
+    toEnum 0 = IteratorItemSkip
+    toEnum 1 = IteratorItemPass
+    toEnum 2 = IteratorItemEnd
+    toEnum k = AnotherIteratorItem k
+
+foreign import ccall "gst_iterator_item_get_type" c_gst_iterator_item_get_type :: 
+    IO GType
+
+instance BoxedEnum IteratorItem where
+    boxedEnumType _ = c_gst_iterator_item_get_type
+
+-- Enum Format
+
+data Format = 
+      FormatUndefined
+    | FormatDefault
+    | FormatBytes
+    | FormatTime
+    | FormatBuffers
+    | FormatPercent
+    | AnotherFormat Int
+    deriving (Show, Eq)
+
+instance Enum Format where
+    fromEnum FormatUndefined = 0
+    fromEnum FormatDefault = 1
+    fromEnum FormatBytes = 2
+    fromEnum FormatTime = 3
+    fromEnum FormatBuffers = 4
+    fromEnum FormatPercent = 5
+    fromEnum (AnotherFormat k) = k
+
+    toEnum 0 = FormatUndefined
+    toEnum 1 = FormatDefault
+    toEnum 2 = FormatBytes
+    toEnum 3 = FormatTime
+    toEnum 4 = FormatBuffers
+    toEnum 5 = FormatPercent
+    toEnum k = AnotherFormat k
+
+foreign import ccall "gst_format_get_type" c_gst_format_get_type :: 
+    IO GType
+
+instance BoxedEnum Format where
+    boxedEnumType _ = c_gst_format_get_type
+
+-- Enum FlowReturn
+
+data FlowReturn = 
+      FlowReturnCustomSuccess2
+    | FlowReturnCustomSuccess1
+    | FlowReturnCustomSuccess
+    | FlowReturnOk
+    | FlowReturnNotLinked
+    | FlowReturnFlushing
+    | FlowReturnEos
+    | FlowReturnNotNegotiated
+    | FlowReturnError
+    | FlowReturnNotSupported
+    | FlowReturnCustomError
+    | FlowReturnCustomError1
+    | FlowReturnCustomError2
+    | AnotherFlowReturn Int
+    deriving (Show, Eq)
+
+instance Enum FlowReturn where
+    fromEnum FlowReturnCustomSuccess2 = 102
+    fromEnum FlowReturnCustomSuccess1 = 101
+    fromEnum FlowReturnCustomSuccess = 100
+    fromEnum FlowReturnOk = 0
+    fromEnum FlowReturnNotLinked = -1
+    fromEnum FlowReturnFlushing = -2
+    fromEnum FlowReturnEos = -3
+    fromEnum FlowReturnNotNegotiated = -4
+    fromEnum FlowReturnError = -5
+    fromEnum FlowReturnNotSupported = -6
+    fromEnum FlowReturnCustomError = -100
+    fromEnum FlowReturnCustomError1 = -101
+    fromEnum FlowReturnCustomError2 = -102
+    fromEnum (AnotherFlowReturn k) = k
+
+    toEnum -102 = FlowReturnCustomError2
+    toEnum -101 = FlowReturnCustomError1
+    toEnum -100 = FlowReturnCustomError
+    toEnum -6 = FlowReturnNotSupported
+    toEnum -5 = FlowReturnError
+    toEnum -4 = FlowReturnNotNegotiated
+    toEnum -3 = FlowReturnEos
+    toEnum -2 = FlowReturnFlushing
+    toEnum -1 = FlowReturnNotLinked
+    toEnum 0 = FlowReturnOk
+    toEnum 100 = FlowReturnCustomSuccess
+    toEnum 101 = FlowReturnCustomSuccess1
+    toEnum 102 = FlowReturnCustomSuccess2
+    toEnum k = AnotherFlowReturn k
+
+foreign import ccall "gst_flow_return_get_type" c_gst_flow_return_get_type :: 
+    IO GType
+
+instance BoxedEnum FlowReturn where
+    boxedEnumType _ = c_gst_flow_return_get_type
+
+-- Enum EventType
+
+data EventType = 
+      EventTypeUnknown
+    | EventTypeFlushStart
+    | EventTypeFlushStop
+    | EventTypeStreamStart
+    | EventTypeCaps
+    | EventTypeSegment
+    | EventTypeTag
+    | EventTypeBuffersize
+    | EventTypeSinkMessage
+    | EventTypeEos
+    | EventTypeToc
+    | EventTypeProtection
+    | EventTypeSegmentDone
+    | EventTypeGap
+    | EventTypeQos
+    | EventTypeSeek
+    | EventTypeNavigation
+    | EventTypeLatency
+    | EventTypeStep
+    | EventTypeReconfigure
+    | EventTypeTocSelect
+    | EventTypeCustomUpstream
+    | EventTypeCustomDownstream
+    | EventTypeCustomDownstreamOob
+    | EventTypeCustomDownstreamSticky
+    | EventTypeCustomBoth
+    | EventTypeCustomBothOob
+    | AnotherEventType Int
+    deriving (Show, Eq)
+
+instance Enum EventType where
+    fromEnum EventTypeUnknown = 0
+    fromEnum EventTypeFlushStart = 2563
+    fromEnum EventTypeFlushStop = 5127
+    fromEnum EventTypeStreamStart = 10254
+    fromEnum EventTypeCaps = 12814
+    fromEnum EventTypeSegment = 17934
+    fromEnum EventTypeTag = 20510
+    fromEnum EventTypeBuffersize = 23054
+    fromEnum EventTypeSinkMessage = 25630
+    fromEnum EventTypeEos = 28174
+    fromEnum EventTypeToc = 30750
+    fromEnum EventTypeProtection = 33310
+    fromEnum EventTypeSegmentDone = 38406
+    fromEnum EventTypeGap = 40966
+    fromEnum EventTypeQos = 48641
+    fromEnum EventTypeSeek = 51201
+    fromEnum EventTypeNavigation = 53761
+    fromEnum EventTypeLatency = 56321
+    fromEnum EventTypeStep = 58881
+    fromEnum EventTypeReconfigure = 61441
+    fromEnum EventTypeTocSelect = 64001
+    fromEnum EventTypeCustomUpstream = 69121
+    fromEnum EventTypeCustomDownstream = 71686
+    fromEnum EventTypeCustomDownstreamOob = 74242
+    fromEnum EventTypeCustomDownstreamSticky = 76830
+    fromEnum EventTypeCustomBoth = 79367
+    fromEnum EventTypeCustomBothOob = 81923
+    fromEnum (AnotherEventType k) = k
+
+    toEnum 0 = EventTypeUnknown
+    toEnum 2563 = EventTypeFlushStart
+    toEnum 5127 = EventTypeFlushStop
+    toEnum 10254 = EventTypeStreamStart
+    toEnum 12814 = EventTypeCaps
+    toEnum 17934 = EventTypeSegment
+    toEnum 20510 = EventTypeTag
+    toEnum 23054 = EventTypeBuffersize
+    toEnum 25630 = EventTypeSinkMessage
+    toEnum 28174 = EventTypeEos
+    toEnum 30750 = EventTypeToc
+    toEnum 33310 = EventTypeProtection
+    toEnum 38406 = EventTypeSegmentDone
+    toEnum 40966 = EventTypeGap
+    toEnum 48641 = EventTypeQos
+    toEnum 51201 = EventTypeSeek
+    toEnum 53761 = EventTypeNavigation
+    toEnum 56321 = EventTypeLatency
+    toEnum 58881 = EventTypeStep
+    toEnum 61441 = EventTypeReconfigure
+    toEnum 64001 = EventTypeTocSelect
+    toEnum 69121 = EventTypeCustomUpstream
+    toEnum 71686 = EventTypeCustomDownstream
+    toEnum 74242 = EventTypeCustomDownstreamOob
+    toEnum 76830 = EventTypeCustomDownstreamSticky
+    toEnum 79367 = EventTypeCustomBoth
+    toEnum 81923 = EventTypeCustomBothOob
+    toEnum k = AnotherEventType k
+
+foreign import ccall "gst_event_type_get_type" c_gst_event_type_get_type :: 
+    IO GType
+
+instance BoxedEnum EventType where
+    boxedEnumType _ = c_gst_event_type_get_type
+
+-- Enum DebugLevel
+
+data DebugLevel = 
+      DebugLevelNone
+    | DebugLevelError
+    | DebugLevelWarning
+    | DebugLevelFixme
+    | DebugLevelInfo
+    | DebugLevelDebug
+    | DebugLevelLog
+    | DebugLevelTrace
+    | DebugLevelMemdump
+    | DebugLevelCount
+    | AnotherDebugLevel Int
+    deriving (Show, Eq)
+
+instance Enum DebugLevel where
+    fromEnum DebugLevelNone = 0
+    fromEnum DebugLevelError = 1
+    fromEnum DebugLevelWarning = 2
+    fromEnum DebugLevelFixme = 3
+    fromEnum DebugLevelInfo = 4
+    fromEnum DebugLevelDebug = 5
+    fromEnum DebugLevelLog = 6
+    fromEnum DebugLevelTrace = 7
+    fromEnum DebugLevelMemdump = 9
+    fromEnum DebugLevelCount = 10
+    fromEnum (AnotherDebugLevel k) = k
+
+    toEnum 0 = DebugLevelNone
+    toEnum 1 = DebugLevelError
+    toEnum 2 = DebugLevelWarning
+    toEnum 3 = DebugLevelFixme
+    toEnum 4 = DebugLevelInfo
+    toEnum 5 = DebugLevelDebug
+    toEnum 6 = DebugLevelLog
+    toEnum 7 = DebugLevelTrace
+    toEnum 9 = DebugLevelMemdump
+    toEnum 10 = DebugLevelCount
+    toEnum k = AnotherDebugLevel k
+
+foreign import ccall "gst_debug_level_get_type" c_gst_debug_level_get_type :: 
+    IO GType
+
+instance BoxedEnum DebugLevel where
+    boxedEnumType _ = c_gst_debug_level_get_type
+
+-- Enum DebugColorMode
+
+data DebugColorMode = 
+      DebugColorModeOff
+    | DebugColorModeOn
+    | DebugColorModeUnix
+    | AnotherDebugColorMode Int
+    deriving (Show, Eq)
+
+instance Enum DebugColorMode where
+    fromEnum DebugColorModeOff = 0
+    fromEnum DebugColorModeOn = 1
+    fromEnum DebugColorModeUnix = 2
+    fromEnum (AnotherDebugColorMode k) = k
+
+    toEnum 0 = DebugColorModeOff
+    toEnum 1 = DebugColorModeOn
+    toEnum 2 = DebugColorModeUnix
+    toEnum k = AnotherDebugColorMode k
+
+foreign import ccall "gst_debug_color_mode_get_type" c_gst_debug_color_mode_get_type :: 
+    IO GType
+
+instance BoxedEnum DebugColorMode where
+    boxedEnumType _ = c_gst_debug_color_mode_get_type
+
+-- Enum DebugColorFlags
+
+data DebugColorFlags = 
+      DebugColorFlagsFgBlack
+    | DebugColorFlagsFgRed
+    | DebugColorFlagsFgGreen
+    | DebugColorFlagsFgYellow
+    | DebugColorFlagsFgBlue
+    | DebugColorFlagsFgMagenta
+    | DebugColorFlagsFgCyan
+    | DebugColorFlagsFgWhite
+    | DebugColorFlagsBgBlack
+    | DebugColorFlagsBgRed
+    | DebugColorFlagsBgGreen
+    | DebugColorFlagsBgYellow
+    | DebugColorFlagsBgBlue
+    | DebugColorFlagsBgMagenta
+    | DebugColorFlagsBgCyan
+    | DebugColorFlagsBgWhite
+    | DebugColorFlagsBold
+    | DebugColorFlagsUnderline
+    | AnotherDebugColorFlags Int
+    deriving (Show, Eq)
+
+instance Enum DebugColorFlags where
+    fromEnum DebugColorFlagsFgBlack = 0
+    fromEnum DebugColorFlagsFgRed = 1
+    fromEnum DebugColorFlagsFgGreen = 2
+    fromEnum DebugColorFlagsFgYellow = 3
+    fromEnum DebugColorFlagsFgBlue = 4
+    fromEnum DebugColorFlagsFgMagenta = 5
+    fromEnum DebugColorFlagsFgCyan = 6
+    fromEnum DebugColorFlagsFgWhite = 7
+    fromEnum DebugColorFlagsBgBlack = 0
+    fromEnum DebugColorFlagsBgRed = 16
+    fromEnum DebugColorFlagsBgGreen = 32
+    fromEnum DebugColorFlagsBgYellow = 48
+    fromEnum DebugColorFlagsBgBlue = 64
+    fromEnum DebugColorFlagsBgMagenta = 80
+    fromEnum DebugColorFlagsBgCyan = 96
+    fromEnum DebugColorFlagsBgWhite = 112
+    fromEnum DebugColorFlagsBold = 256
+    fromEnum DebugColorFlagsUnderline = 512
+    fromEnum (AnotherDebugColorFlags k) = k
+
+    toEnum 0 = DebugColorFlagsFgBlack
+    toEnum 1 = DebugColorFlagsFgRed
+    toEnum 2 = DebugColorFlagsFgGreen
+    toEnum 3 = DebugColorFlagsFgYellow
+    toEnum 4 = DebugColorFlagsFgBlue
+    toEnum 5 = DebugColorFlagsFgMagenta
+    toEnum 6 = DebugColorFlagsFgCyan
+    toEnum 7 = DebugColorFlagsFgWhite
+    toEnum 16 = DebugColorFlagsBgRed
+    toEnum 32 = DebugColorFlagsBgGreen
+    toEnum 48 = DebugColorFlagsBgYellow
+    toEnum 64 = DebugColorFlagsBgBlue
+    toEnum 80 = DebugColorFlagsBgMagenta
+    toEnum 96 = DebugColorFlagsBgCyan
+    toEnum 112 = DebugColorFlagsBgWhite
+    toEnum 256 = DebugColorFlagsBold
+    toEnum 512 = DebugColorFlagsUnderline
+    toEnum k = AnotherDebugColorFlags k
+
+foreign import ccall "gst_debug_color_flags_get_type" c_gst_debug_color_flags_get_type :: 
+    IO GType
+
+instance BoxedEnum DebugColorFlags where
+    boxedEnumType _ = c_gst_debug_color_flags_get_type
+
+-- Enum CoreError
+
+data CoreError = 
+      CoreErrorFailed
+    | CoreErrorTooLazy
+    | CoreErrorNotImplemented
+    | CoreErrorStateChange
+    | CoreErrorPad
+    | CoreErrorThread
+    | CoreErrorNegotiation
+    | CoreErrorEvent
+    | CoreErrorSeek
+    | CoreErrorCaps
+    | CoreErrorTag
+    | CoreErrorMissingPlugin
+    | CoreErrorClock
+    | CoreErrorDisabled
+    | CoreErrorNumErrors
+    | AnotherCoreError Int
+    deriving (Show, Eq)
+
+instance Enum CoreError where
+    fromEnum CoreErrorFailed = 1
+    fromEnum CoreErrorTooLazy = 2
+    fromEnum CoreErrorNotImplemented = 3
+    fromEnum CoreErrorStateChange = 4
+    fromEnum CoreErrorPad = 5
+    fromEnum CoreErrorThread = 6
+    fromEnum CoreErrorNegotiation = 7
+    fromEnum CoreErrorEvent = 8
+    fromEnum CoreErrorSeek = 9
+    fromEnum CoreErrorCaps = 10
+    fromEnum CoreErrorTag = 11
+    fromEnum CoreErrorMissingPlugin = 12
+    fromEnum CoreErrorClock = 13
+    fromEnum CoreErrorDisabled = 14
+    fromEnum CoreErrorNumErrors = 15
+    fromEnum (AnotherCoreError k) = k
+
+    toEnum 1 = CoreErrorFailed
+    toEnum 2 = CoreErrorTooLazy
+    toEnum 3 = CoreErrorNotImplemented
+    toEnum 4 = CoreErrorStateChange
+    toEnum 5 = CoreErrorPad
+    toEnum 6 = CoreErrorThread
+    toEnum 7 = CoreErrorNegotiation
+    toEnum 8 = CoreErrorEvent
+    toEnum 9 = CoreErrorSeek
+    toEnum 10 = CoreErrorCaps
+    toEnum 11 = CoreErrorTag
+    toEnum 12 = CoreErrorMissingPlugin
+    toEnum 13 = CoreErrorClock
+    toEnum 14 = CoreErrorDisabled
+    toEnum 15 = CoreErrorNumErrors
+    toEnum k = AnotherCoreError k
+
+instance GErrorClass CoreError where
+    gerrorClassDomain _ = "gst-core-error-quark"
+
+catchCoreError ::
+    IO a ->
+    (CoreError -> GErrorMessage -> IO a) ->
+    IO a
+catchCoreError = catchGErrorJustDomain
+
+handleCoreError ::
+    (CoreError -> GErrorMessage -> IO a) ->
+    IO a ->
+    IO a
+handleCoreError = handleGErrorJustDomain
+
+foreign import ccall "gst_core_error_get_type" c_gst_core_error_get_type :: 
+    IO GType
+
+instance BoxedEnum CoreError where
+    boxedEnumType _ = c_gst_core_error_get_type
+
+-- Enum ClockType
+
+data ClockType = 
+      ClockTypeRealtime
+    | ClockTypeMonotonic
+    | ClockTypeOther
+    | AnotherClockType Int
+    deriving (Show, Eq)
+
+instance Enum ClockType where
+    fromEnum ClockTypeRealtime = 0
+    fromEnum ClockTypeMonotonic = 1
+    fromEnum ClockTypeOther = 2
+    fromEnum (AnotherClockType k) = k
+
+    toEnum 0 = ClockTypeRealtime
+    toEnum 1 = ClockTypeMonotonic
+    toEnum 2 = ClockTypeOther
+    toEnum k = AnotherClockType k
+
+foreign import ccall "gst_clock_type_get_type" c_gst_clock_type_get_type :: 
+    IO GType
+
+instance BoxedEnum ClockType where
+    boxedEnumType _ = c_gst_clock_type_get_type
+
+-- Enum ClockReturn
+
+data ClockReturn = 
+      ClockReturnOk
+    | ClockReturnEarly
+    | ClockReturnUnscheduled
+    | ClockReturnBusy
+    | ClockReturnBadtime
+    | ClockReturnError
+    | ClockReturnUnsupported
+    | ClockReturnDone
+    | AnotherClockReturn Int
+    deriving (Show, Eq)
+
+instance Enum ClockReturn where
+    fromEnum ClockReturnOk = 0
+    fromEnum ClockReturnEarly = 1
+    fromEnum ClockReturnUnscheduled = 2
+    fromEnum ClockReturnBusy = 3
+    fromEnum ClockReturnBadtime = 4
+    fromEnum ClockReturnError = 5
+    fromEnum ClockReturnUnsupported = 6
+    fromEnum ClockReturnDone = 7
+    fromEnum (AnotherClockReturn k) = k
+
+    toEnum 0 = ClockReturnOk
+    toEnum 1 = ClockReturnEarly
+    toEnum 2 = ClockReturnUnscheduled
+    toEnum 3 = ClockReturnBusy
+    toEnum 4 = ClockReturnBadtime
+    toEnum 5 = ClockReturnError
+    toEnum 6 = ClockReturnUnsupported
+    toEnum 7 = ClockReturnDone
+    toEnum k = AnotherClockReturn k
+
+foreign import ccall "gst_clock_return_get_type" c_gst_clock_return_get_type :: 
+    IO GType
+
+instance BoxedEnum ClockReturn where
+    boxedEnumType _ = c_gst_clock_return_get_type
+
+-- Enum ClockEntryType
+
+data ClockEntryType = 
+      ClockEntryTypeSingle
+    | ClockEntryTypePeriodic
+    | AnotherClockEntryType Int
+    deriving (Show, Eq)
+
+instance Enum ClockEntryType where
+    fromEnum ClockEntryTypeSingle = 0
+    fromEnum ClockEntryTypePeriodic = 1
+    fromEnum (AnotherClockEntryType k) = k
+
+    toEnum 0 = ClockEntryTypeSingle
+    toEnum 1 = ClockEntryTypePeriodic
+    toEnum k = AnotherClockEntryType k
+
+foreign import ccall "gst_clock_entry_type_get_type" c_gst_clock_entry_type_get_type :: 
+    IO GType
+
+instance BoxedEnum ClockEntryType where
+    boxedEnumType _ = c_gst_clock_entry_type_get_type
+
+-- Enum CapsIntersectMode
+
+data CapsIntersectMode = 
+      CapsIntersectModeZigZag
+    | CapsIntersectModeFirst
+    | AnotherCapsIntersectMode Int
+    deriving (Show, Eq)
+
+instance Enum CapsIntersectMode where
+    fromEnum CapsIntersectModeZigZag = 0
+    fromEnum CapsIntersectModeFirst = 1
+    fromEnum (AnotherCapsIntersectMode k) = k
+
+    toEnum 0 = CapsIntersectModeZigZag
+    toEnum 1 = CapsIntersectModeFirst
+    toEnum k = AnotherCapsIntersectMode k
+
+foreign import ccall "gst_caps_intersect_mode_get_type" c_gst_caps_intersect_mode_get_type :: 
+    IO GType
+
+instance BoxedEnum CapsIntersectMode where
+    boxedEnumType _ = c_gst_caps_intersect_mode_get_type
+
+-- Enum BusSyncReply
+
+data BusSyncReply = 
+      BusSyncReplyDrop
+    | BusSyncReplyPass
+    | BusSyncReplyAsync
+    | AnotherBusSyncReply Int
+    deriving (Show, Eq)
+
+instance Enum BusSyncReply where
+    fromEnum BusSyncReplyDrop = 0
+    fromEnum BusSyncReplyPass = 1
+    fromEnum BusSyncReplyAsync = 2
+    fromEnum (AnotherBusSyncReply k) = k
+
+    toEnum 0 = BusSyncReplyDrop
+    toEnum 1 = BusSyncReplyPass
+    toEnum 2 = BusSyncReplyAsync
+    toEnum k = AnotherBusSyncReply k
+
+foreign import ccall "gst_bus_sync_reply_get_type" c_gst_bus_sync_reply_get_type :: 
+    IO GType
+
+instance BoxedEnum BusSyncReply where
+    boxedEnumType _ = c_gst_bus_sync_reply_get_type
+
+-- Enum BufferingMode
+
+data BufferingMode = 
+      BufferingModeStream
+    | BufferingModeDownload
+    | BufferingModeTimeshift
+    | BufferingModeLive
+    | AnotherBufferingMode Int
+    deriving (Show, Eq)
+
+instance Enum BufferingMode where
+    fromEnum BufferingModeStream = 0
+    fromEnum BufferingModeDownload = 1
+    fromEnum BufferingModeTimeshift = 2
+    fromEnum BufferingModeLive = 3
+    fromEnum (AnotherBufferingMode k) = k
+
+    toEnum 0 = BufferingModeStream
+    toEnum 1 = BufferingModeDownload
+    toEnum 2 = BufferingModeTimeshift
+    toEnum 3 = BufferingModeLive
+    toEnum k = AnotherBufferingMode k
+
+foreign import ccall "gst_buffering_mode_get_type" c_gst_buffering_mode_get_type :: 
+    IO GType
+
+instance BoxedEnum BufferingMode where
+    boxedEnumType _ = c_gst_buffering_mode_get_type
+
+
diff --git a/GI/Gst/Flags.hs b/GI/Gst/Flags.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Flags.hs
@@ -0,0 +1,1244 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+-}
+
+module GI.Gst.Flags
+    ( 
+
+-- * Exported types
+    StreamFlags(..)                         ,
+    SegmentFlags(..)                        ,
+    SeekFlags(..)                           ,
+    SchedulingFlags(..)                     ,
+    QueryTypeFlags(..)                      ,
+    PluginFlags(..)                         ,
+    PluginDependencyFlags(..)               ,
+    PipelineFlags(..)                       ,
+    ParseFlags(..)                          ,
+    PadTemplateFlags(..)                    ,
+    PadProbeType(..)                        ,
+    PadLinkCheck(..)                        ,
+    PadFlags(..)                            ,
+    ObjectFlags(..)                         ,
+    MiniObjectFlags(..)                     ,
+    MetaFlags(..)                           ,
+    MessageType(..)                         ,
+    MemoryFlags(..)                         ,
+    MapFlags(..)                            ,
+    LockFlags(..)                           ,
+    EventTypeFlags(..)                      ,
+    ElementFlags(..)                        ,
+    DebugGraphDetails(..)                   ,
+    ClockFlags(..)                          ,
+    CapsFlags(..)                           ,
+    BusFlags(..)                            ,
+    BufferPoolAcquireFlags(..)              ,
+    BufferFlags(..)                         ,
+    BufferCopyFlags(..)                     ,
+    BinFlags(..)                            ,
+    AllocatorFlags(..)                      ,
+
+
+    ) where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+
+
+
+-- Flags StreamFlags
+
+data StreamFlags = 
+      StreamFlagsNone
+    | StreamFlagsSparse
+    | StreamFlagsSelect
+    | StreamFlagsUnselect
+    | AnotherStreamFlags Int
+    deriving (Show, Eq)
+
+instance Enum StreamFlags where
+    fromEnum StreamFlagsNone = 0
+    fromEnum StreamFlagsSparse = 1
+    fromEnum StreamFlagsSelect = 2
+    fromEnum StreamFlagsUnselect = 4
+    fromEnum (AnotherStreamFlags k) = k
+
+    toEnum 0 = StreamFlagsNone
+    toEnum 1 = StreamFlagsSparse
+    toEnum 2 = StreamFlagsSelect
+    toEnum 4 = StreamFlagsUnselect
+    toEnum k = AnotherStreamFlags k
+
+foreign import ccall "gst_stream_flags_get_type" c_gst_stream_flags_get_type :: 
+    IO GType
+
+instance BoxedEnum StreamFlags where
+    boxedEnumType _ = c_gst_stream_flags_get_type
+
+instance IsGFlag StreamFlags
+
+-- Flags SegmentFlags
+
+data SegmentFlags = 
+      SegmentFlagsNone
+    | SegmentFlagsReset
+    | SegmentFlagsTrickmode
+    | SegmentFlagsSkip
+    | SegmentFlagsSegment
+    | SegmentFlagsTrickmodeKeyUnits
+    | SegmentFlagsTrickmodeNoAudio
+    | AnotherSegmentFlags Int
+    deriving (Show, Eq)
+
+instance Enum SegmentFlags where
+    fromEnum SegmentFlagsNone = 0
+    fromEnum SegmentFlagsReset = 1
+    fromEnum SegmentFlagsTrickmode = 16
+    fromEnum SegmentFlagsSkip = 16
+    fromEnum SegmentFlagsSegment = 8
+    fromEnum SegmentFlagsTrickmodeKeyUnits = 128
+    fromEnum SegmentFlagsTrickmodeNoAudio = 256
+    fromEnum (AnotherSegmentFlags k) = k
+
+    toEnum 0 = SegmentFlagsNone
+    toEnum 1 = SegmentFlagsReset
+    toEnum 8 = SegmentFlagsSegment
+    toEnum 16 = SegmentFlagsTrickmode
+    toEnum 128 = SegmentFlagsTrickmodeKeyUnits
+    toEnum 256 = SegmentFlagsTrickmodeNoAudio
+    toEnum k = AnotherSegmentFlags k
+
+foreign import ccall "gst_segment_flags_get_type" c_gst_segment_flags_get_type :: 
+    IO GType
+
+instance BoxedEnum SegmentFlags where
+    boxedEnumType _ = c_gst_segment_flags_get_type
+
+instance IsGFlag SegmentFlags
+
+-- Flags SeekFlags
+
+data SeekFlags = 
+      SeekFlagsNone
+    | SeekFlagsFlush
+    | SeekFlagsAccurate
+    | SeekFlagsKeyUnit
+    | SeekFlagsSegment
+    | SeekFlagsTrickmode
+    | SeekFlagsSkip
+    | SeekFlagsSnapBefore
+    | SeekFlagsSnapAfter
+    | SeekFlagsSnapNearest
+    | SeekFlagsTrickmodeKeyUnits
+    | SeekFlagsTrickmodeNoAudio
+    | AnotherSeekFlags Int
+    deriving (Show, Eq)
+
+instance Enum SeekFlags where
+    fromEnum SeekFlagsNone = 0
+    fromEnum SeekFlagsFlush = 1
+    fromEnum SeekFlagsAccurate = 2
+    fromEnum SeekFlagsKeyUnit = 4
+    fromEnum SeekFlagsSegment = 8
+    fromEnum SeekFlagsTrickmode = 16
+    fromEnum SeekFlagsSkip = 16
+    fromEnum SeekFlagsSnapBefore = 32
+    fromEnum SeekFlagsSnapAfter = 64
+    fromEnum SeekFlagsSnapNearest = 96
+    fromEnum SeekFlagsTrickmodeKeyUnits = 128
+    fromEnum SeekFlagsTrickmodeNoAudio = 256
+    fromEnum (AnotherSeekFlags k) = k
+
+    toEnum 0 = SeekFlagsNone
+    toEnum 1 = SeekFlagsFlush
+    toEnum 2 = SeekFlagsAccurate
+    toEnum 4 = SeekFlagsKeyUnit
+    toEnum 8 = SeekFlagsSegment
+    toEnum 16 = SeekFlagsTrickmode
+    toEnum 32 = SeekFlagsSnapBefore
+    toEnum 64 = SeekFlagsSnapAfter
+    toEnum 96 = SeekFlagsSnapNearest
+    toEnum 128 = SeekFlagsTrickmodeKeyUnits
+    toEnum 256 = SeekFlagsTrickmodeNoAudio
+    toEnum k = AnotherSeekFlags k
+
+foreign import ccall "gst_seek_flags_get_type" c_gst_seek_flags_get_type :: 
+    IO GType
+
+instance BoxedEnum SeekFlags where
+    boxedEnumType _ = c_gst_seek_flags_get_type
+
+instance IsGFlag SeekFlags
+
+-- Flags SchedulingFlags
+
+data SchedulingFlags = 
+      SchedulingFlagsSeekable
+    | SchedulingFlagsSequential
+    | SchedulingFlagsBandwidthLimited
+    | AnotherSchedulingFlags Int
+    deriving (Show, Eq)
+
+instance Enum SchedulingFlags where
+    fromEnum SchedulingFlagsSeekable = 1
+    fromEnum SchedulingFlagsSequential = 2
+    fromEnum SchedulingFlagsBandwidthLimited = 4
+    fromEnum (AnotherSchedulingFlags k) = k
+
+    toEnum 1 = SchedulingFlagsSeekable
+    toEnum 2 = SchedulingFlagsSequential
+    toEnum 4 = SchedulingFlagsBandwidthLimited
+    toEnum k = AnotherSchedulingFlags k
+
+foreign import ccall "gst_scheduling_flags_get_type" c_gst_scheduling_flags_get_type :: 
+    IO GType
+
+instance BoxedEnum SchedulingFlags where
+    boxedEnumType _ = c_gst_scheduling_flags_get_type
+
+instance IsGFlag SchedulingFlags
+
+-- Flags QueryTypeFlags
+
+data QueryTypeFlags = 
+      QueryTypeFlagsUpstream
+    | QueryTypeFlagsDownstream
+    | QueryTypeFlagsSerialized
+    | AnotherQueryTypeFlags Int
+    deriving (Show, Eq)
+
+instance Enum QueryTypeFlags where
+    fromEnum QueryTypeFlagsUpstream = 1
+    fromEnum QueryTypeFlagsDownstream = 2
+    fromEnum QueryTypeFlagsSerialized = 4
+    fromEnum (AnotherQueryTypeFlags k) = k
+
+    toEnum 1 = QueryTypeFlagsUpstream
+    toEnum 2 = QueryTypeFlagsDownstream
+    toEnum 4 = QueryTypeFlagsSerialized
+    toEnum k = AnotherQueryTypeFlags k
+
+foreign import ccall "gst_query_type_flags_get_type" c_gst_query_type_flags_get_type :: 
+    IO GType
+
+instance BoxedEnum QueryTypeFlags where
+    boxedEnumType _ = c_gst_query_type_flags_get_type
+
+instance IsGFlag QueryTypeFlags
+
+-- Flags PluginFlags
+
+data PluginFlags = 
+      PluginFlagsCached
+    | PluginFlagsBlacklisted
+    | AnotherPluginFlags Int
+    deriving (Show, Eq)
+
+instance Enum PluginFlags where
+    fromEnum PluginFlagsCached = 16
+    fromEnum PluginFlagsBlacklisted = 32
+    fromEnum (AnotherPluginFlags k) = k
+
+    toEnum 16 = PluginFlagsCached
+    toEnum 32 = PluginFlagsBlacklisted
+    toEnum k = AnotherPluginFlags k
+
+foreign import ccall "gst_plugin_flags_get_type" c_gst_plugin_flags_get_type :: 
+    IO GType
+
+instance BoxedEnum PluginFlags where
+    boxedEnumType _ = c_gst_plugin_flags_get_type
+
+instance IsGFlag PluginFlags
+
+-- Flags PluginDependencyFlags
+
+data PluginDependencyFlags = 
+      PluginDependencyFlagsNone
+    | PluginDependencyFlagsRecurse
+    | PluginDependencyFlagsPathsAreDefaultOnly
+    | PluginDependencyFlagsFileNameIsSuffix
+    | AnotherPluginDependencyFlags Int
+    deriving (Show, Eq)
+
+instance Enum PluginDependencyFlags where
+    fromEnum PluginDependencyFlagsNone = 0
+    fromEnum PluginDependencyFlagsRecurse = 1
+    fromEnum PluginDependencyFlagsPathsAreDefaultOnly = 2
+    fromEnum PluginDependencyFlagsFileNameIsSuffix = 4
+    fromEnum (AnotherPluginDependencyFlags k) = k
+
+    toEnum 0 = PluginDependencyFlagsNone
+    toEnum 1 = PluginDependencyFlagsRecurse
+    toEnum 2 = PluginDependencyFlagsPathsAreDefaultOnly
+    toEnum 4 = PluginDependencyFlagsFileNameIsSuffix
+    toEnum k = AnotherPluginDependencyFlags k
+
+foreign import ccall "gst_plugin_dependency_flags_get_type" c_gst_plugin_dependency_flags_get_type :: 
+    IO GType
+
+instance BoxedEnum PluginDependencyFlags where
+    boxedEnumType _ = c_gst_plugin_dependency_flags_get_type
+
+instance IsGFlag PluginDependencyFlags
+
+-- Flags PipelineFlags
+
+data PipelineFlags = 
+      PipelineFlagsFixedClock
+    | PipelineFlagsLast
+    | AnotherPipelineFlags Int
+    deriving (Show, Eq)
+
+instance Enum PipelineFlags where
+    fromEnum PipelineFlagsFixedClock = 524288
+    fromEnum PipelineFlagsLast = 8388608
+    fromEnum (AnotherPipelineFlags k) = k
+
+    toEnum 524288 = PipelineFlagsFixedClock
+    toEnum 8388608 = PipelineFlagsLast
+    toEnum k = AnotherPipelineFlags k
+
+foreign import ccall "gst_pipeline_flags_get_type" c_gst_pipeline_flags_get_type :: 
+    IO GType
+
+instance BoxedEnum PipelineFlags where
+    boxedEnumType _ = c_gst_pipeline_flags_get_type
+
+instance IsGFlag PipelineFlags
+
+-- Flags ParseFlags
+
+data ParseFlags = 
+      ParseFlagsNone
+    | ParseFlagsFatalErrors
+    | ParseFlagsNoSingleElementBins
+    | AnotherParseFlags Int
+    deriving (Show, Eq)
+
+instance Enum ParseFlags where
+    fromEnum ParseFlagsNone = 0
+    fromEnum ParseFlagsFatalErrors = 1
+    fromEnum ParseFlagsNoSingleElementBins = 2
+    fromEnum (AnotherParseFlags k) = k
+
+    toEnum 0 = ParseFlagsNone
+    toEnum 1 = ParseFlagsFatalErrors
+    toEnum 2 = ParseFlagsNoSingleElementBins
+    toEnum k = AnotherParseFlags k
+
+foreign import ccall "gst_parse_flags_get_type" c_gst_parse_flags_get_type :: 
+    IO GType
+
+instance BoxedEnum ParseFlags where
+    boxedEnumType _ = c_gst_parse_flags_get_type
+
+instance IsGFlag ParseFlags
+
+-- Flags PadTemplateFlags
+
+data PadTemplateFlags = 
+      PadTemplateFlagsLast
+    | AnotherPadTemplateFlags Int
+    deriving (Show, Eq)
+
+instance Enum PadTemplateFlags where
+    fromEnum PadTemplateFlagsLast = 256
+    fromEnum (AnotherPadTemplateFlags k) = k
+
+    toEnum 256 = PadTemplateFlagsLast
+    toEnum k = AnotherPadTemplateFlags k
+
+foreign import ccall "gst_pad_template_flags_get_type" c_gst_pad_template_flags_get_type :: 
+    IO GType
+
+instance BoxedEnum PadTemplateFlags where
+    boxedEnumType _ = c_gst_pad_template_flags_get_type
+
+instance IsGFlag PadTemplateFlags
+
+-- Flags PadProbeType
+
+data PadProbeType = 
+      PadProbeTypeInvalid
+    | PadProbeTypeIdle
+    | PadProbeTypeBlock
+    | PadProbeTypeBuffer
+    | PadProbeTypeBufferList
+    | PadProbeTypeEventDownstream
+    | PadProbeTypeEventUpstream
+    | PadProbeTypeEventFlush
+    | PadProbeTypeQueryDownstream
+    | PadProbeTypeQueryUpstream
+    | PadProbeTypePush
+    | PadProbeTypePull
+    | PadProbeTypeBlocking
+    | PadProbeTypeDataDownstream
+    | PadProbeTypeDataUpstream
+    | PadProbeTypeDataBoth
+    | PadProbeTypeBlockDownstream
+    | PadProbeTypeBlockUpstream
+    | PadProbeTypeEventBoth
+    | PadProbeTypeQueryBoth
+    | PadProbeTypeAllBoth
+    | PadProbeTypeScheduling
+    | AnotherPadProbeType Int
+    deriving (Show, Eq)
+
+instance Enum PadProbeType where
+    fromEnum PadProbeTypeInvalid = 0
+    fromEnum PadProbeTypeIdle = 1
+    fromEnum PadProbeTypeBlock = 2
+    fromEnum PadProbeTypeBuffer = 16
+    fromEnum PadProbeTypeBufferList = 32
+    fromEnum PadProbeTypeEventDownstream = 64
+    fromEnum PadProbeTypeEventUpstream = 128
+    fromEnum PadProbeTypeEventFlush = 256
+    fromEnum PadProbeTypeQueryDownstream = 512
+    fromEnum PadProbeTypeQueryUpstream = 1024
+    fromEnum PadProbeTypePush = 4096
+    fromEnum PadProbeTypePull = 8192
+    fromEnum PadProbeTypeBlocking = 3
+    fromEnum PadProbeTypeDataDownstream = 112
+    fromEnum PadProbeTypeDataUpstream = 128
+    fromEnum PadProbeTypeDataBoth = 240
+    fromEnum PadProbeTypeBlockDownstream = 114
+    fromEnum PadProbeTypeBlockUpstream = 130
+    fromEnum PadProbeTypeEventBoth = 192
+    fromEnum PadProbeTypeQueryBoth = 1536
+    fromEnum PadProbeTypeAllBoth = 1776
+    fromEnum PadProbeTypeScheduling = 12288
+    fromEnum (AnotherPadProbeType k) = k
+
+    toEnum 0 = PadProbeTypeInvalid
+    toEnum 1 = PadProbeTypeIdle
+    toEnum 2 = PadProbeTypeBlock
+    toEnum 3 = PadProbeTypeBlocking
+    toEnum 16 = PadProbeTypeBuffer
+    toEnum 32 = PadProbeTypeBufferList
+    toEnum 64 = PadProbeTypeEventDownstream
+    toEnum 112 = PadProbeTypeDataDownstream
+    toEnum 114 = PadProbeTypeBlockDownstream
+    toEnum 128 = PadProbeTypeEventUpstream
+    toEnum 130 = PadProbeTypeBlockUpstream
+    toEnum 192 = PadProbeTypeEventBoth
+    toEnum 240 = PadProbeTypeDataBoth
+    toEnum 256 = PadProbeTypeEventFlush
+    toEnum 512 = PadProbeTypeQueryDownstream
+    toEnum 1024 = PadProbeTypeQueryUpstream
+    toEnum 1536 = PadProbeTypeQueryBoth
+    toEnum 1776 = PadProbeTypeAllBoth
+    toEnum 4096 = PadProbeTypePush
+    toEnum 8192 = PadProbeTypePull
+    toEnum 12288 = PadProbeTypeScheduling
+    toEnum k = AnotherPadProbeType k
+
+foreign import ccall "gst_pad_probe_type_get_type" c_gst_pad_probe_type_get_type :: 
+    IO GType
+
+instance BoxedEnum PadProbeType where
+    boxedEnumType _ = c_gst_pad_probe_type_get_type
+
+instance IsGFlag PadProbeType
+
+-- Flags PadLinkCheck
+
+data PadLinkCheck = 
+      PadLinkCheckNothing
+    | PadLinkCheckHierarchy
+    | PadLinkCheckTemplateCaps
+    | PadLinkCheckCaps
+    | PadLinkCheckDefault
+    | AnotherPadLinkCheck Int
+    deriving (Show, Eq)
+
+instance Enum PadLinkCheck where
+    fromEnum PadLinkCheckNothing = 0
+    fromEnum PadLinkCheckHierarchy = 1
+    fromEnum PadLinkCheckTemplateCaps = 2
+    fromEnum PadLinkCheckCaps = 4
+    fromEnum PadLinkCheckDefault = 5
+    fromEnum (AnotherPadLinkCheck k) = k
+
+    toEnum 0 = PadLinkCheckNothing
+    toEnum 1 = PadLinkCheckHierarchy
+    toEnum 2 = PadLinkCheckTemplateCaps
+    toEnum 4 = PadLinkCheckCaps
+    toEnum 5 = PadLinkCheckDefault
+    toEnum k = AnotherPadLinkCheck k
+
+foreign import ccall "gst_pad_link_check_get_type" c_gst_pad_link_check_get_type :: 
+    IO GType
+
+instance BoxedEnum PadLinkCheck where
+    boxedEnumType _ = c_gst_pad_link_check_get_type
+
+instance IsGFlag PadLinkCheck
+
+-- Flags PadFlags
+
+data PadFlags = 
+      PadFlagsBlocked
+    | PadFlagsFlushing
+    | PadFlagsEos
+    | PadFlagsBlocking
+    | PadFlagsNeedParent
+    | PadFlagsNeedReconfigure
+    | PadFlagsPendingEvents
+    | PadFlagsFixedCaps
+    | PadFlagsProxyCaps
+    | PadFlagsProxyAllocation
+    | PadFlagsProxyScheduling
+    | PadFlagsAcceptIntersect
+    | PadFlagsAcceptTemplate
+    | PadFlagsLast
+    | AnotherPadFlags Int
+    deriving (Show, Eq)
+
+instance Enum PadFlags where
+    fromEnum PadFlagsBlocked = 16
+    fromEnum PadFlagsFlushing = 32
+    fromEnum PadFlagsEos = 64
+    fromEnum PadFlagsBlocking = 128
+    fromEnum PadFlagsNeedParent = 256
+    fromEnum PadFlagsNeedReconfigure = 512
+    fromEnum PadFlagsPendingEvents = 1024
+    fromEnum PadFlagsFixedCaps = 2048
+    fromEnum PadFlagsProxyCaps = 4096
+    fromEnum PadFlagsProxyAllocation = 8192
+    fromEnum PadFlagsProxyScheduling = 16384
+    fromEnum PadFlagsAcceptIntersect = 32768
+    fromEnum PadFlagsAcceptTemplate = 65536
+    fromEnum PadFlagsLast = 1048576
+    fromEnum (AnotherPadFlags k) = k
+
+    toEnum 16 = PadFlagsBlocked
+    toEnum 32 = PadFlagsFlushing
+    toEnum 64 = PadFlagsEos
+    toEnum 128 = PadFlagsBlocking
+    toEnum 256 = PadFlagsNeedParent
+    toEnum 512 = PadFlagsNeedReconfigure
+    toEnum 1024 = PadFlagsPendingEvents
+    toEnum 2048 = PadFlagsFixedCaps
+    toEnum 4096 = PadFlagsProxyCaps
+    toEnum 8192 = PadFlagsProxyAllocation
+    toEnum 16384 = PadFlagsProxyScheduling
+    toEnum 32768 = PadFlagsAcceptIntersect
+    toEnum 65536 = PadFlagsAcceptTemplate
+    toEnum 1048576 = PadFlagsLast
+    toEnum k = AnotherPadFlags k
+
+foreign import ccall "gst_pad_flags_get_type" c_gst_pad_flags_get_type :: 
+    IO GType
+
+instance BoxedEnum PadFlags where
+    boxedEnumType _ = c_gst_pad_flags_get_type
+
+instance IsGFlag PadFlags
+
+-- Flags ObjectFlags
+
+data ObjectFlags = 
+      ObjectFlagsLast
+    | AnotherObjectFlags Int
+    deriving (Show, Eq)
+
+instance Enum ObjectFlags where
+    fromEnum ObjectFlagsLast = 16
+    fromEnum (AnotherObjectFlags k) = k
+
+    toEnum 16 = ObjectFlagsLast
+    toEnum k = AnotherObjectFlags k
+
+foreign import ccall "gst_object_flags_get_type" c_gst_object_flags_get_type :: 
+    IO GType
+
+instance BoxedEnum ObjectFlags where
+    boxedEnumType _ = c_gst_object_flags_get_type
+
+instance IsGFlag ObjectFlags
+
+-- Flags MiniObjectFlags
+
+data MiniObjectFlags = 
+      MiniObjectFlagsLockable
+    | MiniObjectFlagsLockReadonly
+    | MiniObjectFlagsLast
+    | AnotherMiniObjectFlags Int
+    deriving (Show, Eq)
+
+instance Enum MiniObjectFlags where
+    fromEnum MiniObjectFlagsLockable = 1
+    fromEnum MiniObjectFlagsLockReadonly = 2
+    fromEnum MiniObjectFlagsLast = 16
+    fromEnum (AnotherMiniObjectFlags k) = k
+
+    toEnum 1 = MiniObjectFlagsLockable
+    toEnum 2 = MiniObjectFlagsLockReadonly
+    toEnum 16 = MiniObjectFlagsLast
+    toEnum k = AnotherMiniObjectFlags k
+
+foreign import ccall "gst_mini_object_flags_get_type" c_gst_mini_object_flags_get_type :: 
+    IO GType
+
+instance BoxedEnum MiniObjectFlags where
+    boxedEnumType _ = c_gst_mini_object_flags_get_type
+
+instance IsGFlag MiniObjectFlags
+
+-- Flags MetaFlags
+
+data MetaFlags = 
+      MetaFlagsNone
+    | MetaFlagsReadonly
+    | MetaFlagsPooled
+    | MetaFlagsLocked
+    | MetaFlagsLast
+    | AnotherMetaFlags Int
+    deriving (Show, Eq)
+
+instance Enum MetaFlags where
+    fromEnum MetaFlagsNone = 0
+    fromEnum MetaFlagsReadonly = 1
+    fromEnum MetaFlagsPooled = 2
+    fromEnum MetaFlagsLocked = 4
+    fromEnum MetaFlagsLast = 65536
+    fromEnum (AnotherMetaFlags k) = k
+
+    toEnum 0 = MetaFlagsNone
+    toEnum 1 = MetaFlagsReadonly
+    toEnum 2 = MetaFlagsPooled
+    toEnum 4 = MetaFlagsLocked
+    toEnum 65536 = MetaFlagsLast
+    toEnum k = AnotherMetaFlags k
+
+foreign import ccall "gst_meta_flags_get_type" c_gst_meta_flags_get_type :: 
+    IO GType
+
+instance BoxedEnum MetaFlags where
+    boxedEnumType _ = c_gst_meta_flags_get_type
+
+instance IsGFlag MetaFlags
+
+-- Flags MessageType
+
+data MessageType = 
+      MessageTypeUnknown
+    | MessageTypeEos
+    | MessageTypeError
+    | MessageTypeWarning
+    | MessageTypeInfo
+    | MessageTypeTag
+    | MessageTypeBuffering
+    | MessageTypeStateChanged
+    | MessageTypeStateDirty
+    | MessageTypeStepDone
+    | MessageTypeClockProvide
+    | MessageTypeClockLost
+    | MessageTypeNewClock
+    | MessageTypeStructureChange
+    | MessageTypeStreamStatus
+    | MessageTypeApplication
+    | MessageTypeElement
+    | MessageTypeSegmentStart
+    | MessageTypeSegmentDone
+    | MessageTypeDurationChanged
+    | MessageTypeLatency
+    | MessageTypeAsyncStart
+    | MessageTypeAsyncDone
+    | MessageTypeRequestState
+    | MessageTypeStepStart
+    | MessageTypeQos
+    | MessageTypeProgress
+    | MessageTypeToc
+    | MessageTypeResetTime
+    | MessageTypeStreamStart
+    | MessageTypeNeedContext
+    | MessageTypeHaveContext
+    | MessageTypeExtended
+    | MessageTypeDeviceAdded
+    | MessageTypeDeviceRemoved
+    | MessageTypeAny
+    | AnotherMessageType Int
+    deriving (Show, Eq)
+
+instance Enum MessageType where
+    fromEnum MessageTypeUnknown = 0
+    fromEnum MessageTypeEos = 1
+    fromEnum MessageTypeError = 2
+    fromEnum MessageTypeWarning = 4
+    fromEnum MessageTypeInfo = 8
+    fromEnum MessageTypeTag = 16
+    fromEnum MessageTypeBuffering = 32
+    fromEnum MessageTypeStateChanged = 64
+    fromEnum MessageTypeStateDirty = 128
+    fromEnum MessageTypeStepDone = 256
+    fromEnum MessageTypeClockProvide = 512
+    fromEnum MessageTypeClockLost = 1024
+    fromEnum MessageTypeNewClock = 2048
+    fromEnum MessageTypeStructureChange = 4096
+    fromEnum MessageTypeStreamStatus = 8192
+    fromEnum MessageTypeApplication = 16384
+    fromEnum MessageTypeElement = 32768
+    fromEnum MessageTypeSegmentStart = 65536
+    fromEnum MessageTypeSegmentDone = 131072
+    fromEnum MessageTypeDurationChanged = 262144
+    fromEnum MessageTypeLatency = 524288
+    fromEnum MessageTypeAsyncStart = 1048576
+    fromEnum MessageTypeAsyncDone = 2097152
+    fromEnum MessageTypeRequestState = 4194304
+    fromEnum MessageTypeStepStart = 8388608
+    fromEnum MessageTypeQos = 16777216
+    fromEnum MessageTypeProgress = 33554432
+    fromEnum MessageTypeToc = 67108864
+    fromEnum MessageTypeResetTime = 134217728
+    fromEnum MessageTypeStreamStart = 268435456
+    fromEnum MessageTypeNeedContext = 536870912
+    fromEnum MessageTypeHaveContext = 1073741824
+    fromEnum MessageTypeExtended = 2147483648
+    fromEnum MessageTypeDeviceAdded = 2147483649
+    fromEnum MessageTypeDeviceRemoved = 2147483650
+    fromEnum MessageTypeAny = 4294967295
+    fromEnum (AnotherMessageType k) = k
+
+    toEnum 0 = MessageTypeUnknown
+    toEnum 1 = MessageTypeEos
+    toEnum 2 = MessageTypeError
+    toEnum 4 = MessageTypeWarning
+    toEnum 8 = MessageTypeInfo
+    toEnum 16 = MessageTypeTag
+    toEnum 32 = MessageTypeBuffering
+    toEnum 64 = MessageTypeStateChanged
+    toEnum 128 = MessageTypeStateDirty
+    toEnum 256 = MessageTypeStepDone
+    toEnum 512 = MessageTypeClockProvide
+    toEnum 1024 = MessageTypeClockLost
+    toEnum 2048 = MessageTypeNewClock
+    toEnum 4096 = MessageTypeStructureChange
+    toEnum 8192 = MessageTypeStreamStatus
+    toEnum 16384 = MessageTypeApplication
+    toEnum 32768 = MessageTypeElement
+    toEnum 65536 = MessageTypeSegmentStart
+    toEnum 131072 = MessageTypeSegmentDone
+    toEnum 262144 = MessageTypeDurationChanged
+    toEnum 524288 = MessageTypeLatency
+    toEnum 1048576 = MessageTypeAsyncStart
+    toEnum 2097152 = MessageTypeAsyncDone
+    toEnum 4194304 = MessageTypeRequestState
+    toEnum 8388608 = MessageTypeStepStart
+    toEnum 16777216 = MessageTypeQos
+    toEnum 33554432 = MessageTypeProgress
+    toEnum 67108864 = MessageTypeToc
+    toEnum 134217728 = MessageTypeResetTime
+    toEnum 268435456 = MessageTypeStreamStart
+    toEnum 536870912 = MessageTypeNeedContext
+    toEnum 1073741824 = MessageTypeHaveContext
+    toEnum 2147483648 = MessageTypeExtended
+    toEnum 2147483649 = MessageTypeDeviceAdded
+    toEnum 2147483650 = MessageTypeDeviceRemoved
+    toEnum 4294967295 = MessageTypeAny
+    toEnum k = AnotherMessageType k
+
+foreign import ccall "gst_message_type_get_type" c_gst_message_type_get_type :: 
+    IO GType
+
+instance BoxedEnum MessageType where
+    boxedEnumType _ = c_gst_message_type_get_type
+
+instance IsGFlag MessageType
+
+-- Flags MemoryFlags
+
+data MemoryFlags = 
+      MemoryFlagsReadonly
+    | MemoryFlagsNoShare
+    | MemoryFlagsZeroPrefixed
+    | MemoryFlagsZeroPadded
+    | MemoryFlagsPhysicallyContiguous
+    | MemoryFlagsNotMappable
+    | MemoryFlagsLast
+    | AnotherMemoryFlags Int
+    deriving (Show, Eq)
+
+instance Enum MemoryFlags where
+    fromEnum MemoryFlagsReadonly = 2
+    fromEnum MemoryFlagsNoShare = 16
+    fromEnum MemoryFlagsZeroPrefixed = 32
+    fromEnum MemoryFlagsZeroPadded = 64
+    fromEnum MemoryFlagsPhysicallyContiguous = 128
+    fromEnum MemoryFlagsNotMappable = 256
+    fromEnum MemoryFlagsLast = 1048576
+    fromEnum (AnotherMemoryFlags k) = k
+
+    toEnum 2 = MemoryFlagsReadonly
+    toEnum 16 = MemoryFlagsNoShare
+    toEnum 32 = MemoryFlagsZeroPrefixed
+    toEnum 64 = MemoryFlagsZeroPadded
+    toEnum 128 = MemoryFlagsPhysicallyContiguous
+    toEnum 256 = MemoryFlagsNotMappable
+    toEnum 1048576 = MemoryFlagsLast
+    toEnum k = AnotherMemoryFlags k
+
+foreign import ccall "gst_memory_flags_get_type" c_gst_memory_flags_get_type :: 
+    IO GType
+
+instance BoxedEnum MemoryFlags where
+    boxedEnumType _ = c_gst_memory_flags_get_type
+
+instance IsGFlag MemoryFlags
+
+-- Flags MapFlags
+
+data MapFlags = 
+      MapFlagsRead
+    | MapFlagsWrite
+    | MapFlagsFlagLast
+    | AnotherMapFlags Int
+    deriving (Show, Eq)
+
+instance Enum MapFlags where
+    fromEnum MapFlagsRead = 1
+    fromEnum MapFlagsWrite = 2
+    fromEnum MapFlagsFlagLast = 65536
+    fromEnum (AnotherMapFlags k) = k
+
+    toEnum 1 = MapFlagsRead
+    toEnum 2 = MapFlagsWrite
+    toEnum 65536 = MapFlagsFlagLast
+    toEnum k = AnotherMapFlags k
+
+foreign import ccall "gst_map_flags_get_type" c_gst_map_flags_get_type :: 
+    IO GType
+
+instance BoxedEnum MapFlags where
+    boxedEnumType _ = c_gst_map_flags_get_type
+
+instance IsGFlag MapFlags
+
+-- Flags LockFlags
+
+data LockFlags = 
+      LockFlagsRead
+    | LockFlagsWrite
+    | LockFlagsExclusive
+    | LockFlagsLast
+    | AnotherLockFlags Int
+    deriving (Show, Eq)
+
+instance Enum LockFlags where
+    fromEnum LockFlagsRead = 1
+    fromEnum LockFlagsWrite = 2
+    fromEnum LockFlagsExclusive = 4
+    fromEnum LockFlagsLast = 256
+    fromEnum (AnotherLockFlags k) = k
+
+    toEnum 1 = LockFlagsRead
+    toEnum 2 = LockFlagsWrite
+    toEnum 4 = LockFlagsExclusive
+    toEnum 256 = LockFlagsLast
+    toEnum k = AnotherLockFlags k
+
+foreign import ccall "gst_lock_flags_get_type" c_gst_lock_flags_get_type :: 
+    IO GType
+
+instance BoxedEnum LockFlags where
+    boxedEnumType _ = c_gst_lock_flags_get_type
+
+instance IsGFlag LockFlags
+
+-- Flags EventTypeFlags
+
+data EventTypeFlags = 
+      EventTypeFlagsUpstream
+    | EventTypeFlagsDownstream
+    | EventTypeFlagsSerialized
+    | EventTypeFlagsSticky
+    | EventTypeFlagsStickyMulti
+    | AnotherEventTypeFlags Int
+    deriving (Show, Eq)
+
+instance Enum EventTypeFlags where
+    fromEnum EventTypeFlagsUpstream = 1
+    fromEnum EventTypeFlagsDownstream = 2
+    fromEnum EventTypeFlagsSerialized = 4
+    fromEnum EventTypeFlagsSticky = 8
+    fromEnum EventTypeFlagsStickyMulti = 16
+    fromEnum (AnotherEventTypeFlags k) = k
+
+    toEnum 1 = EventTypeFlagsUpstream
+    toEnum 2 = EventTypeFlagsDownstream
+    toEnum 4 = EventTypeFlagsSerialized
+    toEnum 8 = EventTypeFlagsSticky
+    toEnum 16 = EventTypeFlagsStickyMulti
+    toEnum k = AnotherEventTypeFlags k
+
+foreign import ccall "gst_event_type_flags_get_type" c_gst_event_type_flags_get_type :: 
+    IO GType
+
+instance BoxedEnum EventTypeFlags where
+    boxedEnumType _ = c_gst_event_type_flags_get_type
+
+instance IsGFlag EventTypeFlags
+
+-- Flags ElementFlags
+
+data ElementFlags = 
+      ElementFlagsLockedState
+    | ElementFlagsSink
+    | ElementFlagsSource
+    | ElementFlagsProvideClock
+    | ElementFlagsRequireClock
+    | ElementFlagsIndexable
+    | ElementFlagsLast
+    | AnotherElementFlags Int
+    deriving (Show, Eq)
+
+instance Enum ElementFlags where
+    fromEnum ElementFlagsLockedState = 16
+    fromEnum ElementFlagsSink = 32
+    fromEnum ElementFlagsSource = 64
+    fromEnum ElementFlagsProvideClock = 128
+    fromEnum ElementFlagsRequireClock = 256
+    fromEnum ElementFlagsIndexable = 512
+    fromEnum ElementFlagsLast = 16384
+    fromEnum (AnotherElementFlags k) = k
+
+    toEnum 16 = ElementFlagsLockedState
+    toEnum 32 = ElementFlagsSink
+    toEnum 64 = ElementFlagsSource
+    toEnum 128 = ElementFlagsProvideClock
+    toEnum 256 = ElementFlagsRequireClock
+    toEnum 512 = ElementFlagsIndexable
+    toEnum 16384 = ElementFlagsLast
+    toEnum k = AnotherElementFlags k
+
+foreign import ccall "gst_element_flags_get_type" c_gst_element_flags_get_type :: 
+    IO GType
+
+instance BoxedEnum ElementFlags where
+    boxedEnumType _ = c_gst_element_flags_get_type
+
+instance IsGFlag ElementFlags
+
+-- Flags DebugGraphDetails
+
+data DebugGraphDetails = 
+      DebugGraphDetailsMediaType
+    | DebugGraphDetailsCapsDetails
+    | DebugGraphDetailsNonDefaultParams
+    | DebugGraphDetailsStates
+    | DebugGraphDetailsFullParams
+    | DebugGraphDetailsAll
+    | DebugGraphDetailsVerbose
+    | AnotherDebugGraphDetails Int
+    deriving (Show, Eq)
+
+instance Enum DebugGraphDetails where
+    fromEnum DebugGraphDetailsMediaType = 1
+    fromEnum DebugGraphDetailsCapsDetails = 2
+    fromEnum DebugGraphDetailsNonDefaultParams = 4
+    fromEnum DebugGraphDetailsStates = 8
+    fromEnum DebugGraphDetailsFullParams = 16
+    fromEnum DebugGraphDetailsAll = 15
+    fromEnum DebugGraphDetailsVerbose = -1
+    fromEnum (AnotherDebugGraphDetails k) = k
+
+    toEnum -1 = DebugGraphDetailsVerbose
+    toEnum 1 = DebugGraphDetailsMediaType
+    toEnum 2 = DebugGraphDetailsCapsDetails
+    toEnum 4 = DebugGraphDetailsNonDefaultParams
+    toEnum 8 = DebugGraphDetailsStates
+    toEnum 15 = DebugGraphDetailsAll
+    toEnum 16 = DebugGraphDetailsFullParams
+    toEnum k = AnotherDebugGraphDetails k
+
+foreign import ccall "gst_debug_graph_details_get_type" c_gst_debug_graph_details_get_type :: 
+    IO GType
+
+instance BoxedEnum DebugGraphDetails where
+    boxedEnumType _ = c_gst_debug_graph_details_get_type
+
+instance IsGFlag DebugGraphDetails
+
+-- Flags ClockFlags
+
+data ClockFlags = 
+      ClockFlagsCanDoSingleSync
+    | ClockFlagsCanDoSingleAsync
+    | ClockFlagsCanDoPeriodicSync
+    | ClockFlagsCanDoPeriodicAsync
+    | ClockFlagsCanSetResolution
+    | ClockFlagsCanSetMaster
+    | ClockFlagsNeedsStartupSync
+    | ClockFlagsLast
+    | AnotherClockFlags Int
+    deriving (Show, Eq)
+
+instance Enum ClockFlags where
+    fromEnum ClockFlagsCanDoSingleSync = 16
+    fromEnum ClockFlagsCanDoSingleAsync = 32
+    fromEnum ClockFlagsCanDoPeriodicSync = 64
+    fromEnum ClockFlagsCanDoPeriodicAsync = 128
+    fromEnum ClockFlagsCanSetResolution = 256
+    fromEnum ClockFlagsCanSetMaster = 512
+    fromEnum ClockFlagsNeedsStartupSync = 1024
+    fromEnum ClockFlagsLast = 4096
+    fromEnum (AnotherClockFlags k) = k
+
+    toEnum 16 = ClockFlagsCanDoSingleSync
+    toEnum 32 = ClockFlagsCanDoSingleAsync
+    toEnum 64 = ClockFlagsCanDoPeriodicSync
+    toEnum 128 = ClockFlagsCanDoPeriodicAsync
+    toEnum 256 = ClockFlagsCanSetResolution
+    toEnum 512 = ClockFlagsCanSetMaster
+    toEnum 1024 = ClockFlagsNeedsStartupSync
+    toEnum 4096 = ClockFlagsLast
+    toEnum k = AnotherClockFlags k
+
+foreign import ccall "gst_clock_flags_get_type" c_gst_clock_flags_get_type :: 
+    IO GType
+
+instance BoxedEnum ClockFlags where
+    boxedEnumType _ = c_gst_clock_flags_get_type
+
+instance IsGFlag ClockFlags
+
+-- Flags CapsFlags
+
+data CapsFlags = 
+      CapsFlagsAny
+    | AnotherCapsFlags Int
+    deriving (Show, Eq)
+
+instance Enum CapsFlags where
+    fromEnum CapsFlagsAny = 16
+    fromEnum (AnotherCapsFlags k) = k
+
+    toEnum 16 = CapsFlagsAny
+    toEnum k = AnotherCapsFlags k
+
+foreign import ccall "gst_caps_flags_get_type" c_gst_caps_flags_get_type :: 
+    IO GType
+
+instance BoxedEnum CapsFlags where
+    boxedEnumType _ = c_gst_caps_flags_get_type
+
+instance IsGFlag CapsFlags
+
+-- Flags BusFlags
+
+data BusFlags = 
+      BusFlagsFlushing
+    | BusFlagsFlagLast
+    | AnotherBusFlags Int
+    deriving (Show, Eq)
+
+instance Enum BusFlags where
+    fromEnum BusFlagsFlushing = 16
+    fromEnum BusFlagsFlagLast = 32
+    fromEnum (AnotherBusFlags k) = k
+
+    toEnum 16 = BusFlagsFlushing
+    toEnum 32 = BusFlagsFlagLast
+    toEnum k = AnotherBusFlags k
+
+foreign import ccall "gst_bus_flags_get_type" c_gst_bus_flags_get_type :: 
+    IO GType
+
+instance BoxedEnum BusFlags where
+    boxedEnumType _ = c_gst_bus_flags_get_type
+
+instance IsGFlag BusFlags
+
+-- Flags BufferPoolAcquireFlags
+
+data BufferPoolAcquireFlags = 
+      BufferPoolAcquireFlagsNone
+    | BufferPoolAcquireFlagsKeyUnit
+    | BufferPoolAcquireFlagsDontwait
+    | BufferPoolAcquireFlagsDiscont
+    | BufferPoolAcquireFlagsLast
+    | AnotherBufferPoolAcquireFlags Int
+    deriving (Show, Eq)
+
+instance Enum BufferPoolAcquireFlags where
+    fromEnum BufferPoolAcquireFlagsNone = 0
+    fromEnum BufferPoolAcquireFlagsKeyUnit = 1
+    fromEnum BufferPoolAcquireFlagsDontwait = 2
+    fromEnum BufferPoolAcquireFlagsDiscont = 4
+    fromEnum BufferPoolAcquireFlagsLast = 65536
+    fromEnum (AnotherBufferPoolAcquireFlags k) = k
+
+    toEnum 0 = BufferPoolAcquireFlagsNone
+    toEnum 1 = BufferPoolAcquireFlagsKeyUnit
+    toEnum 2 = BufferPoolAcquireFlagsDontwait
+    toEnum 4 = BufferPoolAcquireFlagsDiscont
+    toEnum 65536 = BufferPoolAcquireFlagsLast
+    toEnum k = AnotherBufferPoolAcquireFlags k
+
+foreign import ccall "gst_buffer_pool_acquire_flags_get_type" c_gst_buffer_pool_acquire_flags_get_type :: 
+    IO GType
+
+instance BoxedEnum BufferPoolAcquireFlags where
+    boxedEnumType _ = c_gst_buffer_pool_acquire_flags_get_type
+
+instance IsGFlag BufferPoolAcquireFlags
+
+-- Flags BufferFlags
+
+data BufferFlags = 
+      BufferFlagsLive
+    | BufferFlagsDecodeOnly
+    | BufferFlagsDiscont
+    | BufferFlagsResync
+    | BufferFlagsCorrupted
+    | BufferFlagsMarker
+    | BufferFlagsHeader
+    | BufferFlagsGap
+    | BufferFlagsDroppable
+    | BufferFlagsDeltaUnit
+    | BufferFlagsTagMemory
+    | BufferFlagsSyncAfter
+    | BufferFlagsLast
+    | AnotherBufferFlags Int
+    deriving (Show, Eq)
+
+instance Enum BufferFlags where
+    fromEnum BufferFlagsLive = 16
+    fromEnum BufferFlagsDecodeOnly = 32
+    fromEnum BufferFlagsDiscont = 64
+    fromEnum BufferFlagsResync = 128
+    fromEnum BufferFlagsCorrupted = 256
+    fromEnum BufferFlagsMarker = 512
+    fromEnum BufferFlagsHeader = 1024
+    fromEnum BufferFlagsGap = 2048
+    fromEnum BufferFlagsDroppable = 4096
+    fromEnum BufferFlagsDeltaUnit = 8192
+    fromEnum BufferFlagsTagMemory = 16384
+    fromEnum BufferFlagsSyncAfter = 32768
+    fromEnum BufferFlagsLast = 1048576
+    fromEnum (AnotherBufferFlags k) = k
+
+    toEnum 16 = BufferFlagsLive
+    toEnum 32 = BufferFlagsDecodeOnly
+    toEnum 64 = BufferFlagsDiscont
+    toEnum 128 = BufferFlagsResync
+    toEnum 256 = BufferFlagsCorrupted
+    toEnum 512 = BufferFlagsMarker
+    toEnum 1024 = BufferFlagsHeader
+    toEnum 2048 = BufferFlagsGap
+    toEnum 4096 = BufferFlagsDroppable
+    toEnum 8192 = BufferFlagsDeltaUnit
+    toEnum 16384 = BufferFlagsTagMemory
+    toEnum 32768 = BufferFlagsSyncAfter
+    toEnum 1048576 = BufferFlagsLast
+    toEnum k = AnotherBufferFlags k
+
+foreign import ccall "gst_buffer_flags_get_type" c_gst_buffer_flags_get_type :: 
+    IO GType
+
+instance BoxedEnum BufferFlags where
+    boxedEnumType _ = c_gst_buffer_flags_get_type
+
+instance IsGFlag BufferFlags
+
+-- Flags BufferCopyFlags
+
+data BufferCopyFlags = 
+      BufferCopyFlagsNone
+    | BufferCopyFlagsFlags
+    | BufferCopyFlagsTimestamps
+    | BufferCopyFlagsMeta
+    | BufferCopyFlagsMemory
+    | BufferCopyFlagsMerge
+    | BufferCopyFlagsDeep
+    | AnotherBufferCopyFlags Int
+    deriving (Show, Eq)
+
+instance Enum BufferCopyFlags where
+    fromEnum BufferCopyFlagsNone = 0
+    fromEnum BufferCopyFlagsFlags = 1
+    fromEnum BufferCopyFlagsTimestamps = 2
+    fromEnum BufferCopyFlagsMeta = 4
+    fromEnum BufferCopyFlagsMemory = 8
+    fromEnum BufferCopyFlagsMerge = 16
+    fromEnum BufferCopyFlagsDeep = 32
+    fromEnum (AnotherBufferCopyFlags k) = k
+
+    toEnum 0 = BufferCopyFlagsNone
+    toEnum 1 = BufferCopyFlagsFlags
+    toEnum 2 = BufferCopyFlagsTimestamps
+    toEnum 4 = BufferCopyFlagsMeta
+    toEnum 8 = BufferCopyFlagsMemory
+    toEnum 16 = BufferCopyFlagsMerge
+    toEnum 32 = BufferCopyFlagsDeep
+    toEnum k = AnotherBufferCopyFlags k
+
+foreign import ccall "gst_buffer_copy_flags_get_type" c_gst_buffer_copy_flags_get_type :: 
+    IO GType
+
+instance BoxedEnum BufferCopyFlags where
+    boxedEnumType _ = c_gst_buffer_copy_flags_get_type
+
+instance IsGFlag BufferCopyFlags
+
+-- Flags BinFlags
+
+data BinFlags = 
+      BinFlagsNoResync
+    | BinFlagsLast
+    | AnotherBinFlags Int
+    deriving (Show, Eq)
+
+instance Enum BinFlags where
+    fromEnum BinFlagsNoResync = 16384
+    fromEnum BinFlagsLast = 524288
+    fromEnum (AnotherBinFlags k) = k
+
+    toEnum 16384 = BinFlagsNoResync
+    toEnum 524288 = BinFlagsLast
+    toEnum k = AnotherBinFlags k
+
+foreign import ccall "gst_bin_flags_get_type" c_gst_bin_flags_get_type :: 
+    IO GType
+
+instance BoxedEnum BinFlags where
+    boxedEnumType _ = c_gst_bin_flags_get_type
+
+instance IsGFlag BinFlags
+
+-- Flags AllocatorFlags
+
+data AllocatorFlags = 
+      AllocatorFlagsCustomAlloc
+    | AllocatorFlagsLast
+    | AnotherAllocatorFlags Int
+    deriving (Show, Eq)
+
+instance Enum AllocatorFlags where
+    fromEnum AllocatorFlagsCustomAlloc = 16
+    fromEnum AllocatorFlagsLast = 1048576
+    fromEnum (AnotherAllocatorFlags k) = k
+
+    toEnum 16 = AllocatorFlagsCustomAlloc
+    toEnum 1048576 = AllocatorFlagsLast
+    toEnum k = AnotherAllocatorFlags k
+
+foreign import ccall "gst_allocator_flags_get_type" c_gst_allocator_flags_get_type :: 
+    IO GType
+
+instance BoxedEnum AllocatorFlags where
+    boxedEnumType _ = c_gst_allocator_flags_get_type
+
+instance IsGFlag AllocatorFlags
+
+
diff --git a/GI/Gst/Functions.hs b/GI/Gst/Functions.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Functions.hs
@@ -0,0 +1,3974 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+-}
+
+module GI.Gst.Functions
+    ( 
+
+ -- * Methods
+-- ** debugAddLogFunction
+    debugAddLogFunction                     ,
+
+
+-- ** debugBinToDotData
+    debugBinToDotData                       ,
+
+
+-- ** debugBinToDotFile
+    debugBinToDotFile                       ,
+
+
+-- ** debugBinToDotFileWithTs
+    debugBinToDotFileWithTs                 ,
+
+
+-- ** debugConstructTermColor
+    debugConstructTermColor                 ,
+
+
+-- ** debugConstructWinColor
+    debugConstructWinColor                  ,
+
+
+-- ** debugGetAllCategories
+    debugGetAllCategories                   ,
+
+
+-- ** debugGetColorMode
+    debugGetColorMode                       ,
+
+
+-- ** debugGetDefaultThreshold
+    debugGetDefaultThreshold                ,
+
+
+-- ** debugIsActive
+    debugIsActive                           ,
+
+
+-- ** debugIsColored
+    debugIsColored                          ,
+
+
+-- ** debugLogDefault
+    debugLogDefault                         ,
+
+
+-- ** debugPrintStackTrace
+    debugPrintStackTrace                    ,
+
+
+-- ** debugRemoveLogFunction
+    debugRemoveLogFunction                  ,
+
+
+-- ** debugRemoveLogFunctionByData
+    debugRemoveLogFunctionByData            ,
+
+
+-- ** debugSetActive
+    debugSetActive                          ,
+
+
+-- ** debugSetColorMode
+    debugSetColorMode                       ,
+
+
+-- ** debugSetColorModeFromString
+    debugSetColorModeFromString             ,
+
+
+-- ** debugSetColored
+    debugSetColored                         ,
+
+
+-- ** debugSetDefaultThreshold
+    debugSetDefaultThreshold                ,
+
+
+-- ** debugSetThresholdForName
+    debugSetThresholdForName                ,
+
+
+-- ** debugSetThresholdFromString
+    debugSetThresholdFromString             ,
+
+
+-- ** debugUnsetThresholdForName
+    debugUnsetThresholdForName              ,
+
+
+-- ** deinit
+    deinit                                  ,
+
+
+-- ** errorGetMessage
+    errorGetMessage                         ,
+
+
+-- ** filenameToUri
+    filenameToUri                           ,
+
+
+-- ** flowGetName
+    flowGetName                             ,
+
+
+-- ** flowToQuark
+    flowToQuark                             ,
+
+
+-- ** formatsContains
+    formatsContains                         ,
+
+
+-- ** isCapsFeatures
+    isCapsFeatures                          ,
+
+
+-- ** isInitialized
+    isInitialized                           ,
+
+
+-- ** paramSpecFraction
+    paramSpecFraction                       ,
+
+
+-- ** parentBufferMetaApiGetType
+    parentBufferMetaApiGetType              ,
+
+
+-- ** parseBinFromDescription
+    parseBinFromDescription                 ,
+
+
+-- ** parseBinFromDescriptionFull
+    parseBinFromDescriptionFull             ,
+
+
+-- ** parseLaunch
+    parseLaunch                             ,
+
+
+-- ** parseLaunchFull
+    parseLaunchFull                         ,
+
+
+-- ** parseLaunchv
+    parseLaunchv                            ,
+
+
+-- ** parseLaunchvFull
+    parseLaunchvFull                        ,
+
+
+-- ** protectionMetaApiGetType
+    protectionMetaApiGetType                ,
+
+
+-- ** protectionSelectSystem
+    protectionSelectSystem                  ,
+
+
+-- ** segtrapIsEnabled
+    segtrapIsEnabled                        ,
+
+
+-- ** segtrapSetEnabled
+    segtrapSetEnabled                       ,
+
+
+-- ** staticCapsGetType
+    staticCapsGetType                       ,
+
+
+-- ** staticPadTemplateGetType
+    staticPadTemplateGetType                ,
+
+
+-- ** tagExists
+    tagExists                               ,
+
+
+-- ** tagGetDescription
+    tagGetDescription                       ,
+
+
+-- ** tagGetFlag
+    tagGetFlag                              ,
+
+
+-- ** tagGetNick
+    tagGetNick                              ,
+
+
+-- ** tagGetType
+    tagGetType                              ,
+
+
+-- ** tagIsFixed
+    tagIsFixed                              ,
+
+
+-- ** tagMergeStringsWithComma
+    tagMergeStringsWithComma                ,
+
+
+-- ** tagMergeUseFirst
+    tagMergeUseFirst                        ,
+
+
+-- ** tagRegister
+    tagRegister                             ,
+
+
+-- ** tagRegisterStatic
+    tagRegisterStatic                       ,
+
+
+-- ** typeFindGetType
+    typeFindGetType                         ,
+
+
+-- ** updateRegistry
+    updateRegistry                          ,
+
+
+-- ** utilArrayBinarySearch
+    utilArrayBinarySearch                   ,
+
+
+-- ** utilDoubleToFraction
+    utilDoubleToFraction                    ,
+
+
+-- ** utilDumpMem
+    utilDumpMem                             ,
+
+
+-- ** utilFractionAdd
+    utilFractionAdd                         ,
+
+
+-- ** utilFractionCompare
+    utilFractionCompare                     ,
+
+
+-- ** utilFractionMultiply
+    utilFractionMultiply                    ,
+
+
+-- ** utilFractionToDouble
+    utilFractionToDouble                    ,
+
+
+-- ** utilGdoubleToGuint64
+    utilGdoubleToGuint64                    ,
+
+
+-- ** utilGetTimestamp
+    utilGetTimestamp                        ,
+
+
+-- ** utilGreatestCommonDivisor
+    utilGreatestCommonDivisor               ,
+
+
+-- ** utilGreatestCommonDivisorInt64
+    utilGreatestCommonDivisorInt64          ,
+
+
+-- ** utilGroupIdNext
+    utilGroupIdNext                         ,
+
+
+-- ** utilGuint64ToGdouble
+    utilGuint64ToGdouble                    ,
+
+
+-- ** utilSeqnumCompare
+    utilSeqnumCompare                       ,
+
+
+-- ** utilSeqnumNext
+    utilSeqnumNext                          ,
+
+
+-- ** utilSetObjectArg
+    utilSetObjectArg                        ,
+
+
+-- ** utilSetValueFromString
+    utilSetValueFromString                  ,
+
+
+-- ** utilUint64Scale
+    utilUint64Scale                         ,
+
+
+-- ** utilUint64ScaleCeil
+    utilUint64ScaleCeil                     ,
+
+
+-- ** utilUint64ScaleInt
+    utilUint64ScaleInt                      ,
+
+
+-- ** utilUint64ScaleIntCeil
+    utilUint64ScaleIntCeil                  ,
+
+
+-- ** utilUint64ScaleIntRound
+    utilUint64ScaleIntRound                 ,
+
+
+-- ** utilUint64ScaleRound
+    utilUint64ScaleRound                    ,
+
+
+-- ** valueCanCompare
+    valueCanCompare                         ,
+
+
+-- ** valueCanIntersect
+    valueCanIntersect                       ,
+
+
+-- ** valueCanSubtract
+    valueCanSubtract                        ,
+
+
+-- ** valueCanUnion
+    valueCanUnion                           ,
+
+
+-- ** valueCompare
+    valueCompare                            ,
+
+
+-- ** valueDeserialize
+    valueDeserialize                        ,
+
+
+-- ** valueFixate
+    valueFixate                             ,
+
+
+-- ** valueFractionMultiply
+    valueFractionMultiply                   ,
+
+
+-- ** valueFractionSubtract
+    valueFractionSubtract                   ,
+
+
+-- ** valueGetBitmask
+    valueGetBitmask                         ,
+
+
+-- ** valueGetCaps
+    valueGetCaps                            ,
+
+
+-- ** valueGetCapsFeatures
+    valueGetCapsFeatures                    ,
+
+
+-- ** valueGetDoubleRangeMax
+    valueGetDoubleRangeMax                  ,
+
+
+-- ** valueGetDoubleRangeMin
+    valueGetDoubleRangeMin                  ,
+
+
+-- ** valueGetFlagsetFlags
+    valueGetFlagsetFlags                    ,
+
+
+-- ** valueGetFlagsetMask
+    valueGetFlagsetMask                     ,
+
+
+-- ** valueGetFractionDenominator
+    valueGetFractionDenominator             ,
+
+
+-- ** valueGetFractionNumerator
+    valueGetFractionNumerator               ,
+
+
+-- ** valueGetFractionRangeMax
+    valueGetFractionRangeMax                ,
+
+
+-- ** valueGetFractionRangeMin
+    valueGetFractionRangeMin                ,
+
+
+-- ** valueGetInt64RangeMax
+    valueGetInt64RangeMax                   ,
+
+
+-- ** valueGetInt64RangeMin
+    valueGetInt64RangeMin                   ,
+
+
+-- ** valueGetInt64RangeStep
+    valueGetInt64RangeStep                  ,
+
+
+-- ** valueGetIntRangeMax
+    valueGetIntRangeMax                     ,
+
+
+-- ** valueGetIntRangeMin
+    valueGetIntRangeMin                     ,
+
+
+-- ** valueGetIntRangeStep
+    valueGetIntRangeStep                    ,
+
+
+-- ** valueGetStructure
+    valueGetStructure                       ,
+
+
+-- ** valueInitAndCopy
+    valueInitAndCopy                        ,
+
+
+-- ** valueIntersect
+    valueIntersect                          ,
+
+
+-- ** valueIsFixed
+    valueIsFixed                            ,
+
+
+-- ** valueIsSubset
+    valueIsSubset                           ,
+
+
+-- ** valueRegister
+    valueRegister                           ,
+
+
+-- ** valueSerialize
+    valueSerialize                          ,
+
+
+-- ** valueSetBitmask
+    valueSetBitmask                         ,
+
+
+-- ** valueSetCaps
+    valueSetCaps                            ,
+
+
+-- ** valueSetCapsFeatures
+    valueSetCapsFeatures                    ,
+
+
+-- ** valueSetDoubleRange
+    valueSetDoubleRange                     ,
+
+
+-- ** valueSetFlagset
+    valueSetFlagset                         ,
+
+
+-- ** valueSetFraction
+    valueSetFraction                        ,
+
+
+-- ** valueSetFractionRange
+    valueSetFractionRange                   ,
+
+
+-- ** valueSetFractionRangeFull
+    valueSetFractionRangeFull               ,
+
+
+-- ** valueSetInt64Range
+    valueSetInt64Range                      ,
+
+
+-- ** valueSetInt64RangeStep
+    valueSetInt64RangeStep                  ,
+
+
+-- ** valueSetIntRange
+    valueSetIntRange                        ,
+
+
+-- ** valueSetIntRangeStep
+    valueSetIntRangeStep                    ,
+
+
+-- ** valueSetStructure
+    valueSetStructure                       ,
+
+
+-- ** valueSubtract
+    valueSubtract                           ,
+
+
+-- ** valueUnion
+    valueUnion                              ,
+
+
+-- ** version
+    version                                 ,
+
+
+-- ** versionString
+    versionString                           ,
+
+
+
+
+    ) where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+import GI.Gst.Callbacks
+import qualified GI.GLib as GLib
+import qualified GI.GObject as GObject
+
+-- function gst_version_string
+-- Args : []
+-- Lengths : []
+-- returnType : TBasicType TUTF8
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_version_string" gst_version_string :: 
+    IO CString
+
+
+versionString ::
+    (MonadIO m) =>
+    m T.Text                                -- result
+versionString  = liftIO $ do
+    result <- gst_version_string
+    checkUnexpectedReturnNULL "gst_version_string" result
+    result' <- cstringToText result
+    freeMem result
+    return result'
+
+
+-- function gst_version
+-- Args : [Arg {argCName = "major", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "minor", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "micro", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "nano", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_version" gst_version :: 
+    Ptr Word32 ->                           -- major : TBasicType TUInt32
+    Ptr Word32 ->                           -- minor : TBasicType TUInt32
+    Ptr Word32 ->                           -- micro : TBasicType TUInt32
+    Ptr Word32 ->                           -- nano : TBasicType TUInt32
+    IO ()
+
+
+version ::
+    (MonadIO m) =>
+    m (Word32,Word32,Word32,Word32)         -- result
+version  = liftIO $ do
+    major <- allocMem :: IO (Ptr Word32)
+    minor <- allocMem :: IO (Ptr Word32)
+    micro <- allocMem :: IO (Ptr Word32)
+    nano <- allocMem :: IO (Ptr Word32)
+    gst_version major minor micro nano
+    major' <- peek major
+    minor' <- peek minor
+    micro' <- peek micro
+    nano' <- peek nano
+    freeMem major
+    freeMem minor
+    freeMem micro
+    freeMem nano
+    return (major', minor', micro', nano')
+
+
+-- function gst_value_union
+-- Args : [Arg {argCName = "dest", argType = TInterface "GObject" "Value", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing},Arg {argCName = "value1", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value2", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_value_union" gst_value_union :: 
+    Ptr GValue ->                           -- dest : TInterface "GObject" "Value"
+    Ptr GValue ->                           -- value1 : TInterface "GObject" "Value"
+    Ptr GValue ->                           -- value2 : TInterface "GObject" "Value"
+    IO CInt
+
+
+valueUnion ::
+    (MonadIO m) =>
+    GValue                                  -- value1
+    -> GValue                               -- value2
+    -> m (Bool,GValue)                      -- result
+valueUnion value1 value2 = liftIO $ do
+    dest <- callocBoxedBytes 24 :: IO (Ptr GValue)
+    let value1' = unsafeManagedPtrGetPtr value1
+    let value2' = unsafeManagedPtrGetPtr value2
+    result <- gst_value_union dest value1' value2'
+    let result' = (/= 0) result
+    dest' <- (wrapBoxed GValue) dest
+    touchManagedPtr value1
+    touchManagedPtr value2
+    return (result', dest')
+
+
+-- function gst_value_subtract
+-- Args : [Arg {argCName = "dest", argType = TInterface "GObject" "Value", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing},Arg {argCName = "minuend", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "subtrahend", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_value_subtract" gst_value_subtract :: 
+    Ptr GValue ->                           -- dest : TInterface "GObject" "Value"
+    Ptr GValue ->                           -- minuend : TInterface "GObject" "Value"
+    Ptr GValue ->                           -- subtrahend : TInterface "GObject" "Value"
+    IO CInt
+
+
+valueSubtract ::
+    (MonadIO m) =>
+    GValue                                  -- minuend
+    -> GValue                               -- subtrahend
+    -> m (Bool,GValue)                      -- result
+valueSubtract minuend subtrahend = liftIO $ do
+    dest <- callocBoxedBytes 24 :: IO (Ptr GValue)
+    let minuend' = unsafeManagedPtrGetPtr minuend
+    let subtrahend' = unsafeManagedPtrGetPtr subtrahend
+    result <- gst_value_subtract dest minuend' subtrahend'
+    let result' = (/= 0) result
+    dest' <- (wrapBoxed GValue) dest
+    touchManagedPtr minuend
+    touchManagedPtr subtrahend
+    return (result', dest')
+
+
+-- function gst_value_set_structure
+-- Args : [Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "structure", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_value_set_structure" gst_value_set_structure :: 
+    Ptr GValue ->                           -- value : TInterface "GObject" "Value"
+    Ptr Structure ->                        -- structure : TInterface "Gst" "Structure"
+    IO ()
+
+
+valueSetStructure ::
+    (MonadIO m) =>
+    GValue                                  -- value
+    -> Structure                            -- structure
+    -> m ()                                 -- result
+valueSetStructure value structure = liftIO $ do
+    let value' = unsafeManagedPtrGetPtr value
+    let structure' = unsafeManagedPtrGetPtr structure
+    gst_value_set_structure value' structure'
+    touchManagedPtr value
+    touchManagedPtr structure
+    return ()
+
+
+-- function gst_value_set_int_range_step
+-- Args : [Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "end", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "step", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_value_set_int_range_step" gst_value_set_int_range_step :: 
+    Ptr GValue ->                           -- value : TInterface "GObject" "Value"
+    Int32 ->                                -- start : TBasicType TInt32
+    Int32 ->                                -- end : TBasicType TInt32
+    Int32 ->                                -- step : TBasicType TInt32
+    IO ()
+
+
+valueSetIntRangeStep ::
+    (MonadIO m) =>
+    GValue                                  -- value
+    -> Int32                                -- start
+    -> Int32                                -- end
+    -> Int32                                -- step
+    -> m ()                                 -- result
+valueSetIntRangeStep value start end step = liftIO $ do
+    let value' = unsafeManagedPtrGetPtr value
+    gst_value_set_int_range_step value' start end step
+    touchManagedPtr value
+    return ()
+
+
+-- function gst_value_set_int_range
+-- Args : [Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "end", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_value_set_int_range" gst_value_set_int_range :: 
+    Ptr GValue ->                           -- value : TInterface "GObject" "Value"
+    Int32 ->                                -- start : TBasicType TInt32
+    Int32 ->                                -- end : TBasicType TInt32
+    IO ()
+
+
+valueSetIntRange ::
+    (MonadIO m) =>
+    GValue                                  -- value
+    -> Int32                                -- start
+    -> Int32                                -- end
+    -> m ()                                 -- result
+valueSetIntRange value start end = liftIO $ do
+    let value' = unsafeManagedPtrGetPtr value
+    gst_value_set_int_range value' start end
+    touchManagedPtr value
+    return ()
+
+
+-- function gst_value_set_int64_range_step
+-- Args : [Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "end", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "step", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_value_set_int64_range_step" gst_value_set_int64_range_step :: 
+    Ptr GValue ->                           -- value : TInterface "GObject" "Value"
+    Int64 ->                                -- start : TBasicType TInt64
+    Int64 ->                                -- end : TBasicType TInt64
+    Int64 ->                                -- step : TBasicType TInt64
+    IO ()
+
+
+valueSetInt64RangeStep ::
+    (MonadIO m) =>
+    GValue                                  -- value
+    -> Int64                                -- start
+    -> Int64                                -- end
+    -> Int64                                -- step
+    -> m ()                                 -- result
+valueSetInt64RangeStep value start end step = liftIO $ do
+    let value' = unsafeManagedPtrGetPtr value
+    gst_value_set_int64_range_step value' start end step
+    touchManagedPtr value
+    return ()
+
+
+-- function gst_value_set_int64_range
+-- Args : [Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "end", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_value_set_int64_range" gst_value_set_int64_range :: 
+    Ptr GValue ->                           -- value : TInterface "GObject" "Value"
+    Int64 ->                                -- start : TBasicType TInt64
+    Int64 ->                                -- end : TBasicType TInt64
+    IO ()
+
+
+valueSetInt64Range ::
+    (MonadIO m) =>
+    GValue                                  -- value
+    -> Int64                                -- start
+    -> Int64                                -- end
+    -> m ()                                 -- result
+valueSetInt64Range value start end = liftIO $ do
+    let value' = unsafeManagedPtrGetPtr value
+    gst_value_set_int64_range value' start end
+    touchManagedPtr value
+    return ()
+
+
+-- function gst_value_set_fraction_range_full
+-- Args : [Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "numerator_start", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "denominator_start", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "numerator_end", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "denominator_end", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_value_set_fraction_range_full" gst_value_set_fraction_range_full :: 
+    Ptr GValue ->                           -- value : TInterface "GObject" "Value"
+    Int32 ->                                -- numerator_start : TBasicType TInt32
+    Int32 ->                                -- denominator_start : TBasicType TInt32
+    Int32 ->                                -- numerator_end : TBasicType TInt32
+    Int32 ->                                -- denominator_end : TBasicType TInt32
+    IO ()
+
+
+valueSetFractionRangeFull ::
+    (MonadIO m) =>
+    GValue                                  -- value
+    -> Int32                                -- numeratorStart
+    -> Int32                                -- denominatorStart
+    -> Int32                                -- numeratorEnd
+    -> Int32                                -- denominatorEnd
+    -> m ()                                 -- result
+valueSetFractionRangeFull value numeratorStart denominatorStart numeratorEnd denominatorEnd = liftIO $ do
+    let value' = unsafeManagedPtrGetPtr value
+    gst_value_set_fraction_range_full value' numeratorStart denominatorStart numeratorEnd denominatorEnd
+    touchManagedPtr value
+    return ()
+
+
+-- function gst_value_set_fraction_range
+-- Args : [Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "end", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_value_set_fraction_range" gst_value_set_fraction_range :: 
+    Ptr GValue ->                           -- value : TInterface "GObject" "Value"
+    Ptr GValue ->                           -- start : TInterface "GObject" "Value"
+    Ptr GValue ->                           -- end : TInterface "GObject" "Value"
+    IO ()
+
+
+valueSetFractionRange ::
+    (MonadIO m) =>
+    GValue                                  -- value
+    -> GValue                               -- start
+    -> GValue                               -- end
+    -> m ()                                 -- result
+valueSetFractionRange value start end = liftIO $ do
+    let value' = unsafeManagedPtrGetPtr value
+    let start' = unsafeManagedPtrGetPtr start
+    let end' = unsafeManagedPtrGetPtr end
+    gst_value_set_fraction_range value' start' end'
+    touchManagedPtr value
+    touchManagedPtr start
+    touchManagedPtr end
+    return ()
+
+
+-- function gst_value_set_fraction
+-- Args : [Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "numerator", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "denominator", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_value_set_fraction" gst_value_set_fraction :: 
+    Ptr GValue ->                           -- value : TInterface "GObject" "Value"
+    Int32 ->                                -- numerator : TBasicType TInt32
+    Int32 ->                                -- denominator : TBasicType TInt32
+    IO ()
+
+
+valueSetFraction ::
+    (MonadIO m) =>
+    GValue                                  -- value
+    -> Int32                                -- numerator
+    -> Int32                                -- denominator
+    -> m ()                                 -- result
+valueSetFraction value numerator denominator = liftIO $ do
+    let value' = unsafeManagedPtrGetPtr value
+    gst_value_set_fraction value' numerator denominator
+    touchManagedPtr value
+    return ()
+
+
+-- function gst_value_set_flagset
+-- Args : [Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mask", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_value_set_flagset" gst_value_set_flagset :: 
+    Ptr GValue ->                           -- value : TInterface "GObject" "Value"
+    Word32 ->                               -- flags : TBasicType TUInt32
+    Word32 ->                               -- mask : TBasicType TUInt32
+    IO ()
+
+
+valueSetFlagset ::
+    (MonadIO m) =>
+    GValue                                  -- value
+    -> Word32                               -- flags
+    -> Word32                               -- mask
+    -> m ()                                 -- result
+valueSetFlagset value flags mask = liftIO $ do
+    let value' = unsafeManagedPtrGetPtr value
+    gst_value_set_flagset value' flags mask
+    touchManagedPtr value
+    return ()
+
+
+-- function gst_value_set_double_range
+-- Args : [Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "end", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_value_set_double_range" gst_value_set_double_range :: 
+    Ptr GValue ->                           -- value : TInterface "GObject" "Value"
+    CDouble ->                              -- start : TBasicType TDouble
+    CDouble ->                              -- end : TBasicType TDouble
+    IO ()
+
+
+valueSetDoubleRange ::
+    (MonadIO m) =>
+    GValue                                  -- value
+    -> Double                               -- start
+    -> Double                               -- end
+    -> m ()                                 -- result
+valueSetDoubleRange value start end = liftIO $ do
+    let value' = unsafeManagedPtrGetPtr value
+    let start' = realToFrac start
+    let end' = realToFrac end
+    gst_value_set_double_range value' start' end'
+    touchManagedPtr value
+    return ()
+
+
+-- function gst_value_set_caps_features
+-- Args : [Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "features", argType = TInterface "Gst" "CapsFeatures", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_value_set_caps_features" gst_value_set_caps_features :: 
+    Ptr GValue ->                           -- value : TInterface "GObject" "Value"
+    Ptr CapsFeatures ->                     -- features : TInterface "Gst" "CapsFeatures"
+    IO ()
+
+
+valueSetCapsFeatures ::
+    (MonadIO m) =>
+    GValue                                  -- value
+    -> CapsFeatures                         -- features
+    -> m ()                                 -- result
+valueSetCapsFeatures value features = liftIO $ do
+    let value' = unsafeManagedPtrGetPtr value
+    let features' = unsafeManagedPtrGetPtr features
+    gst_value_set_caps_features value' features'
+    touchManagedPtr value
+    touchManagedPtr features
+    return ()
+
+
+-- function gst_value_set_caps
+-- Args : [Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_value_set_caps" gst_value_set_caps :: 
+    Ptr GValue ->                           -- value : TInterface "GObject" "Value"
+    Ptr Caps ->                             -- caps : TInterface "Gst" "Caps"
+    IO ()
+
+
+valueSetCaps ::
+    (MonadIO m) =>
+    GValue                                  -- value
+    -> Caps                                 -- caps
+    -> m ()                                 -- result
+valueSetCaps value caps = liftIO $ do
+    let value' = unsafeManagedPtrGetPtr value
+    let caps' = unsafeManagedPtrGetPtr caps
+    gst_value_set_caps value' caps'
+    touchManagedPtr value
+    touchManagedPtr caps
+    return ()
+
+
+-- function gst_value_set_bitmask
+-- Args : [Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "bitmask", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_value_set_bitmask" gst_value_set_bitmask :: 
+    Ptr GValue ->                           -- value : TInterface "GObject" "Value"
+    Word64 ->                               -- bitmask : TBasicType TUInt64
+    IO ()
+
+
+valueSetBitmask ::
+    (MonadIO m) =>
+    GValue                                  -- value
+    -> Word64                               -- bitmask
+    -> m ()                                 -- result
+valueSetBitmask value bitmask = liftIO $ do
+    let value' = unsafeManagedPtrGetPtr value
+    gst_value_set_bitmask value' bitmask
+    touchManagedPtr value
+    return ()
+
+
+-- function gst_value_serialize
+-- Args : [Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUTF8
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_value_serialize" gst_value_serialize :: 
+    Ptr GValue ->                           -- value : TInterface "GObject" "Value"
+    IO CString
+
+
+valueSerialize ::
+    (MonadIO m) =>
+    GValue                                  -- value
+    -> m T.Text                             -- result
+valueSerialize value = liftIO $ do
+    let value' = unsafeManagedPtrGetPtr value
+    result <- gst_value_serialize value'
+    checkUnexpectedReturnNULL "gst_value_serialize" result
+    result' <- cstringToText result
+    freeMem result
+    touchManagedPtr value
+    return result'
+
+
+-- function gst_value_register
+-- Args : [Arg {argCName = "table", argType = TInterface "Gst" "ValueTable", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_value_register" gst_value_register :: 
+    Ptr ValueTable ->                       -- table : TInterface "Gst" "ValueTable"
+    IO ()
+
+
+valueRegister ::
+    (MonadIO m) =>
+    ValueTable                              -- table
+    -> m ()                                 -- result
+valueRegister table = liftIO $ do
+    let table' = unsafeManagedPtrGetPtr table
+    gst_value_register table'
+    touchManagedPtr table
+    return ()
+
+
+-- function gst_value_is_subset
+-- Args : [Arg {argCName = "value1", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value2", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_value_is_subset" gst_value_is_subset :: 
+    Ptr GValue ->                           -- value1 : TInterface "GObject" "Value"
+    Ptr GValue ->                           -- value2 : TInterface "GObject" "Value"
+    IO CInt
+
+
+valueIsSubset ::
+    (MonadIO m) =>
+    GValue                                  -- value1
+    -> GValue                               -- value2
+    -> m Bool                               -- result
+valueIsSubset value1 value2 = liftIO $ do
+    let value1' = unsafeManagedPtrGetPtr value1
+    let value2' = unsafeManagedPtrGetPtr value2
+    result <- gst_value_is_subset value1' value2'
+    let result' = (/= 0) result
+    touchManagedPtr value1
+    touchManagedPtr value2
+    return result'
+
+
+-- function gst_value_is_fixed
+-- Args : [Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_value_is_fixed" gst_value_is_fixed :: 
+    Ptr GValue ->                           -- value : TInterface "GObject" "Value"
+    IO CInt
+
+
+valueIsFixed ::
+    (MonadIO m) =>
+    GValue                                  -- value
+    -> m Bool                               -- result
+valueIsFixed value = liftIO $ do
+    let value' = unsafeManagedPtrGetPtr value
+    result <- gst_value_is_fixed value'
+    let result' = (/= 0) result
+    touchManagedPtr value
+    return result'
+
+
+-- function gst_value_intersect
+-- Args : [Arg {argCName = "dest", argType = TInterface "GObject" "Value", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferEverything},Arg {argCName = "value1", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value2", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_value_intersect" gst_value_intersect :: 
+    Ptr GValue ->                           -- dest : TInterface "GObject" "Value"
+    Ptr GValue ->                           -- value1 : TInterface "GObject" "Value"
+    Ptr GValue ->                           -- value2 : TInterface "GObject" "Value"
+    IO CInt
+
+
+valueIntersect ::
+    (MonadIO m) =>
+    GValue                                  -- value1
+    -> GValue                               -- value2
+    -> m (Bool,GValue)                      -- result
+valueIntersect value1 value2 = liftIO $ do
+    dest <- callocBoxedBytes 24 :: IO (Ptr GValue)
+    let value1' = unsafeManagedPtrGetPtr value1
+    let value2' = unsafeManagedPtrGetPtr value2
+    result <- gst_value_intersect dest value1' value2'
+    let result' = (/= 0) result
+    dest' <- (wrapBoxed GValue) dest
+    touchManagedPtr value1
+    touchManagedPtr value2
+    return (result', dest')
+
+
+-- function gst_value_init_and_copy
+-- Args : [Arg {argCName = "dest", argType = TInterface "GObject" "Value", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing},Arg {argCName = "src", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_value_init_and_copy" gst_value_init_and_copy :: 
+    Ptr GValue ->                           -- dest : TInterface "GObject" "Value"
+    Ptr GValue ->                           -- src : TInterface "GObject" "Value"
+    IO ()
+
+
+valueInitAndCopy ::
+    (MonadIO m) =>
+    GValue                                  -- src
+    -> m (GValue)                           -- result
+valueInitAndCopy src = liftIO $ do
+    dest <- callocBoxedBytes 24 :: IO (Ptr GValue)
+    let src' = unsafeManagedPtrGetPtr src
+    gst_value_init_and_copy dest src'
+    dest' <- (wrapBoxed GValue) dest
+    touchManagedPtr src
+    return dest'
+
+
+-- function gst_value_get_structure
+-- Args : [Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Structure"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_value_get_structure" gst_value_get_structure :: 
+    Ptr GValue ->                           -- value : TInterface "GObject" "Value"
+    IO (Ptr Structure)
+
+
+valueGetStructure ::
+    (MonadIO m) =>
+    GValue                                  -- value
+    -> m Structure                          -- result
+valueGetStructure value = liftIO $ do
+    let value' = unsafeManagedPtrGetPtr value
+    result <- gst_value_get_structure value'
+    checkUnexpectedReturnNULL "gst_value_get_structure" result
+    result' <- (newBoxed Structure) result
+    touchManagedPtr value
+    return result'
+
+
+-- function gst_value_get_int_range_step
+-- Args : [Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TInt32
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_value_get_int_range_step" gst_value_get_int_range_step :: 
+    Ptr GValue ->                           -- value : TInterface "GObject" "Value"
+    IO Int32
+
+
+valueGetIntRangeStep ::
+    (MonadIO m) =>
+    GValue                                  -- value
+    -> m Int32                              -- result
+valueGetIntRangeStep value = liftIO $ do
+    let value' = unsafeManagedPtrGetPtr value
+    result <- gst_value_get_int_range_step value'
+    touchManagedPtr value
+    return result
+
+
+-- function gst_value_get_int_range_min
+-- Args : [Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TInt32
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_value_get_int_range_min" gst_value_get_int_range_min :: 
+    Ptr GValue ->                           -- value : TInterface "GObject" "Value"
+    IO Int32
+
+
+valueGetIntRangeMin ::
+    (MonadIO m) =>
+    GValue                                  -- value
+    -> m Int32                              -- result
+valueGetIntRangeMin value = liftIO $ do
+    let value' = unsafeManagedPtrGetPtr value
+    result <- gst_value_get_int_range_min value'
+    touchManagedPtr value
+    return result
+
+
+-- function gst_value_get_int_range_max
+-- Args : [Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TInt32
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_value_get_int_range_max" gst_value_get_int_range_max :: 
+    Ptr GValue ->                           -- value : TInterface "GObject" "Value"
+    IO Int32
+
+
+valueGetIntRangeMax ::
+    (MonadIO m) =>
+    GValue                                  -- value
+    -> m Int32                              -- result
+valueGetIntRangeMax value = liftIO $ do
+    let value' = unsafeManagedPtrGetPtr value
+    result <- gst_value_get_int_range_max value'
+    touchManagedPtr value
+    return result
+
+
+-- function gst_value_get_int64_range_step
+-- Args : [Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TInt64
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_value_get_int64_range_step" gst_value_get_int64_range_step :: 
+    Ptr GValue ->                           -- value : TInterface "GObject" "Value"
+    IO Int64
+
+
+valueGetInt64RangeStep ::
+    (MonadIO m) =>
+    GValue                                  -- value
+    -> m Int64                              -- result
+valueGetInt64RangeStep value = liftIO $ do
+    let value' = unsafeManagedPtrGetPtr value
+    result <- gst_value_get_int64_range_step value'
+    touchManagedPtr value
+    return result
+
+
+-- function gst_value_get_int64_range_min
+-- Args : [Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TInt64
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_value_get_int64_range_min" gst_value_get_int64_range_min :: 
+    Ptr GValue ->                           -- value : TInterface "GObject" "Value"
+    IO Int64
+
+
+valueGetInt64RangeMin ::
+    (MonadIO m) =>
+    GValue                                  -- value
+    -> m Int64                              -- result
+valueGetInt64RangeMin value = liftIO $ do
+    let value' = unsafeManagedPtrGetPtr value
+    result <- gst_value_get_int64_range_min value'
+    touchManagedPtr value
+    return result
+
+
+-- function gst_value_get_int64_range_max
+-- Args : [Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TInt64
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_value_get_int64_range_max" gst_value_get_int64_range_max :: 
+    Ptr GValue ->                           -- value : TInterface "GObject" "Value"
+    IO Int64
+
+
+valueGetInt64RangeMax ::
+    (MonadIO m) =>
+    GValue                                  -- value
+    -> m Int64                              -- result
+valueGetInt64RangeMax value = liftIO $ do
+    let value' = unsafeManagedPtrGetPtr value
+    result <- gst_value_get_int64_range_max value'
+    touchManagedPtr value
+    return result
+
+
+-- function gst_value_get_fraction_range_min
+-- Args : [Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "GObject" "Value"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_value_get_fraction_range_min" gst_value_get_fraction_range_min :: 
+    Ptr GValue ->                           -- value : TInterface "GObject" "Value"
+    IO (Ptr GValue)
+
+
+valueGetFractionRangeMin ::
+    (MonadIO m) =>
+    GValue                                  -- value
+    -> m GValue                             -- result
+valueGetFractionRangeMin value = liftIO $ do
+    let value' = unsafeManagedPtrGetPtr value
+    result <- gst_value_get_fraction_range_min value'
+    checkUnexpectedReturnNULL "gst_value_get_fraction_range_min" result
+    result' <- (newBoxed GValue) result
+    touchManagedPtr value
+    return result'
+
+
+-- function gst_value_get_fraction_range_max
+-- Args : [Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "GObject" "Value"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_value_get_fraction_range_max" gst_value_get_fraction_range_max :: 
+    Ptr GValue ->                           -- value : TInterface "GObject" "Value"
+    IO (Ptr GValue)
+
+
+valueGetFractionRangeMax ::
+    (MonadIO m) =>
+    GValue                                  -- value
+    -> m GValue                             -- result
+valueGetFractionRangeMax value = liftIO $ do
+    let value' = unsafeManagedPtrGetPtr value
+    result <- gst_value_get_fraction_range_max value'
+    checkUnexpectedReturnNULL "gst_value_get_fraction_range_max" result
+    result' <- (newBoxed GValue) result
+    touchManagedPtr value
+    return result'
+
+
+-- function gst_value_get_fraction_numerator
+-- Args : [Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TInt32
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_value_get_fraction_numerator" gst_value_get_fraction_numerator :: 
+    Ptr GValue ->                           -- value : TInterface "GObject" "Value"
+    IO Int32
+
+
+valueGetFractionNumerator ::
+    (MonadIO m) =>
+    GValue                                  -- value
+    -> m Int32                              -- result
+valueGetFractionNumerator value = liftIO $ do
+    let value' = unsafeManagedPtrGetPtr value
+    result <- gst_value_get_fraction_numerator value'
+    touchManagedPtr value
+    return result
+
+
+-- function gst_value_get_fraction_denominator
+-- Args : [Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TInt32
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_value_get_fraction_denominator" gst_value_get_fraction_denominator :: 
+    Ptr GValue ->                           -- value : TInterface "GObject" "Value"
+    IO Int32
+
+
+valueGetFractionDenominator ::
+    (MonadIO m) =>
+    GValue                                  -- value
+    -> m Int32                              -- result
+valueGetFractionDenominator value = liftIO $ do
+    let value' = unsafeManagedPtrGetPtr value
+    result <- gst_value_get_fraction_denominator value'
+    touchManagedPtr value
+    return result
+
+
+-- function gst_value_get_flagset_mask
+-- Args : [Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUInt32
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_value_get_flagset_mask" gst_value_get_flagset_mask :: 
+    Ptr GValue ->                           -- value : TInterface "GObject" "Value"
+    IO Word32
+
+
+valueGetFlagsetMask ::
+    (MonadIO m) =>
+    GValue                                  -- value
+    -> m Word32                             -- result
+valueGetFlagsetMask value = liftIO $ do
+    let value' = unsafeManagedPtrGetPtr value
+    result <- gst_value_get_flagset_mask value'
+    touchManagedPtr value
+    return result
+
+
+-- function gst_value_get_flagset_flags
+-- Args : [Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUInt32
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_value_get_flagset_flags" gst_value_get_flagset_flags :: 
+    Ptr GValue ->                           -- value : TInterface "GObject" "Value"
+    IO Word32
+
+
+valueGetFlagsetFlags ::
+    (MonadIO m) =>
+    GValue                                  -- value
+    -> m Word32                             -- result
+valueGetFlagsetFlags value = liftIO $ do
+    let value' = unsafeManagedPtrGetPtr value
+    result <- gst_value_get_flagset_flags value'
+    touchManagedPtr value
+    return result
+
+
+-- function gst_value_get_double_range_min
+-- Args : [Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TDouble
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_value_get_double_range_min" gst_value_get_double_range_min :: 
+    Ptr GValue ->                           -- value : TInterface "GObject" "Value"
+    IO CDouble
+
+
+valueGetDoubleRangeMin ::
+    (MonadIO m) =>
+    GValue                                  -- value
+    -> m Double                             -- result
+valueGetDoubleRangeMin value = liftIO $ do
+    let value' = unsafeManagedPtrGetPtr value
+    result <- gst_value_get_double_range_min value'
+    let result' = realToFrac result
+    touchManagedPtr value
+    return result'
+
+
+-- function gst_value_get_double_range_max
+-- Args : [Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TDouble
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_value_get_double_range_max" gst_value_get_double_range_max :: 
+    Ptr GValue ->                           -- value : TInterface "GObject" "Value"
+    IO CDouble
+
+
+valueGetDoubleRangeMax ::
+    (MonadIO m) =>
+    GValue                                  -- value
+    -> m Double                             -- result
+valueGetDoubleRangeMax value = liftIO $ do
+    let value' = unsafeManagedPtrGetPtr value
+    result <- gst_value_get_double_range_max value'
+    let result' = realToFrac result
+    touchManagedPtr value
+    return result'
+
+
+-- function gst_value_get_caps_features
+-- Args : [Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "CapsFeatures"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_value_get_caps_features" gst_value_get_caps_features :: 
+    Ptr GValue ->                           -- value : TInterface "GObject" "Value"
+    IO (Ptr CapsFeatures)
+
+
+valueGetCapsFeatures ::
+    (MonadIO m) =>
+    GValue                                  -- value
+    -> m CapsFeatures                       -- result
+valueGetCapsFeatures value = liftIO $ do
+    let value' = unsafeManagedPtrGetPtr value
+    result <- gst_value_get_caps_features value'
+    checkUnexpectedReturnNULL "gst_value_get_caps_features" result
+    result' <- (newBoxed CapsFeatures) result
+    touchManagedPtr value
+    return result'
+
+
+-- function gst_value_get_caps
+-- Args : [Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Caps"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_value_get_caps" gst_value_get_caps :: 
+    Ptr GValue ->                           -- value : TInterface "GObject" "Value"
+    IO (Ptr Caps)
+
+
+valueGetCaps ::
+    (MonadIO m) =>
+    GValue                                  -- value
+    -> m Caps                               -- result
+valueGetCaps value = liftIO $ do
+    let value' = unsafeManagedPtrGetPtr value
+    result <- gst_value_get_caps value'
+    checkUnexpectedReturnNULL "gst_value_get_caps" result
+    result' <- (newBoxed Caps) result
+    touchManagedPtr value
+    return result'
+
+
+-- function gst_value_get_bitmask
+-- Args : [Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUInt64
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_value_get_bitmask" gst_value_get_bitmask :: 
+    Ptr GValue ->                           -- value : TInterface "GObject" "Value"
+    IO Word64
+
+
+valueGetBitmask ::
+    (MonadIO m) =>
+    GValue                                  -- value
+    -> m Word64                             -- result
+valueGetBitmask value = liftIO $ do
+    let value' = unsafeManagedPtrGetPtr value
+    result <- gst_value_get_bitmask value'
+    touchManagedPtr value
+    return result
+
+
+-- function gst_value_fraction_subtract
+-- Args : [Arg {argCName = "dest", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "minuend", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "subtrahend", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_value_fraction_subtract" gst_value_fraction_subtract :: 
+    Ptr GValue ->                           -- dest : TInterface "GObject" "Value"
+    Ptr GValue ->                           -- minuend : TInterface "GObject" "Value"
+    Ptr GValue ->                           -- subtrahend : TInterface "GObject" "Value"
+    IO CInt
+
+
+valueFractionSubtract ::
+    (MonadIO m) =>
+    GValue                                  -- dest
+    -> GValue                               -- minuend
+    -> GValue                               -- subtrahend
+    -> m Bool                               -- result
+valueFractionSubtract dest minuend subtrahend = liftIO $ do
+    let dest' = unsafeManagedPtrGetPtr dest
+    let minuend' = unsafeManagedPtrGetPtr minuend
+    let subtrahend' = unsafeManagedPtrGetPtr subtrahend
+    result <- gst_value_fraction_subtract dest' minuend' subtrahend'
+    let result' = (/= 0) result
+    touchManagedPtr dest
+    touchManagedPtr minuend
+    touchManagedPtr subtrahend
+    return result'
+
+
+-- function gst_value_fraction_multiply
+-- Args : [Arg {argCName = "product", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "factor1", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "factor2", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_value_fraction_multiply" gst_value_fraction_multiply :: 
+    Ptr GValue ->                           -- product : TInterface "GObject" "Value"
+    Ptr GValue ->                           -- factor1 : TInterface "GObject" "Value"
+    Ptr GValue ->                           -- factor2 : TInterface "GObject" "Value"
+    IO CInt
+
+
+valueFractionMultiply ::
+    (MonadIO m) =>
+    GValue                                  -- product
+    -> GValue                               -- factor1
+    -> GValue                               -- factor2
+    -> m Bool                               -- result
+valueFractionMultiply product factor1 factor2 = liftIO $ do
+    let product' = unsafeManagedPtrGetPtr product
+    let factor1' = unsafeManagedPtrGetPtr factor1
+    let factor2' = unsafeManagedPtrGetPtr factor2
+    result <- gst_value_fraction_multiply product' factor1' factor2'
+    let result' = (/= 0) result
+    touchManagedPtr product
+    touchManagedPtr factor1
+    touchManagedPtr factor2
+    return result'
+
+
+-- function gst_value_fixate
+-- Args : [Arg {argCName = "dest", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "src", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_value_fixate" gst_value_fixate :: 
+    Ptr GValue ->                           -- dest : TInterface "GObject" "Value"
+    Ptr GValue ->                           -- src : TInterface "GObject" "Value"
+    IO CInt
+
+
+valueFixate ::
+    (MonadIO m) =>
+    GValue                                  -- dest
+    -> GValue                               -- src
+    -> m Bool                               -- result
+valueFixate dest src = liftIO $ do
+    let dest' = unsafeManagedPtrGetPtr dest
+    let src' = unsafeManagedPtrGetPtr src
+    result <- gst_value_fixate dest' src'
+    let result' = (/= 0) result
+    touchManagedPtr dest
+    touchManagedPtr src
+    return result'
+
+
+-- function gst_value_deserialize
+-- Args : [Arg {argCName = "dest", argType = TInterface "GObject" "Value", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing},Arg {argCName = "src", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_value_deserialize" gst_value_deserialize :: 
+    Ptr GValue ->                           -- dest : TInterface "GObject" "Value"
+    CString ->                              -- src : TBasicType TUTF8
+    IO CInt
+
+
+valueDeserialize ::
+    (MonadIO m) =>
+    T.Text                                  -- src
+    -> m (Bool,GValue)                      -- result
+valueDeserialize src = liftIO $ do
+    dest <- callocBoxedBytes 24 :: IO (Ptr GValue)
+    src' <- textToCString src
+    result <- gst_value_deserialize dest src'
+    let result' = (/= 0) result
+    dest' <- (wrapBoxed GValue) dest
+    freeMem src'
+    return (result', dest')
+
+
+-- function gst_value_compare
+-- Args : [Arg {argCName = "value1", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value2", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TInt32
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_value_compare" gst_value_compare :: 
+    Ptr GValue ->                           -- value1 : TInterface "GObject" "Value"
+    Ptr GValue ->                           -- value2 : TInterface "GObject" "Value"
+    IO Int32
+
+
+valueCompare ::
+    (MonadIO m) =>
+    GValue                                  -- value1
+    -> GValue                               -- value2
+    -> m Int32                              -- result
+valueCompare value1 value2 = liftIO $ do
+    let value1' = unsafeManagedPtrGetPtr value1
+    let value2' = unsafeManagedPtrGetPtr value2
+    result <- gst_value_compare value1' value2'
+    touchManagedPtr value1
+    touchManagedPtr value2
+    return result
+
+
+-- function gst_value_can_union
+-- Args : [Arg {argCName = "value1", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value2", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_value_can_union" gst_value_can_union :: 
+    Ptr GValue ->                           -- value1 : TInterface "GObject" "Value"
+    Ptr GValue ->                           -- value2 : TInterface "GObject" "Value"
+    IO CInt
+
+
+valueCanUnion ::
+    (MonadIO m) =>
+    GValue                                  -- value1
+    -> GValue                               -- value2
+    -> m Bool                               -- result
+valueCanUnion value1 value2 = liftIO $ do
+    let value1' = unsafeManagedPtrGetPtr value1
+    let value2' = unsafeManagedPtrGetPtr value2
+    result <- gst_value_can_union value1' value2'
+    let result' = (/= 0) result
+    touchManagedPtr value1
+    touchManagedPtr value2
+    return result'
+
+
+-- function gst_value_can_subtract
+-- Args : [Arg {argCName = "minuend", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "subtrahend", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_value_can_subtract" gst_value_can_subtract :: 
+    Ptr GValue ->                           -- minuend : TInterface "GObject" "Value"
+    Ptr GValue ->                           -- subtrahend : TInterface "GObject" "Value"
+    IO CInt
+
+
+valueCanSubtract ::
+    (MonadIO m) =>
+    GValue                                  -- minuend
+    -> GValue                               -- subtrahend
+    -> m Bool                               -- result
+valueCanSubtract minuend subtrahend = liftIO $ do
+    let minuend' = unsafeManagedPtrGetPtr minuend
+    let subtrahend' = unsafeManagedPtrGetPtr subtrahend
+    result <- gst_value_can_subtract minuend' subtrahend'
+    let result' = (/= 0) result
+    touchManagedPtr minuend
+    touchManagedPtr subtrahend
+    return result'
+
+
+-- function gst_value_can_intersect
+-- Args : [Arg {argCName = "value1", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value2", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_value_can_intersect" gst_value_can_intersect :: 
+    Ptr GValue ->                           -- value1 : TInterface "GObject" "Value"
+    Ptr GValue ->                           -- value2 : TInterface "GObject" "Value"
+    IO CInt
+
+
+valueCanIntersect ::
+    (MonadIO m) =>
+    GValue                                  -- value1
+    -> GValue                               -- value2
+    -> m Bool                               -- result
+valueCanIntersect value1 value2 = liftIO $ do
+    let value1' = unsafeManagedPtrGetPtr value1
+    let value2' = unsafeManagedPtrGetPtr value2
+    result <- gst_value_can_intersect value1' value2'
+    let result' = (/= 0) result
+    touchManagedPtr value1
+    touchManagedPtr value2
+    return result'
+
+
+-- function gst_value_can_compare
+-- Args : [Arg {argCName = "value1", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value2", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_value_can_compare" gst_value_can_compare :: 
+    Ptr GValue ->                           -- value1 : TInterface "GObject" "Value"
+    Ptr GValue ->                           -- value2 : TInterface "GObject" "Value"
+    IO CInt
+
+
+valueCanCompare ::
+    (MonadIO m) =>
+    GValue                                  -- value1
+    -> GValue                               -- value2
+    -> m Bool                               -- result
+valueCanCompare value1 value2 = liftIO $ do
+    let value1' = unsafeManagedPtrGetPtr value1
+    let value2' = unsafeManagedPtrGetPtr value2
+    result <- gst_value_can_compare value1' value2'
+    let result' = (/= 0) result
+    touchManagedPtr value1
+    touchManagedPtr value2
+    return result'
+
+
+-- function gst_util_uint64_scale_round
+-- Args : [Arg {argCName = "val", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "num", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "denom", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUInt64
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_util_uint64_scale_round" gst_util_uint64_scale_round :: 
+    Word64 ->                               -- val : TBasicType TUInt64
+    Word64 ->                               -- num : TBasicType TUInt64
+    Word64 ->                               -- denom : TBasicType TUInt64
+    IO Word64
+
+
+utilUint64ScaleRound ::
+    (MonadIO m) =>
+    Word64                                  -- val
+    -> Word64                               -- num
+    -> Word64                               -- denom
+    -> m Word64                             -- result
+utilUint64ScaleRound val num denom = liftIO $ do
+    result <- gst_util_uint64_scale_round val num denom
+    return result
+
+
+-- function gst_util_uint64_scale_int_round
+-- Args : [Arg {argCName = "val", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "num", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "denom", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUInt64
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_util_uint64_scale_int_round" gst_util_uint64_scale_int_round :: 
+    Word64 ->                               -- val : TBasicType TUInt64
+    Int32 ->                                -- num : TBasicType TInt32
+    Int32 ->                                -- denom : TBasicType TInt32
+    IO Word64
+
+
+utilUint64ScaleIntRound ::
+    (MonadIO m) =>
+    Word64                                  -- val
+    -> Int32                                -- num
+    -> Int32                                -- denom
+    -> m Word64                             -- result
+utilUint64ScaleIntRound val num denom = liftIO $ do
+    result <- gst_util_uint64_scale_int_round val num denom
+    return result
+
+
+-- function gst_util_uint64_scale_int_ceil
+-- Args : [Arg {argCName = "val", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "num", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "denom", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUInt64
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_util_uint64_scale_int_ceil" gst_util_uint64_scale_int_ceil :: 
+    Word64 ->                               -- val : TBasicType TUInt64
+    Int32 ->                                -- num : TBasicType TInt32
+    Int32 ->                                -- denom : TBasicType TInt32
+    IO Word64
+
+
+utilUint64ScaleIntCeil ::
+    (MonadIO m) =>
+    Word64                                  -- val
+    -> Int32                                -- num
+    -> Int32                                -- denom
+    -> m Word64                             -- result
+utilUint64ScaleIntCeil val num denom = liftIO $ do
+    result <- gst_util_uint64_scale_int_ceil val num denom
+    return result
+
+
+-- function gst_util_uint64_scale_int
+-- Args : [Arg {argCName = "val", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "num", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "denom", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUInt64
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_util_uint64_scale_int" gst_util_uint64_scale_int :: 
+    Word64 ->                               -- val : TBasicType TUInt64
+    Int32 ->                                -- num : TBasicType TInt32
+    Int32 ->                                -- denom : TBasicType TInt32
+    IO Word64
+
+
+utilUint64ScaleInt ::
+    (MonadIO m) =>
+    Word64                                  -- val
+    -> Int32                                -- num
+    -> Int32                                -- denom
+    -> m Word64                             -- result
+utilUint64ScaleInt val num denom = liftIO $ do
+    result <- gst_util_uint64_scale_int val num denom
+    return result
+
+
+-- function gst_util_uint64_scale_ceil
+-- Args : [Arg {argCName = "val", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "num", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "denom", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUInt64
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_util_uint64_scale_ceil" gst_util_uint64_scale_ceil :: 
+    Word64 ->                               -- val : TBasicType TUInt64
+    Word64 ->                               -- num : TBasicType TUInt64
+    Word64 ->                               -- denom : TBasicType TUInt64
+    IO Word64
+
+
+utilUint64ScaleCeil ::
+    (MonadIO m) =>
+    Word64                                  -- val
+    -> Word64                               -- num
+    -> Word64                               -- denom
+    -> m Word64                             -- result
+utilUint64ScaleCeil val num denom = liftIO $ do
+    result <- gst_util_uint64_scale_ceil val num denom
+    return result
+
+
+-- function gst_util_uint64_scale
+-- Args : [Arg {argCName = "val", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "num", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "denom", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUInt64
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_util_uint64_scale" gst_util_uint64_scale :: 
+    Word64 ->                               -- val : TBasicType TUInt64
+    Word64 ->                               -- num : TBasicType TUInt64
+    Word64 ->                               -- denom : TBasicType TUInt64
+    IO Word64
+
+
+utilUint64Scale ::
+    (MonadIO m) =>
+    Word64                                  -- val
+    -> Word64                               -- num
+    -> Word64                               -- denom
+    -> m Word64                             -- result
+utilUint64Scale val num denom = liftIO $ do
+    result <- gst_util_uint64_scale val num denom
+    return result
+
+
+-- function gst_util_set_value_from_string
+-- Args : [Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing},Arg {argCName = "value_str", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_util_set_value_from_string" gst_util_set_value_from_string :: 
+    Ptr GValue ->                           -- value : TInterface "GObject" "Value"
+    CString ->                              -- value_str : TBasicType TUTF8
+    IO ()
+
+
+utilSetValueFromString ::
+    (MonadIO m) =>
+    T.Text                                  -- valueStr
+    -> m (GValue)                           -- result
+utilSetValueFromString valueStr = liftIO $ do
+    value <- callocBoxedBytes 24 :: IO (Ptr GValue)
+    valueStr' <- textToCString valueStr
+    gst_util_set_value_from_string value valueStr'
+    value' <- (wrapBoxed GValue) value
+    freeMem valueStr'
+    return value'
+
+
+-- function gst_util_set_object_arg
+-- Args : [Arg {argCName = "object", argType = TInterface "GObject" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_util_set_object_arg" gst_util_set_object_arg :: 
+    Ptr GObject.Object ->                   -- object : TInterface "GObject" "Object"
+    CString ->                              -- name : TBasicType TUTF8
+    CString ->                              -- value : TBasicType TUTF8
+    IO ()
+
+
+utilSetObjectArg ::
+    (MonadIO m, GObject.ObjectK a) =>
+    a                                       -- object
+    -> T.Text                               -- name
+    -> T.Text                               -- value
+    -> m ()                                 -- result
+utilSetObjectArg object name value = liftIO $ do
+    let object' = unsafeManagedPtrCastPtr object
+    name' <- textToCString name
+    value' <- textToCString value
+    gst_util_set_object_arg object' name' value'
+    touchManagedPtr object
+    freeMem name'
+    freeMem value'
+    return ()
+
+
+-- function gst_util_seqnum_next
+-- Args : []
+-- Lengths : []
+-- returnType : TBasicType TUInt32
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_util_seqnum_next" gst_util_seqnum_next :: 
+    IO Word32
+
+
+utilSeqnumNext ::
+    (MonadIO m) =>
+    m Word32                                -- result
+utilSeqnumNext  = liftIO $ do
+    result <- gst_util_seqnum_next
+    return result
+
+
+-- function gst_util_seqnum_compare
+-- Args : [Arg {argCName = "s1", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "s2", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TInt32
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_util_seqnum_compare" gst_util_seqnum_compare :: 
+    Word32 ->                               -- s1 : TBasicType TUInt32
+    Word32 ->                               -- s2 : TBasicType TUInt32
+    IO Int32
+
+
+utilSeqnumCompare ::
+    (MonadIO m) =>
+    Word32                                  -- s1
+    -> Word32                               -- s2
+    -> m Int32                              -- result
+utilSeqnumCompare s1 s2 = liftIO $ do
+    result <- gst_util_seqnum_compare s1 s2
+    return result
+
+
+-- function gst_util_guint64_to_gdouble
+-- Args : [Arg {argCName = "value", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TDouble
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_util_guint64_to_gdouble" gst_util_guint64_to_gdouble :: 
+    Word64 ->                               -- value : TBasicType TUInt64
+    IO CDouble
+
+
+utilGuint64ToGdouble ::
+    (MonadIO m) =>
+    Word64                                  -- value
+    -> m Double                             -- result
+utilGuint64ToGdouble value = liftIO $ do
+    result <- gst_util_guint64_to_gdouble value
+    let result' = realToFrac result
+    return result'
+
+
+-- function gst_util_group_id_next
+-- Args : []
+-- Lengths : []
+-- returnType : TBasicType TUInt32
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_util_group_id_next" gst_util_group_id_next :: 
+    IO Word32
+
+
+utilGroupIdNext ::
+    (MonadIO m) =>
+    m Word32                                -- result
+utilGroupIdNext  = liftIO $ do
+    result <- gst_util_group_id_next
+    return result
+
+
+-- function gst_util_greatest_common_divisor_int64
+-- Args : [Arg {argCName = "a", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "b", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TInt64
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_util_greatest_common_divisor_int64" gst_util_greatest_common_divisor_int64 :: 
+    Int64 ->                                -- a : TBasicType TInt64
+    Int64 ->                                -- b : TBasicType TInt64
+    IO Int64
+
+
+utilGreatestCommonDivisorInt64 ::
+    (MonadIO m) =>
+    Int64                                   -- a
+    -> Int64                                -- b
+    -> m Int64                              -- result
+utilGreatestCommonDivisorInt64 a b = liftIO $ do
+    result <- gst_util_greatest_common_divisor_int64 a b
+    return result
+
+
+-- function gst_util_greatest_common_divisor
+-- Args : [Arg {argCName = "a", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "b", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TInt32
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_util_greatest_common_divisor" gst_util_greatest_common_divisor :: 
+    Int32 ->                                -- a : TBasicType TInt32
+    Int32 ->                                -- b : TBasicType TInt32
+    IO Int32
+
+
+utilGreatestCommonDivisor ::
+    (MonadIO m) =>
+    Int32                                   -- a
+    -> Int32                                -- b
+    -> m Int32                              -- result
+utilGreatestCommonDivisor a b = liftIO $ do
+    result <- gst_util_greatest_common_divisor a b
+    return result
+
+
+-- function gst_util_get_timestamp
+-- Args : []
+-- Lengths : []
+-- returnType : TBasicType TUInt64
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_util_get_timestamp" gst_util_get_timestamp :: 
+    IO Word64
+
+
+utilGetTimestamp ::
+    (MonadIO m) =>
+    m Word64                                -- result
+utilGetTimestamp  = liftIO $ do
+    result <- gst_util_get_timestamp
+    return result
+
+
+-- function gst_util_gdouble_to_guint64
+-- Args : [Arg {argCName = "value", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUInt64
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_util_gdouble_to_guint64" gst_util_gdouble_to_guint64 :: 
+    CDouble ->                              -- value : TBasicType TDouble
+    IO Word64
+
+
+utilGdoubleToGuint64 ::
+    (MonadIO m) =>
+    Double                                  -- value
+    -> m Word64                             -- result
+utilGdoubleToGuint64 value = liftIO $ do
+    let value' = realToFrac value
+    result <- gst_util_gdouble_to_guint64 value'
+    return result
+
+
+-- function gst_util_fraction_to_double
+-- Args : [Arg {argCName = "src_n", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "src_d", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest", argType = TBasicType TDouble, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_util_fraction_to_double" gst_util_fraction_to_double :: 
+    Int32 ->                                -- src_n : TBasicType TInt32
+    Int32 ->                                -- src_d : TBasicType TInt32
+    Ptr CDouble ->                          -- dest : TBasicType TDouble
+    IO ()
+
+
+utilFractionToDouble ::
+    (MonadIO m) =>
+    Int32                                   -- srcN
+    -> Int32                                -- srcD
+    -> m (Double)                           -- result
+utilFractionToDouble srcN srcD = liftIO $ do
+    dest <- allocMem :: IO (Ptr CDouble)
+    gst_util_fraction_to_double srcN srcD dest
+    dest' <- peek dest
+    let dest'' = realToFrac dest'
+    freeMem dest
+    return dest''
+
+
+-- function gst_util_fraction_multiply
+-- Args : [Arg {argCName = "a_n", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "a_d", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "b_n", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "b_d", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "res_n", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "res_d", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_util_fraction_multiply" gst_util_fraction_multiply :: 
+    Int32 ->                                -- a_n : TBasicType TInt32
+    Int32 ->                                -- a_d : TBasicType TInt32
+    Int32 ->                                -- b_n : TBasicType TInt32
+    Int32 ->                                -- b_d : TBasicType TInt32
+    Ptr Int32 ->                            -- res_n : TBasicType TInt32
+    Ptr Int32 ->                            -- res_d : TBasicType TInt32
+    IO CInt
+
+
+utilFractionMultiply ::
+    (MonadIO m) =>
+    Int32                                   -- aN
+    -> Int32                                -- aD
+    -> Int32                                -- bN
+    -> Int32                                -- bD
+    -> m (Bool,Int32,Int32)                 -- result
+utilFractionMultiply aN aD bN bD = liftIO $ do
+    resN <- allocMem :: IO (Ptr Int32)
+    resD <- allocMem :: IO (Ptr Int32)
+    result <- gst_util_fraction_multiply aN aD bN bD resN resD
+    let result' = (/= 0) result
+    resN' <- peek resN
+    resD' <- peek resD
+    freeMem resN
+    freeMem resD
+    return (result', resN', resD')
+
+
+-- function gst_util_fraction_compare
+-- Args : [Arg {argCName = "a_n", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "a_d", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "b_n", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "b_d", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TInt32
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_util_fraction_compare" gst_util_fraction_compare :: 
+    Int32 ->                                -- a_n : TBasicType TInt32
+    Int32 ->                                -- a_d : TBasicType TInt32
+    Int32 ->                                -- b_n : TBasicType TInt32
+    Int32 ->                                -- b_d : TBasicType TInt32
+    IO Int32
+
+
+utilFractionCompare ::
+    (MonadIO m) =>
+    Int32                                   -- aN
+    -> Int32                                -- aD
+    -> Int32                                -- bN
+    -> Int32                                -- bD
+    -> m Int32                              -- result
+utilFractionCompare aN aD bN bD = liftIO $ do
+    result <- gst_util_fraction_compare aN aD bN bD
+    return result
+
+
+-- function gst_util_fraction_add
+-- Args : [Arg {argCName = "a_n", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "a_d", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "b_n", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "b_d", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "res_n", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "res_d", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_util_fraction_add" gst_util_fraction_add :: 
+    Int32 ->                                -- a_n : TBasicType TInt32
+    Int32 ->                                -- a_d : TBasicType TInt32
+    Int32 ->                                -- b_n : TBasicType TInt32
+    Int32 ->                                -- b_d : TBasicType TInt32
+    Ptr Int32 ->                            -- res_n : TBasicType TInt32
+    Ptr Int32 ->                            -- res_d : TBasicType TInt32
+    IO CInt
+
+
+utilFractionAdd ::
+    (MonadIO m) =>
+    Int32                                   -- aN
+    -> Int32                                -- aD
+    -> Int32                                -- bN
+    -> Int32                                -- bD
+    -> m (Bool,Int32,Int32)                 -- result
+utilFractionAdd aN aD bN bD = liftIO $ do
+    resN <- allocMem :: IO (Ptr Int32)
+    resD <- allocMem :: IO (Ptr Int32)
+    result <- gst_util_fraction_add aN aD bN bD resN resD
+    let result' = (/= 0) result
+    resN' <- peek resN
+    resD' <- peek resD
+    freeMem resN
+    freeMem resD
+    return (result', resN', resD')
+
+
+-- function gst_util_dump_mem
+-- Args : [Arg {argCName = "mem", argType = TBasicType TUInt8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_util_dump_mem" gst_util_dump_mem :: 
+    Word8 ->                                -- mem : TBasicType TUInt8
+    Word32 ->                               -- size : TBasicType TUInt32
+    IO ()
+
+
+utilDumpMem ::
+    (MonadIO m) =>
+    Word8                                   -- mem
+    -> Word32                               -- size
+    -> m ()                                 -- result
+utilDumpMem mem size = liftIO $ do
+    gst_util_dump_mem mem size
+    return ()
+
+
+-- function gst_util_double_to_fraction
+-- Args : [Arg {argCName = "src", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest_n", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "dest_d", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_util_double_to_fraction" gst_util_double_to_fraction :: 
+    CDouble ->                              -- src : TBasicType TDouble
+    Ptr Int32 ->                            -- dest_n : TBasicType TInt32
+    Ptr Int32 ->                            -- dest_d : TBasicType TInt32
+    IO ()
+
+
+utilDoubleToFraction ::
+    (MonadIO m) =>
+    Double                                  -- src
+    -> m (Int32,Int32)                      -- result
+utilDoubleToFraction src = liftIO $ do
+    let src' = realToFrac src
+    destN <- allocMem :: IO (Ptr Int32)
+    destD <- allocMem :: IO (Ptr Int32)
+    gst_util_double_to_fraction src' destN destD
+    destN' <- peek destN
+    destD' <- peek destD
+    freeMem destN
+    freeMem destD
+    return (destN', destD')
+
+
+-- function gst_util_array_binary_search
+-- Args : [Arg {argCName = "array", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "num_elements", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "element_size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "search_func", argType = TInterface "GLib" "CompareDataFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, argClosure = 6, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mode", argType = TInterface "Gst" "SearchMode", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "search_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_util_array_binary_search" gst_util_array_binary_search :: 
+    Ptr () ->                               -- array : TBasicType TVoid
+    Word32 ->                               -- num_elements : TBasicType TUInt32
+    Word64 ->                               -- element_size : TBasicType TUInt64
+    FunPtr GLib.CompareDataFuncC ->         -- search_func : TInterface "GLib" "CompareDataFunc"
+    CUInt ->                                -- mode : TInterface "Gst" "SearchMode"
+    Ptr () ->                               -- search_data : TBasicType TVoid
+    Ptr () ->                               -- user_data : TBasicType TVoid
+    IO ()
+
+
+utilArrayBinarySearch ::
+    (MonadIO m) =>
+    Ptr ()                                  -- array
+    -> Word32                               -- numElements
+    -> Word64                               -- elementSize
+    -> GLib.CompareDataFunc                 -- searchFunc
+    -> SearchMode                           -- mode
+    -> Ptr ()                               -- searchData
+    -> m ()                                 -- result
+utilArrayBinarySearch array numElements elementSize searchFunc mode searchData = liftIO $ do
+    searchFunc' <- GLib.mkCompareDataFunc (GLib.compareDataFuncWrapper Nothing searchFunc)
+    let mode' = (fromIntegral . fromEnum) mode
+    let userData = nullPtr
+    gst_util_array_binary_search array numElements elementSize searchFunc' mode' searchData userData
+    safeFreeFunPtr $ castFunPtrToPtr searchFunc'
+    return ()
+
+
+-- function gst_update_registry
+-- Args : []
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_update_registry" gst_update_registry :: 
+    IO CInt
+
+
+updateRegistry ::
+    (MonadIO m) =>
+    m Bool                                  -- result
+updateRegistry  = liftIO $ do
+    result <- gst_update_registry
+    let result' = (/= 0) result
+    return result'
+
+
+-- function gst_type_find_get_type
+-- Args : []
+-- Lengths : []
+-- returnType : TBasicType TGType
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_type_find_get_type" gst_type_find_get_type :: 
+    IO CGType
+
+
+typeFindGetType ::
+    (MonadIO m) =>
+    m GType                                 -- result
+typeFindGetType  = liftIO $ do
+    result <- gst_type_find_get_type
+    let result' = GType result
+    return result'
+
+
+-- function gst_tag_register_static
+-- Args : [Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flag", argType = TInterface "Gst" "TagFlag", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "type", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "nick", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "blurb", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "func", argType = TInterface "Gst" "TagMergeFunc", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeCall, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_tag_register_static" gst_tag_register_static :: 
+    CString ->                              -- name : TBasicType TUTF8
+    CUInt ->                                -- flag : TInterface "Gst" "TagFlag"
+    CGType ->                               -- type : TBasicType TGType
+    CString ->                              -- nick : TBasicType TUTF8
+    CString ->                              -- blurb : TBasicType TUTF8
+    FunPtr TagMergeFuncC ->                 -- func : TInterface "Gst" "TagMergeFunc"
+    IO ()
+
+
+tagRegisterStatic ::
+    (MonadIO m) =>
+    T.Text                                  -- name
+    -> TagFlag                              -- flag
+    -> GType                                -- type_
+    -> T.Text                               -- nick
+    -> T.Text                               -- blurb
+    -> Maybe (TagMergeFunc)                 -- func
+    -> m ()                                 -- result
+tagRegisterStatic name flag type_ nick blurb func = liftIO $ do
+    name' <- textToCString name
+    let flag' = (fromIntegral . fromEnum) flag
+    let type_' = gtypeToCGType type_
+    nick' <- textToCString nick
+    blurb' <- textToCString blurb
+    maybeFunc <- case func of
+        Nothing -> return (castPtrToFunPtr nullPtr)
+        Just jFunc -> do
+            jFunc' <- mkTagMergeFunc (tagMergeFuncWrapper Nothing jFunc)
+            return jFunc'
+    gst_tag_register_static name' flag' type_' nick' blurb' maybeFunc
+    safeFreeFunPtr $ castFunPtrToPtr maybeFunc
+    freeMem name'
+    freeMem nick'
+    freeMem blurb'
+    return ()
+
+
+-- function gst_tag_register
+-- Args : [Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flag", argType = TInterface "Gst" "TagFlag", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "type", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "nick", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "blurb", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "func", argType = TInterface "Gst" "TagMergeFunc", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeCall, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_tag_register" gst_tag_register :: 
+    CString ->                              -- name : TBasicType TUTF8
+    CUInt ->                                -- flag : TInterface "Gst" "TagFlag"
+    CGType ->                               -- type : TBasicType TGType
+    CString ->                              -- nick : TBasicType TUTF8
+    CString ->                              -- blurb : TBasicType TUTF8
+    FunPtr TagMergeFuncC ->                 -- func : TInterface "Gst" "TagMergeFunc"
+    IO ()
+
+
+tagRegister ::
+    (MonadIO m) =>
+    T.Text                                  -- name
+    -> TagFlag                              -- flag
+    -> GType                                -- type_
+    -> T.Text                               -- nick
+    -> T.Text                               -- blurb
+    -> Maybe (TagMergeFunc)                 -- func
+    -> m ()                                 -- result
+tagRegister name flag type_ nick blurb func = liftIO $ do
+    name' <- textToCString name
+    let flag' = (fromIntegral . fromEnum) flag
+    let type_' = gtypeToCGType type_
+    nick' <- textToCString nick
+    blurb' <- textToCString blurb
+    maybeFunc <- case func of
+        Nothing -> return (castPtrToFunPtr nullPtr)
+        Just jFunc -> do
+            jFunc' <- mkTagMergeFunc (tagMergeFuncWrapper Nothing jFunc)
+            return jFunc'
+    gst_tag_register name' flag' type_' nick' blurb' maybeFunc
+    safeFreeFunPtr $ castFunPtrToPtr maybeFunc
+    freeMem name'
+    freeMem nick'
+    freeMem blurb'
+    return ()
+
+
+-- function gst_tag_merge_use_first
+-- Args : [Arg {argCName = "dest", argType = TInterface "GObject" "Value", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing},Arg {argCName = "src", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_tag_merge_use_first" gst_tag_merge_use_first :: 
+    Ptr GValue ->                           -- dest : TInterface "GObject" "Value"
+    Ptr GValue ->                           -- src : TInterface "GObject" "Value"
+    IO ()
+
+
+tagMergeUseFirst ::
+    (MonadIO m) =>
+    GValue                                  -- src
+    -> m (GValue)                           -- result
+tagMergeUseFirst src = liftIO $ do
+    dest <- callocBoxedBytes 24 :: IO (Ptr GValue)
+    let src' = unsafeManagedPtrGetPtr src
+    gst_tag_merge_use_first dest src'
+    dest' <- (wrapBoxed GValue) dest
+    touchManagedPtr src
+    return dest'
+
+
+-- function gst_tag_merge_strings_with_comma
+-- Args : [Arg {argCName = "dest", argType = TInterface "GObject" "Value", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing},Arg {argCName = "src", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_tag_merge_strings_with_comma" gst_tag_merge_strings_with_comma :: 
+    Ptr GValue ->                           -- dest : TInterface "GObject" "Value"
+    Ptr GValue ->                           -- src : TInterface "GObject" "Value"
+    IO ()
+
+
+tagMergeStringsWithComma ::
+    (MonadIO m) =>
+    GValue                                  -- src
+    -> m (GValue)                           -- result
+tagMergeStringsWithComma src = liftIO $ do
+    dest <- callocBoxedBytes 24 :: IO (Ptr GValue)
+    let src' = unsafeManagedPtrGetPtr src
+    gst_tag_merge_strings_with_comma dest src'
+    dest' <- (wrapBoxed GValue) dest
+    touchManagedPtr src
+    return dest'
+
+
+-- function gst_tag_is_fixed
+-- Args : [Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_tag_is_fixed" gst_tag_is_fixed :: 
+    CString ->                              -- tag : TBasicType TUTF8
+    IO CInt
+
+
+tagIsFixed ::
+    (MonadIO m) =>
+    T.Text                                  -- tag
+    -> m Bool                               -- result
+tagIsFixed tag = liftIO $ do
+    tag' <- textToCString tag
+    result <- gst_tag_is_fixed tag'
+    let result' = (/= 0) result
+    freeMem tag'
+    return result'
+
+
+-- function gst_tag_get_type
+-- Args : [Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TGType
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_tag_get_type" gst_tag_get_type :: 
+    CString ->                              -- tag : TBasicType TUTF8
+    IO CGType
+
+
+tagGetType ::
+    (MonadIO m) =>
+    T.Text                                  -- tag
+    -> m GType                              -- result
+tagGetType tag = liftIO $ do
+    tag' <- textToCString tag
+    result <- gst_tag_get_type tag'
+    let result' = GType result
+    freeMem tag'
+    return result'
+
+
+-- function gst_tag_get_nick
+-- Args : [Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUTF8
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_tag_get_nick" gst_tag_get_nick :: 
+    CString ->                              -- tag : TBasicType TUTF8
+    IO CString
+
+
+tagGetNick ::
+    (MonadIO m) =>
+    T.Text                                  -- tag
+    -> m T.Text                             -- result
+tagGetNick tag = liftIO $ do
+    tag' <- textToCString tag
+    result <- gst_tag_get_nick tag'
+    checkUnexpectedReturnNULL "gst_tag_get_nick" result
+    result' <- cstringToText result
+    freeMem tag'
+    return result'
+
+
+-- function gst_tag_get_flag
+-- Args : [Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "TagFlag"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_tag_get_flag" gst_tag_get_flag :: 
+    CString ->                              -- tag : TBasicType TUTF8
+    IO CUInt
+
+
+tagGetFlag ::
+    (MonadIO m) =>
+    T.Text                                  -- tag
+    -> m TagFlag                            -- result
+tagGetFlag tag = liftIO $ do
+    tag' <- textToCString tag
+    result <- gst_tag_get_flag tag'
+    let result' = (toEnum . fromIntegral) result
+    freeMem tag'
+    return result'
+
+
+-- function gst_tag_get_description
+-- Args : [Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUTF8
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_tag_get_description" gst_tag_get_description :: 
+    CString ->                              -- tag : TBasicType TUTF8
+    IO CString
+
+
+tagGetDescription ::
+    (MonadIO m) =>
+    T.Text                                  -- tag
+    -> m T.Text                             -- result
+tagGetDescription tag = liftIO $ do
+    tag' <- textToCString tag
+    result <- gst_tag_get_description tag'
+    checkUnexpectedReturnNULL "gst_tag_get_description" result
+    result' <- cstringToText result
+    freeMem tag'
+    return result'
+
+
+-- function gst_tag_exists
+-- Args : [Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_tag_exists" gst_tag_exists :: 
+    CString ->                              -- tag : TBasicType TUTF8
+    IO CInt
+
+
+tagExists ::
+    (MonadIO m) =>
+    T.Text                                  -- tag
+    -> m Bool                               -- result
+tagExists tag = liftIO $ do
+    tag' <- textToCString tag
+    result <- gst_tag_exists tag'
+    let result' = (/= 0) result
+    freeMem tag'
+    return result'
+
+
+-- function gst_static_pad_template_get_type
+-- Args : []
+-- Lengths : []
+-- returnType : TBasicType TGType
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_static_pad_template_get_type" gst_static_pad_template_get_type :: 
+    IO CGType
+
+
+staticPadTemplateGetType ::
+    (MonadIO m) =>
+    m GType                                 -- result
+staticPadTemplateGetType  = liftIO $ do
+    result <- gst_static_pad_template_get_type
+    let result' = GType result
+    return result'
+
+
+-- function gst_static_caps_get_type
+-- Args : []
+-- Lengths : []
+-- returnType : TBasicType TGType
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_static_caps_get_type" gst_static_caps_get_type :: 
+    IO CGType
+
+
+staticCapsGetType ::
+    (MonadIO m) =>
+    m GType                                 -- result
+staticCapsGetType  = liftIO $ do
+    result <- gst_static_caps_get_type
+    let result' = GType result
+    return result'
+
+
+-- function gst_segtrap_set_enabled
+-- Args : [Arg {argCName = "enabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_segtrap_set_enabled" gst_segtrap_set_enabled :: 
+    CInt ->                                 -- enabled : TBasicType TBoolean
+    IO ()
+
+
+segtrapSetEnabled ::
+    (MonadIO m) =>
+    Bool                                    -- enabled
+    -> m ()                                 -- result
+segtrapSetEnabled enabled = liftIO $ do
+    let enabled' = (fromIntegral . fromEnum) enabled
+    gst_segtrap_set_enabled enabled'
+    return ()
+
+
+-- function gst_segtrap_is_enabled
+-- Args : []
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_segtrap_is_enabled" gst_segtrap_is_enabled :: 
+    IO CInt
+
+
+segtrapIsEnabled ::
+    (MonadIO m) =>
+    m Bool                                  -- result
+segtrapIsEnabled  = liftIO $ do
+    result <- gst_segtrap_is_enabled
+    let result' = (/= 0) result
+    return result'
+
+
+-- function gst_protection_select_system
+-- Args : [Arg {argCName = "system_identifiers", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUTF8
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_protection_select_system" gst_protection_select_system :: 
+    CString ->                              -- system_identifiers : TBasicType TUTF8
+    IO CString
+
+
+protectionSelectSystem ::
+    (MonadIO m) =>
+    T.Text                                  -- systemIdentifiers
+    -> m T.Text                             -- result
+protectionSelectSystem systemIdentifiers = liftIO $ do
+    systemIdentifiers' <- textToCString systemIdentifiers
+    result <- gst_protection_select_system systemIdentifiers'
+    checkUnexpectedReturnNULL "gst_protection_select_system" result
+    result' <- cstringToText result
+    freeMem systemIdentifiers'
+    return result'
+
+
+-- function gst_protection_meta_api_get_type
+-- Args : []
+-- Lengths : []
+-- returnType : TBasicType TGType
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_protection_meta_api_get_type" gst_protection_meta_api_get_type :: 
+    IO CGType
+
+
+protectionMetaApiGetType ::
+    (MonadIO m) =>
+    m GType                                 -- result
+protectionMetaApiGetType  = liftIO $ do
+    result <- gst_protection_meta_api_get_type
+    let result' = GType result
+    return result'
+
+
+-- function gst_parse_launchv_full
+-- Args : [Arg {argCName = "argv", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "context", argType = TInterface "Gst" "ParseContext", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface "Gst" "ParseFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Element"
+-- throws : True
+-- Skip return : False
+
+foreign import ccall "gst_parse_launchv_full" gst_parse_launchv_full :: 
+    Ptr CString ->                          -- argv : TCArray True (-1) (-1) (TBasicType TUTF8)
+    Ptr ParseContext ->                     -- context : TInterface "Gst" "ParseContext"
+    CUInt ->                                -- flags : TInterface "Gst" "ParseFlags"
+    Ptr (Ptr GError) ->                     -- error
+    IO (Ptr Element)
+
+
+parseLaunchvFull ::
+    (MonadIO m) =>
+    [T.Text]                                -- argv
+    -> Maybe (ParseContext)                 -- context
+    -> [ParseFlags]                         -- flags
+    -> m Element                            -- result
+parseLaunchvFull argv context flags = liftIO $ do
+    argv' <- packZeroTerminatedUTF8CArray argv
+    maybeContext <- case context of
+        Nothing -> return nullPtr
+        Just jContext -> do
+            let jContext' = unsafeManagedPtrGetPtr jContext
+            return jContext'
+    let flags' = gflagsToWord flags
+    onException (do
+        result <- propagateGError $ gst_parse_launchv_full argv' maybeContext flags'
+        checkUnexpectedReturnNULL "gst_parse_launchv_full" result
+        result' <- (newObject Element) result
+        whenJust context touchManagedPtr
+        mapZeroTerminatedCArray freeMem argv'
+        freeMem argv'
+        return result'
+     ) (do
+        mapZeroTerminatedCArray freeMem argv'
+        freeMem argv'
+     )
+
+
+-- function gst_parse_launchv
+-- Args : [Arg {argCName = "argv", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Element"
+-- throws : True
+-- Skip return : False
+
+foreign import ccall "gst_parse_launchv" gst_parse_launchv :: 
+    Ptr CString ->                          -- argv : TCArray True (-1) (-1) (TBasicType TUTF8)
+    Ptr (Ptr GError) ->                     -- error
+    IO (Ptr Element)
+
+
+parseLaunchv ::
+    (MonadIO m) =>
+    [T.Text]                                -- argv
+    -> m Element                            -- result
+parseLaunchv argv = liftIO $ do
+    argv' <- packZeroTerminatedUTF8CArray argv
+    onException (do
+        result <- propagateGError $ gst_parse_launchv argv'
+        checkUnexpectedReturnNULL "gst_parse_launchv" result
+        result' <- (newObject Element) result
+        mapZeroTerminatedCArray freeMem argv'
+        freeMem argv'
+        return result'
+     ) (do
+        mapZeroTerminatedCArray freeMem argv'
+        freeMem argv'
+     )
+
+
+-- function gst_parse_launch_full
+-- Args : [Arg {argCName = "pipeline_description", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "context", argType = TInterface "Gst" "ParseContext", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface "Gst" "ParseFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Element"
+-- throws : True
+-- Skip return : False
+
+foreign import ccall "gst_parse_launch_full" gst_parse_launch_full :: 
+    CString ->                              -- pipeline_description : TBasicType TUTF8
+    Ptr ParseContext ->                     -- context : TInterface "Gst" "ParseContext"
+    CUInt ->                                -- flags : TInterface "Gst" "ParseFlags"
+    Ptr (Ptr GError) ->                     -- error
+    IO (Ptr Element)
+
+
+parseLaunchFull ::
+    (MonadIO m) =>
+    T.Text                                  -- pipelineDescription
+    -> Maybe (ParseContext)                 -- context
+    -> [ParseFlags]                         -- flags
+    -> m Element                            -- result
+parseLaunchFull pipelineDescription context flags = liftIO $ do
+    pipelineDescription' <- textToCString pipelineDescription
+    maybeContext <- case context of
+        Nothing -> return nullPtr
+        Just jContext -> do
+            let jContext' = unsafeManagedPtrGetPtr jContext
+            return jContext'
+    let flags' = gflagsToWord flags
+    onException (do
+        result <- propagateGError $ gst_parse_launch_full pipelineDescription' maybeContext flags'
+        checkUnexpectedReturnNULL "gst_parse_launch_full" result
+        result' <- (newObject Element) result
+        whenJust context touchManagedPtr
+        freeMem pipelineDescription'
+        return result'
+     ) (do
+        freeMem pipelineDescription'
+     )
+
+
+-- function gst_parse_launch
+-- Args : [Arg {argCName = "pipeline_description", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Element"
+-- throws : True
+-- Skip return : False
+
+foreign import ccall "gst_parse_launch" gst_parse_launch :: 
+    CString ->                              -- pipeline_description : TBasicType TUTF8
+    Ptr (Ptr GError) ->                     -- error
+    IO (Ptr Element)
+
+
+parseLaunch ::
+    (MonadIO m) =>
+    T.Text                                  -- pipelineDescription
+    -> m Element                            -- result
+parseLaunch pipelineDescription = liftIO $ do
+    pipelineDescription' <- textToCString pipelineDescription
+    onException (do
+        result <- propagateGError $ gst_parse_launch pipelineDescription'
+        checkUnexpectedReturnNULL "gst_parse_launch" result
+        result' <- (newObject Element) result
+        freeMem pipelineDescription'
+        return result'
+     ) (do
+        freeMem pipelineDescription'
+     )
+
+
+-- function gst_parse_bin_from_description_full
+-- Args : [Arg {argCName = "bin_description", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "ghost_unlinked_pads", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "context", argType = TInterface "Gst" "ParseContext", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface "Gst" "ParseFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Element"
+-- throws : True
+-- Skip return : False
+
+foreign import ccall "gst_parse_bin_from_description_full" gst_parse_bin_from_description_full :: 
+    CString ->                              -- bin_description : TBasicType TUTF8
+    CInt ->                                 -- ghost_unlinked_pads : TBasicType TBoolean
+    Ptr ParseContext ->                     -- context : TInterface "Gst" "ParseContext"
+    CUInt ->                                -- flags : TInterface "Gst" "ParseFlags"
+    Ptr (Ptr GError) ->                     -- error
+    IO (Ptr Element)
+
+
+parseBinFromDescriptionFull ::
+    (MonadIO m) =>
+    T.Text                                  -- binDescription
+    -> Bool                                 -- ghostUnlinkedPads
+    -> Maybe (ParseContext)                 -- context
+    -> [ParseFlags]                         -- flags
+    -> m Element                            -- result
+parseBinFromDescriptionFull binDescription ghostUnlinkedPads context flags = liftIO $ do
+    binDescription' <- textToCString binDescription
+    let ghostUnlinkedPads' = (fromIntegral . fromEnum) ghostUnlinkedPads
+    maybeContext <- case context of
+        Nothing -> return nullPtr
+        Just jContext -> do
+            let jContext' = unsafeManagedPtrGetPtr jContext
+            return jContext'
+    let flags' = gflagsToWord flags
+    onException (do
+        result <- propagateGError $ gst_parse_bin_from_description_full binDescription' ghostUnlinkedPads' maybeContext flags'
+        checkUnexpectedReturnNULL "gst_parse_bin_from_description_full" result
+        result' <- (newObject Element) result
+        whenJust context touchManagedPtr
+        freeMem binDescription'
+        return result'
+     ) (do
+        freeMem binDescription'
+     )
+
+
+-- function gst_parse_bin_from_description
+-- Args : [Arg {argCName = "bin_description", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "ghost_unlinked_pads", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Bin"
+-- throws : True
+-- Skip return : False
+
+foreign import ccall "gst_parse_bin_from_description" gst_parse_bin_from_description :: 
+    CString ->                              -- bin_description : TBasicType TUTF8
+    CInt ->                                 -- ghost_unlinked_pads : TBasicType TBoolean
+    Ptr (Ptr GError) ->                     -- error
+    IO (Ptr Bin)
+
+
+parseBinFromDescription ::
+    (MonadIO m) =>
+    T.Text                                  -- binDescription
+    -> Bool                                 -- ghostUnlinkedPads
+    -> m Bin                                -- result
+parseBinFromDescription binDescription ghostUnlinkedPads = liftIO $ do
+    binDescription' <- textToCString binDescription
+    let ghostUnlinkedPads' = (fromIntegral . fromEnum) ghostUnlinkedPads
+    onException (do
+        result <- propagateGError $ gst_parse_bin_from_description binDescription' ghostUnlinkedPads'
+        checkUnexpectedReturnNULL "gst_parse_bin_from_description" result
+        result' <- (newObject Bin) result
+        freeMem binDescription'
+        return result'
+     ) (do
+        freeMem binDescription'
+     )
+
+
+-- function gst_parent_buffer_meta_api_get_type
+-- Args : []
+-- Lengths : []
+-- returnType : TBasicType TGType
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_parent_buffer_meta_api_get_type" gst_parent_buffer_meta_api_get_type :: 
+    IO CGType
+
+
+parentBufferMetaApiGetType ::
+    (MonadIO m) =>
+    m GType                                 -- result
+parentBufferMetaApiGetType  = liftIO $ do
+    result <- gst_parent_buffer_meta_api_get_type
+    let result' = GType result
+    return result'
+
+
+-- function gst_param_spec_fraction
+-- Args : [Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "nick", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "blurb", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "min_num", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "min_denom", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "max_num", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "max_denom", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "default_num", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "default_denom", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface "GObject" "ParamFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TParamSpec
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_param_spec_fraction" gst_param_spec_fraction :: 
+    CString ->                              -- name : TBasicType TUTF8
+    CString ->                              -- nick : TBasicType TUTF8
+    CString ->                              -- blurb : TBasicType TUTF8
+    Int32 ->                                -- min_num : TBasicType TInt32
+    Int32 ->                                -- min_denom : TBasicType TInt32
+    Int32 ->                                -- max_num : TBasicType TInt32
+    Int32 ->                                -- max_denom : TBasicType TInt32
+    Int32 ->                                -- default_num : TBasicType TInt32
+    Int32 ->                                -- default_denom : TBasicType TInt32
+    CUInt ->                                -- flags : TInterface "GObject" "ParamFlags"
+    IO (Ptr GParamSpec)
+
+
+paramSpecFraction ::
+    (MonadIO m) =>
+    T.Text                                  -- name
+    -> T.Text                               -- nick
+    -> T.Text                               -- blurb
+    -> Int32                                -- minNum
+    -> Int32                                -- minDenom
+    -> Int32                                -- maxNum
+    -> Int32                                -- maxDenom
+    -> Int32                                -- defaultNum
+    -> Int32                                -- defaultDenom
+    -> [GObject.ParamFlags]                 -- flags
+    -> m GParamSpec                         -- result
+paramSpecFraction name nick blurb minNum minDenom maxNum maxDenom defaultNum defaultDenom flags = liftIO $ do
+    name' <- textToCString name
+    nick' <- textToCString nick
+    blurb' <- textToCString blurb
+    let flags' = gflagsToWord flags
+    result <- gst_param_spec_fraction name' nick' blurb' minNum minDenom maxNum maxDenom defaultNum defaultDenom flags'
+    checkUnexpectedReturnNULL "gst_param_spec_fraction" result
+    result' <- wrapGParamSpecPtr result
+    freeMem name'
+    freeMem nick'
+    freeMem blurb'
+    return result'
+
+
+-- function gst_is_initialized
+-- Args : []
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_is_initialized" gst_is_initialized :: 
+    IO CInt
+
+
+isInitialized ::
+    (MonadIO m) =>
+    m Bool                                  -- result
+isInitialized  = liftIO $ do
+    result <- gst_is_initialized
+    let result' = (/= 0) result
+    return result'
+
+
+-- function gst_is_caps_features
+-- Args : [Arg {argCName = "obj", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_is_caps_features" gst_is_caps_features :: 
+    Ptr () ->                               -- obj : TBasicType TVoid
+    IO CInt
+
+
+isCapsFeatures ::
+    (MonadIO m) =>
+    Ptr ()                                  -- obj
+    -> m Bool                               -- result
+isCapsFeatures obj = liftIO $ do
+    result <- gst_is_caps_features obj
+    let result' = (/= 0) result
+    return result'
+
+
+-- function gst_init_check
+-- XXX Could not generate function gst_init_check
+-- Error was : Bad introspection data: "argument \"argc\" is not of nullable type (TBasicType TInt32), but it is marked as such."
+
+-- function gst_init
+-- XXX Could not generate function gst_init
+-- Error was : Bad introspection data: "argument \"argc\" is not of nullable type (TBasicType TInt32), but it is marked as such."
+
+-- function gst_formats_contains
+-- Args : [Arg {argCName = "formats", argType = TCArray True (-1) (-1) (TInterface "Gst" "Format"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_formats_contains" gst_formats_contains :: 
+    Ptr CUInt ->                            -- formats : TCArray True (-1) (-1) (TInterface "Gst" "Format")
+    CUInt ->                                -- format : TInterface "Gst" "Format"
+    IO CInt
+
+
+formatsContains ::
+    (MonadIO m) =>
+    [Format]                                -- formats
+    -> Format                               -- format
+    -> m Bool                               -- result
+formatsContains formats format = liftIO $ do
+    let formats' = map (fromIntegral . fromEnum) formats
+    formats'' <- packZeroTerminatedStorableArray formats'
+    let format' = (fromIntegral . fromEnum) format
+    result <- gst_formats_contains formats'' format'
+    let result' = (/= 0) result
+    freeMem formats''
+    return result'
+
+
+-- function gst_flow_to_quark
+-- Args : [Arg {argCName = "ret", argType = TInterface "Gst" "FlowReturn", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUInt32
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_flow_to_quark" gst_flow_to_quark :: 
+    CUInt ->                                -- ret : TInterface "Gst" "FlowReturn"
+    IO Word32
+
+
+flowToQuark ::
+    (MonadIO m) =>
+    FlowReturn                              -- ret
+    -> m Word32                             -- result
+flowToQuark ret = liftIO $ do
+    let ret' = (fromIntegral . fromEnum) ret
+    result <- gst_flow_to_quark ret'
+    return result
+
+
+-- function gst_flow_get_name
+-- Args : [Arg {argCName = "ret", argType = TInterface "Gst" "FlowReturn", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUTF8
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_flow_get_name" gst_flow_get_name :: 
+    CUInt ->                                -- ret : TInterface "Gst" "FlowReturn"
+    IO CString
+
+
+flowGetName ::
+    (MonadIO m) =>
+    FlowReturn                              -- ret
+    -> m T.Text                             -- result
+flowGetName ret = liftIO $ do
+    let ret' = (fromIntegral . fromEnum) ret
+    result <- gst_flow_get_name ret'
+    checkUnexpectedReturnNULL "gst_flow_get_name" result
+    result' <- cstringToText result
+    return result'
+
+
+-- function gst_filename_to_uri
+-- Args : [Arg {argCName = "filename", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUTF8
+-- throws : True
+-- Skip return : False
+
+foreign import ccall "gst_filename_to_uri" gst_filename_to_uri :: 
+    CString ->                              -- filename : TBasicType TUTF8
+    Ptr (Ptr GError) ->                     -- error
+    IO CString
+
+
+filenameToUri ::
+    (MonadIO m) =>
+    T.Text                                  -- filename
+    -> m T.Text                             -- result
+filenameToUri filename = liftIO $ do
+    filename' <- textToCString filename
+    onException (do
+        result <- propagateGError $ gst_filename_to_uri filename'
+        checkUnexpectedReturnNULL "gst_filename_to_uri" result
+        result' <- cstringToText result
+        freeMem result
+        freeMem filename'
+        return result'
+     ) (do
+        freeMem filename'
+     )
+
+
+-- function gst_error_get_message
+-- Args : [Arg {argCName = "domain", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "code", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUTF8
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_error_get_message" gst_error_get_message :: 
+    Word32 ->                               -- domain : TBasicType TUInt32
+    Int32 ->                                -- code : TBasicType TInt32
+    IO CString
+
+
+errorGetMessage ::
+    (MonadIO m) =>
+    Word32                                  -- domain
+    -> Int32                                -- code
+    -> m T.Text                             -- result
+errorGetMessage domain code = liftIO $ do
+    result <- gst_error_get_message domain code
+    checkUnexpectedReturnNULL "gst_error_get_message" result
+    result' <- cstringToText result
+    freeMem result
+    return result'
+
+
+-- function gst_deinit
+-- Args : []
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_deinit" gst_deinit :: 
+    IO ()
+
+
+deinit ::
+    (MonadIO m) =>
+    m ()                                    -- result
+deinit  = liftIO $ do
+    gst_deinit
+    return ()
+
+
+-- function gst_debug_unset_threshold_for_name
+-- Args : [Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_debug_unset_threshold_for_name" gst_debug_unset_threshold_for_name :: 
+    CString ->                              -- name : TBasicType TUTF8
+    IO ()
+
+
+debugUnsetThresholdForName ::
+    (MonadIO m) =>
+    T.Text                                  -- name
+    -> m ()                                 -- result
+debugUnsetThresholdForName name = liftIO $ do
+    name' <- textToCString name
+    gst_debug_unset_threshold_for_name name'
+    freeMem name'
+    return ()
+
+
+-- function gst_debug_set_threshold_from_string
+-- Args : [Arg {argCName = "list", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "reset", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_debug_set_threshold_from_string" gst_debug_set_threshold_from_string :: 
+    CString ->                              -- list : TBasicType TUTF8
+    CInt ->                                 -- reset : TBasicType TBoolean
+    IO ()
+
+
+debugSetThresholdFromString ::
+    (MonadIO m) =>
+    T.Text                                  -- list
+    -> Bool                                 -- reset
+    -> m ()                                 -- result
+debugSetThresholdFromString list reset = liftIO $ do
+    list' <- textToCString list
+    let reset' = (fromIntegral . fromEnum) reset
+    gst_debug_set_threshold_from_string list' reset'
+    freeMem list'
+    return ()
+
+
+-- function gst_debug_set_threshold_for_name
+-- Args : [Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "level", argType = TInterface "Gst" "DebugLevel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_debug_set_threshold_for_name" gst_debug_set_threshold_for_name :: 
+    CString ->                              -- name : TBasicType TUTF8
+    CUInt ->                                -- level : TInterface "Gst" "DebugLevel"
+    IO ()
+
+
+debugSetThresholdForName ::
+    (MonadIO m) =>
+    T.Text                                  -- name
+    -> DebugLevel                           -- level
+    -> m ()                                 -- result
+debugSetThresholdForName name level = liftIO $ do
+    name' <- textToCString name
+    let level' = (fromIntegral . fromEnum) level
+    gst_debug_set_threshold_for_name name' level'
+    freeMem name'
+    return ()
+
+
+-- function gst_debug_set_default_threshold
+-- Args : [Arg {argCName = "level", argType = TInterface "Gst" "DebugLevel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_debug_set_default_threshold" gst_debug_set_default_threshold :: 
+    CUInt ->                                -- level : TInterface "Gst" "DebugLevel"
+    IO ()
+
+
+debugSetDefaultThreshold ::
+    (MonadIO m) =>
+    DebugLevel                              -- level
+    -> m ()                                 -- result
+debugSetDefaultThreshold level = liftIO $ do
+    let level' = (fromIntegral . fromEnum) level
+    gst_debug_set_default_threshold level'
+    return ()
+
+
+-- function gst_debug_set_colored
+-- Args : [Arg {argCName = "colored", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_debug_set_colored" gst_debug_set_colored :: 
+    CInt ->                                 -- colored : TBasicType TBoolean
+    IO ()
+
+
+debugSetColored ::
+    (MonadIO m) =>
+    Bool                                    -- colored
+    -> m ()                                 -- result
+debugSetColored colored = liftIO $ do
+    let colored' = (fromIntegral . fromEnum) colored
+    gst_debug_set_colored colored'
+    return ()
+
+
+-- function gst_debug_set_color_mode_from_string
+-- Args : [Arg {argCName = "mode", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_debug_set_color_mode_from_string" gst_debug_set_color_mode_from_string :: 
+    CString ->                              -- mode : TBasicType TUTF8
+    IO ()
+
+
+debugSetColorModeFromString ::
+    (MonadIO m) =>
+    T.Text                                  -- mode
+    -> m ()                                 -- result
+debugSetColorModeFromString mode = liftIO $ do
+    mode' <- textToCString mode
+    gst_debug_set_color_mode_from_string mode'
+    freeMem mode'
+    return ()
+
+
+-- function gst_debug_set_color_mode
+-- Args : [Arg {argCName = "mode", argType = TInterface "Gst" "DebugColorMode", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_debug_set_color_mode" gst_debug_set_color_mode :: 
+    CUInt ->                                -- mode : TInterface "Gst" "DebugColorMode"
+    IO ()
+
+
+debugSetColorMode ::
+    (MonadIO m) =>
+    DebugColorMode                          -- mode
+    -> m ()                                 -- result
+debugSetColorMode mode = liftIO $ do
+    let mode' = (fromIntegral . fromEnum) mode
+    gst_debug_set_color_mode mode'
+    return ()
+
+
+-- function gst_debug_set_active
+-- Args : [Arg {argCName = "active", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_debug_set_active" gst_debug_set_active :: 
+    CInt ->                                 -- active : TBasicType TBoolean
+    IO ()
+
+
+debugSetActive ::
+    (MonadIO m) =>
+    Bool                                    -- active
+    -> m ()                                 -- result
+debugSetActive active = liftIO $ do
+    let active' = (fromIntegral . fromEnum) active
+    gst_debug_set_active active'
+    return ()
+
+
+-- function gst_debug_remove_log_function_by_data
+-- Args : [Arg {argCName = "data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUInt32
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_debug_remove_log_function_by_data" gst_debug_remove_log_function_by_data :: 
+    Ptr () ->                               -- data : TBasicType TVoid
+    IO Word32
+
+
+debugRemoveLogFunctionByData ::
+    (MonadIO m) =>
+    Ptr ()                                  -- data_
+    -> m Word32                             -- result
+debugRemoveLogFunctionByData data_ = liftIO $ do
+    result <- gst_debug_remove_log_function_by_data data_
+    return result
+
+
+-- function gst_debug_remove_log_function
+-- Args : [Arg {argCName = "func", argType = TInterface "Gst" "LogFunction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUInt32
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_debug_remove_log_function" gst_debug_remove_log_function :: 
+    FunPtr LogFunctionC ->                  -- func : TInterface "Gst" "LogFunction"
+    IO Word32
+
+
+debugRemoveLogFunction ::
+    (MonadIO m) =>
+    LogFunction                             -- func
+    -> m Word32                             -- result
+debugRemoveLogFunction func = liftIO $ do
+    func' <- mkLogFunction (logFunctionWrapper Nothing func)
+    result <- gst_debug_remove_log_function func'
+    safeFreeFunPtr $ castFunPtrToPtr func'
+    return result
+
+
+-- function gst_debug_print_stack_trace
+-- Args : []
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_debug_print_stack_trace" gst_debug_print_stack_trace :: 
+    IO ()
+
+
+debugPrintStackTrace ::
+    (MonadIO m) =>
+    m ()                                    -- result
+debugPrintStackTrace  = liftIO $ do
+    gst_debug_print_stack_trace
+    return ()
+
+
+-- function gst_debug_log_default
+-- Args : [Arg {argCName = "category", argType = TInterface "Gst" "DebugCategory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "level", argType = TInterface "Gst" "DebugLevel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "file", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "function", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "line", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "object", argType = TInterface "GObject" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "message", argType = TInterface "Gst" "DebugMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_debug_log_default" gst_debug_log_default :: 
+    Ptr DebugCategory ->                    -- category : TInterface "Gst" "DebugCategory"
+    CUInt ->                                -- level : TInterface "Gst" "DebugLevel"
+    CString ->                              -- file : TBasicType TUTF8
+    CString ->                              -- function : TBasicType TUTF8
+    Int32 ->                                -- line : TBasicType TInt32
+    Ptr GObject.Object ->                   -- object : TInterface "GObject" "Object"
+    Ptr DebugMessage ->                     -- message : TInterface "Gst" "DebugMessage"
+    Ptr () ->                               -- user_data : TBasicType TVoid
+    IO ()
+
+
+debugLogDefault ::
+    (MonadIO m, GObject.ObjectK a) =>
+    DebugCategory                           -- category
+    -> DebugLevel                           -- level
+    -> T.Text                               -- file
+    -> T.Text                               -- function
+    -> Int32                                -- line
+    -> Maybe (a)                            -- object
+    -> DebugMessage                         -- message
+    -> Ptr ()                               -- userData
+    -> m ()                                 -- result
+debugLogDefault category level file function line object message userData = liftIO $ do
+    let category' = unsafeManagedPtrGetPtr category
+    let level' = (fromIntegral . fromEnum) level
+    file' <- textToCString file
+    function' <- textToCString function
+    maybeObject <- case object of
+        Nothing -> return nullPtr
+        Just jObject -> do
+            let jObject' = unsafeManagedPtrCastPtr jObject
+            return jObject'
+    let message' = unsafeManagedPtrGetPtr message
+    gst_debug_log_default category' level' file' function' line maybeObject message' userData
+    touchManagedPtr category
+    whenJust object touchManagedPtr
+    touchManagedPtr message
+    freeMem file'
+    freeMem function'
+    return ()
+
+
+-- function gst_debug_is_colored
+-- Args : []
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_debug_is_colored" gst_debug_is_colored :: 
+    IO CInt
+
+
+debugIsColored ::
+    (MonadIO m) =>
+    m Bool                                  -- result
+debugIsColored  = liftIO $ do
+    result <- gst_debug_is_colored
+    let result' = (/= 0) result
+    return result'
+
+
+-- function gst_debug_is_active
+-- Args : []
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_debug_is_active" gst_debug_is_active :: 
+    IO CInt
+
+
+debugIsActive ::
+    (MonadIO m) =>
+    m Bool                                  -- result
+debugIsActive  = liftIO $ do
+    result <- gst_debug_is_active
+    let result' = (/= 0) result
+    return result'
+
+
+-- function gst_debug_get_default_threshold
+-- Args : []
+-- Lengths : []
+-- returnType : TInterface "Gst" "DebugLevel"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_debug_get_default_threshold" gst_debug_get_default_threshold :: 
+    IO CUInt
+
+
+debugGetDefaultThreshold ::
+    (MonadIO m) =>
+    m DebugLevel                            -- result
+debugGetDefaultThreshold  = liftIO $ do
+    result <- gst_debug_get_default_threshold
+    let result' = (toEnum . fromIntegral) result
+    return result'
+
+
+-- function gst_debug_get_color_mode
+-- Args : []
+-- Lengths : []
+-- returnType : TInterface "Gst" "DebugColorMode"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_debug_get_color_mode" gst_debug_get_color_mode :: 
+    IO CUInt
+
+
+debugGetColorMode ::
+    (MonadIO m) =>
+    m DebugColorMode                        -- result
+debugGetColorMode  = liftIO $ do
+    result <- gst_debug_get_color_mode
+    let result' = (toEnum . fromIntegral) result
+    return result'
+
+
+-- function gst_debug_get_all_categories
+-- Args : []
+-- Lengths : []
+-- returnType : TGSList (TInterface "Gst" "DebugCategory")
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_debug_get_all_categories" gst_debug_get_all_categories :: 
+    IO (Ptr (GSList (Ptr DebugCategory)))
+
+
+debugGetAllCategories ::
+    (MonadIO m) =>
+    m [DebugCategory]                       -- result
+debugGetAllCategories  = liftIO $ do
+    result <- gst_debug_get_all_categories
+    checkUnexpectedReturnNULL "gst_debug_get_all_categories" result
+    result' <- unpackGSList result
+    result'' <- mapM (newPtr 24 DebugCategory) result'
+    g_slist_free result
+    return result''
+
+
+-- function gst_debug_construct_win_color
+-- Args : [Arg {argCName = "colorinfo", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TInt32
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_debug_construct_win_color" gst_debug_construct_win_color :: 
+    Word32 ->                               -- colorinfo : TBasicType TUInt32
+    IO Int32
+
+
+debugConstructWinColor ::
+    (MonadIO m) =>
+    Word32                                  -- colorinfo
+    -> m Int32                              -- result
+debugConstructWinColor colorinfo = liftIO $ do
+    result <- gst_debug_construct_win_color colorinfo
+    return result
+
+
+-- function gst_debug_construct_term_color
+-- Args : [Arg {argCName = "colorinfo", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUTF8
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_debug_construct_term_color" gst_debug_construct_term_color :: 
+    Word32 ->                               -- colorinfo : TBasicType TUInt32
+    IO CString
+
+
+debugConstructTermColor ::
+    (MonadIO m) =>
+    Word32                                  -- colorinfo
+    -> m T.Text                             -- result
+debugConstructTermColor colorinfo = liftIO $ do
+    result <- gst_debug_construct_term_color colorinfo
+    checkUnexpectedReturnNULL "gst_debug_construct_term_color" result
+    result' <- cstringToText result
+    freeMem result
+    return result'
+
+
+-- function gst_debug_bin_to_dot_file_with_ts
+-- Args : [Arg {argCName = "bin", argType = TInterface "Gst" "Bin", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "details", argType = TInterface "Gst" "DebugGraphDetails", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "file_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_debug_bin_to_dot_file_with_ts" gst_debug_bin_to_dot_file_with_ts :: 
+    Ptr Bin ->                              -- bin : TInterface "Gst" "Bin"
+    CUInt ->                                -- details : TInterface "Gst" "DebugGraphDetails"
+    CString ->                              -- file_name : TBasicType TUTF8
+    IO ()
+
+
+debugBinToDotFileWithTs ::
+    (MonadIO m, BinK a) =>
+    a                                       -- bin
+    -> [DebugGraphDetails]                  -- details
+    -> T.Text                               -- fileName
+    -> m ()                                 -- result
+debugBinToDotFileWithTs bin details fileName = liftIO $ do
+    let bin' = unsafeManagedPtrCastPtr bin
+    let details' = gflagsToWord details
+    fileName' <- textToCString fileName
+    gst_debug_bin_to_dot_file_with_ts bin' details' fileName'
+    touchManagedPtr bin
+    freeMem fileName'
+    return ()
+
+
+-- function gst_debug_bin_to_dot_file
+-- Args : [Arg {argCName = "bin", argType = TInterface "Gst" "Bin", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "details", argType = TInterface "Gst" "DebugGraphDetails", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "file_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_debug_bin_to_dot_file" gst_debug_bin_to_dot_file :: 
+    Ptr Bin ->                              -- bin : TInterface "Gst" "Bin"
+    CUInt ->                                -- details : TInterface "Gst" "DebugGraphDetails"
+    CString ->                              -- file_name : TBasicType TUTF8
+    IO ()
+
+
+debugBinToDotFile ::
+    (MonadIO m, BinK a) =>
+    a                                       -- bin
+    -> [DebugGraphDetails]                  -- details
+    -> T.Text                               -- fileName
+    -> m ()                                 -- result
+debugBinToDotFile bin details fileName = liftIO $ do
+    let bin' = unsafeManagedPtrCastPtr bin
+    let details' = gflagsToWord details
+    fileName' <- textToCString fileName
+    gst_debug_bin_to_dot_file bin' details' fileName'
+    touchManagedPtr bin
+    freeMem fileName'
+    return ()
+
+
+-- function gst_debug_bin_to_dot_data
+-- Args : [Arg {argCName = "bin", argType = TInterface "Gst" "Bin", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "details", argType = TInterface "Gst" "DebugGraphDetails", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUTF8
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_debug_bin_to_dot_data" gst_debug_bin_to_dot_data :: 
+    Ptr Bin ->                              -- bin : TInterface "Gst" "Bin"
+    CUInt ->                                -- details : TInterface "Gst" "DebugGraphDetails"
+    IO CString
+
+
+debugBinToDotData ::
+    (MonadIO m, BinK a) =>
+    a                                       -- bin
+    -> [DebugGraphDetails]                  -- details
+    -> m T.Text                             -- result
+debugBinToDotData bin details = liftIO $ do
+    let bin' = unsafeManagedPtrCastPtr bin
+    let details' = gflagsToWord details
+    result <- gst_debug_bin_to_dot_data bin' details'
+    checkUnexpectedReturnNULL "gst_debug_bin_to_dot_data" result
+    result' <- cstringToText result
+    freeMem result
+    touchManagedPtr bin
+    return result'
+
+
+-- function gst_debug_add_log_function
+-- Args : [Arg {argCName = "func", argType = TInterface "Gst" "LogFunction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeNotified, argClosure = 1, argDestroy = 2, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "notify", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_debug_add_log_function" gst_debug_add_log_function :: 
+    FunPtr LogFunctionC ->                  -- func : TInterface "Gst" "LogFunction"
+    Ptr () ->                               -- user_data : TBasicType TVoid
+    FunPtr GLib.DestroyNotifyC ->           -- notify : TInterface "GLib" "DestroyNotify"
+    IO ()
+
+
+debugAddLogFunction ::
+    (MonadIO m) =>
+    LogFunction                             -- func
+    -> m ()                                 -- result
+debugAddLogFunction func = liftIO $ do
+    func' <- mkLogFunction (logFunctionWrapper Nothing func)
+    let userData = castFunPtrToPtr func'
+    let notify = safeFreeFunPtrPtr
+    gst_debug_add_log_function func' userData notify
+    return ()
+
+
+
diff --git a/GI/Gst/Interfaces.hs b/GI/Gst/Interfaces.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Interfaces.hs
@@ -0,0 +1,35 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+-}
+
+module GI.Gst.Interfaces
+    (     module GI.Gst.Interfaces.ChildProxy     ,
+    module GI.Gst.Interfaces.Preset         ,
+    module GI.Gst.Interfaces.TagSetter      ,
+    module GI.Gst.Interfaces.TocSetter      ,
+    module GI.Gst.Interfaces.URIHandler     ,
+
+
+    ) where
+
+import GI.Gst.Interfaces.ChildProxy
+import GI.Gst.Interfaces.Preset
+import GI.Gst.Interfaces.TagSetter
+import GI.Gst.Interfaces.TocSetter
+import GI.Gst.Interfaces.URIHandler
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+import GI.Gst.Callbacks
+
+
diff --git a/GI/Gst/Interfaces/ChildProxy.hs b/GI/Gst/Interfaces/ChildProxy.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Interfaces/ChildProxy.hs
@@ -0,0 +1,542 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+-}
+
+module GI.Gst.Interfaces.ChildProxy
+    ( 
+
+-- * Exported types
+    ChildProxy(..)                          ,
+    noChildProxy                            ,
+    ChildProxyK                             ,
+    toChildProxy                            ,
+
+
+ -- * Methods
+-- ** childProxyChildAdded
+    ChildProxyChildAddedMethodInfo          ,
+    childProxyChildAdded                    ,
+
+
+-- ** childProxyChildRemoved
+    ChildProxyChildRemovedMethodInfo        ,
+    childProxyChildRemoved                  ,
+
+
+-- ** childProxyGetChildByIndex
+    ChildProxyGetChildByIndexMethodInfo     ,
+    childProxyGetChildByIndex               ,
+
+
+-- ** childProxyGetChildByName
+    ChildProxyGetChildByNameMethodInfo      ,
+    childProxyGetChildByName                ,
+
+
+-- ** childProxyGetChildrenCount
+    ChildProxyGetChildrenCountMethodInfo    ,
+    childProxyGetChildrenCount              ,
+
+
+-- ** childProxyGetProperty
+    ChildProxyGetPropertyMethodInfo         ,
+    childProxyGetProperty                   ,
+
+
+-- ** childProxyLookup
+    ChildProxyLookupMethodInfo              ,
+    childProxyLookup                        ,
+
+
+-- ** childProxySetProperty
+    ChildProxySetPropertyMethodInfo         ,
+    childProxySetProperty                   ,
+
+
+
+
+ -- * Signals
+-- ** ChildAdded
+    ChildProxyChildAddedCallback            ,
+    ChildProxyChildAddedCallbackC           ,
+    ChildProxyChildAddedSignalInfo          ,
+    afterChildProxyChildAdded               ,
+    childProxyChildAddedCallbackWrapper     ,
+    childProxyChildAddedClosure             ,
+    mkChildProxyChildAddedCallback          ,
+    noChildProxyChildAddedCallback          ,
+    onChildProxyChildAdded                  ,
+
+
+-- ** ChildRemoved
+    ChildProxyChildRemovedCallback          ,
+    ChildProxyChildRemovedCallbackC         ,
+    ChildProxyChildRemovedSignalInfo        ,
+    afterChildProxyChildRemoved             ,
+    childProxyChildRemovedCallbackWrapper   ,
+    childProxyChildRemovedClosure           ,
+    mkChildProxyChildRemovedCallback        ,
+    noChildProxyChildRemovedCallback        ,
+    onChildProxyChildRemoved                ,
+
+
+
+
+    ) where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+import GI.Gst.Callbacks
+import qualified GI.GObject as GObject
+
+-- interface ChildProxy 
+
+newtype ChildProxy = ChildProxy (ForeignPtr ChildProxy)
+noChildProxy :: Maybe ChildProxy
+noChildProxy = Nothing
+
+type family ResolveChildProxyMethod (t :: Symbol) (o :: *) :: * where
+    ResolveChildProxyMethod "bindProperty" o = GObject.ObjectBindPropertyMethodInfo
+    ResolveChildProxyMethod "bindPropertyFull" o = GObject.ObjectBindPropertyFullMethodInfo
+    ResolveChildProxyMethod "childAdded" o = ChildProxyChildAddedMethodInfo
+    ResolveChildProxyMethod "childRemoved" o = ChildProxyChildRemovedMethodInfo
+    ResolveChildProxyMethod "forceFloating" o = GObject.ObjectForceFloatingMethodInfo
+    ResolveChildProxyMethod "freezeNotify" o = GObject.ObjectFreezeNotifyMethodInfo
+    ResolveChildProxyMethod "isFloating" o = GObject.ObjectIsFloatingMethodInfo
+    ResolveChildProxyMethod "lookup" o = ChildProxyLookupMethodInfo
+    ResolveChildProxyMethod "notify" o = GObject.ObjectNotifyMethodInfo
+    ResolveChildProxyMethod "notifyByPspec" o = GObject.ObjectNotifyByPspecMethodInfo
+    ResolveChildProxyMethod "ref" o = GObject.ObjectRefMethodInfo
+    ResolveChildProxyMethod "refSink" o = GObject.ObjectRefSinkMethodInfo
+    ResolveChildProxyMethod "replaceData" o = GObject.ObjectReplaceDataMethodInfo
+    ResolveChildProxyMethod "replaceQdata" o = GObject.ObjectReplaceQdataMethodInfo
+    ResolveChildProxyMethod "runDispose" o = GObject.ObjectRunDisposeMethodInfo
+    ResolveChildProxyMethod "stealData" o = GObject.ObjectStealDataMethodInfo
+    ResolveChildProxyMethod "stealQdata" o = GObject.ObjectStealQdataMethodInfo
+    ResolveChildProxyMethod "thawNotify" o = GObject.ObjectThawNotifyMethodInfo
+    ResolveChildProxyMethod "unref" o = GObject.ObjectUnrefMethodInfo
+    ResolveChildProxyMethod "watchClosure" o = GObject.ObjectWatchClosureMethodInfo
+    ResolveChildProxyMethod "getChildByIndex" o = ChildProxyGetChildByIndexMethodInfo
+    ResolveChildProxyMethod "getChildByName" o = ChildProxyGetChildByNameMethodInfo
+    ResolveChildProxyMethod "getChildrenCount" o = ChildProxyGetChildrenCountMethodInfo
+    ResolveChildProxyMethod "getData" o = GObject.ObjectGetDataMethodInfo
+    ResolveChildProxyMethod "getQdata" o = GObject.ObjectGetQdataMethodInfo
+    ResolveChildProxyMethod "setData" o = GObject.ObjectSetDataMethodInfo
+    ResolveChildProxyMethod l o = MethodResolutionFailed l o
+
+instance (info ~ ResolveChildProxyMethod t ChildProxy, MethodInfo info ChildProxy p) => IsLabelProxy t (ChildProxy -> p) where
+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)
+
+#if MIN_VERSION_base(4,9,0)
+instance (info ~ ResolveChildProxyMethod t ChildProxy, MethodInfo info ChildProxy p) => IsLabel t (ChildProxy -> p) where
+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)
+#endif
+
+-- signal ChildProxy::child-added
+type ChildProxyChildAddedCallback =
+    GObject.Object ->
+    T.Text ->
+    IO ()
+
+noChildProxyChildAddedCallback :: Maybe ChildProxyChildAddedCallback
+noChildProxyChildAddedCallback = Nothing
+
+type ChildProxyChildAddedCallbackC =
+    Ptr () ->                               -- object
+    Ptr GObject.Object ->
+    CString ->
+    Ptr () ->                               -- user_data
+    IO ()
+
+foreign import ccall "wrapper"
+    mkChildProxyChildAddedCallback :: ChildProxyChildAddedCallbackC -> IO (FunPtr ChildProxyChildAddedCallbackC)
+
+childProxyChildAddedClosure :: ChildProxyChildAddedCallback -> IO Closure
+childProxyChildAddedClosure cb = newCClosure =<< mkChildProxyChildAddedCallback wrapped
+    where wrapped = childProxyChildAddedCallbackWrapper cb
+
+childProxyChildAddedCallbackWrapper ::
+    ChildProxyChildAddedCallback ->
+    Ptr () ->
+    Ptr GObject.Object ->
+    CString ->
+    Ptr () ->
+    IO ()
+childProxyChildAddedCallbackWrapper _cb _ object name _ = do
+    object' <- (newObject GObject.Object) object
+    name' <- cstringToText name
+    _cb  object' name'
+
+onChildProxyChildAdded :: (GObject a, MonadIO m) => a -> ChildProxyChildAddedCallback -> m SignalHandlerId
+onChildProxyChildAdded obj cb = liftIO $ connectChildProxyChildAdded obj cb SignalConnectBefore
+afterChildProxyChildAdded :: (GObject a, MonadIO m) => a -> ChildProxyChildAddedCallback -> m SignalHandlerId
+afterChildProxyChildAdded obj cb = connectChildProxyChildAdded obj cb SignalConnectAfter
+
+connectChildProxyChildAdded :: (GObject a, MonadIO m) =>
+                               a -> ChildProxyChildAddedCallback -> SignalConnectMode -> m SignalHandlerId
+connectChildProxyChildAdded obj cb after = liftIO $ do
+    cb' <- mkChildProxyChildAddedCallback (childProxyChildAddedCallbackWrapper cb)
+    connectSignalFunPtr obj "child-added" cb' after
+
+-- signal ChildProxy::child-removed
+type ChildProxyChildRemovedCallback =
+    GObject.Object ->
+    T.Text ->
+    IO ()
+
+noChildProxyChildRemovedCallback :: Maybe ChildProxyChildRemovedCallback
+noChildProxyChildRemovedCallback = Nothing
+
+type ChildProxyChildRemovedCallbackC =
+    Ptr () ->                               -- object
+    Ptr GObject.Object ->
+    CString ->
+    Ptr () ->                               -- user_data
+    IO ()
+
+foreign import ccall "wrapper"
+    mkChildProxyChildRemovedCallback :: ChildProxyChildRemovedCallbackC -> IO (FunPtr ChildProxyChildRemovedCallbackC)
+
+childProxyChildRemovedClosure :: ChildProxyChildRemovedCallback -> IO Closure
+childProxyChildRemovedClosure cb = newCClosure =<< mkChildProxyChildRemovedCallback wrapped
+    where wrapped = childProxyChildRemovedCallbackWrapper cb
+
+childProxyChildRemovedCallbackWrapper ::
+    ChildProxyChildRemovedCallback ->
+    Ptr () ->
+    Ptr GObject.Object ->
+    CString ->
+    Ptr () ->
+    IO ()
+childProxyChildRemovedCallbackWrapper _cb _ object name _ = do
+    object' <- (newObject GObject.Object) object
+    name' <- cstringToText name
+    _cb  object' name'
+
+onChildProxyChildRemoved :: (GObject a, MonadIO m) => a -> ChildProxyChildRemovedCallback -> m SignalHandlerId
+onChildProxyChildRemoved obj cb = liftIO $ connectChildProxyChildRemoved obj cb SignalConnectBefore
+afterChildProxyChildRemoved :: (GObject a, MonadIO m) => a -> ChildProxyChildRemovedCallback -> m SignalHandlerId
+afterChildProxyChildRemoved obj cb = connectChildProxyChildRemoved obj cb SignalConnectAfter
+
+connectChildProxyChildRemoved :: (GObject a, MonadIO m) =>
+                                 a -> ChildProxyChildRemovedCallback -> SignalConnectMode -> m SignalHandlerId
+connectChildProxyChildRemoved obj cb after = liftIO $ do
+    cb' <- mkChildProxyChildRemovedCallback (childProxyChildRemovedCallbackWrapper cb)
+    connectSignalFunPtr obj "child-removed" cb' after
+
+type instance AttributeList ChildProxy = ChildProxyAttributeList
+type ChildProxyAttributeList = ('[ ] :: [(Symbol, *)])
+
+data ChildProxyChildAddedSignalInfo
+instance SignalInfo ChildProxyChildAddedSignalInfo where
+    type HaskellCallbackType ChildProxyChildAddedSignalInfo = ChildProxyChildAddedCallback
+    connectSignal _ = connectChildProxyChildAdded
+
+data ChildProxyChildRemovedSignalInfo
+instance SignalInfo ChildProxyChildRemovedSignalInfo where
+    type HaskellCallbackType ChildProxyChildRemovedSignalInfo = ChildProxyChildRemovedCallback
+    connectSignal _ = connectChildProxyChildRemoved
+
+type instance SignalList ChildProxy = ChildProxySignalList
+type ChildProxySignalList = ('[ '("childAdded", ChildProxyChildAddedSignalInfo), '("childRemoved", ChildProxyChildRemovedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo)] :: [(Symbol, *)])
+
+foreign import ccall "gst_child_proxy_get_type"
+    c_gst_child_proxy_get_type :: IO GType
+
+type instance ParentTypes ChildProxy = ChildProxyParentTypes
+type ChildProxyParentTypes = '[GObject.Object]
+
+instance GObject ChildProxy where
+    gobjectIsInitiallyUnowned _ = False
+    gobjectType _ = c_gst_child_proxy_get_type
+    
+
+class GObject o => ChildProxyK o
+instance (GObject o, IsDescendantOf ChildProxy o) => ChildProxyK o
+
+toChildProxy :: ChildProxyK o => o -> IO ChildProxy
+toChildProxy = unsafeCastTo ChildProxy
+
+-- method ChildProxy::child_added
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "ChildProxy", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "child", argType = TInterface "GObject" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_child_proxy_child_added" gst_child_proxy_child_added :: 
+    Ptr ChildProxy ->                       -- _obj : TInterface "Gst" "ChildProxy"
+    Ptr GObject.Object ->                   -- child : TInterface "GObject" "Object"
+    CString ->                              -- name : TBasicType TUTF8
+    IO ()
+
+
+childProxyChildAdded ::
+    (MonadIO m, ChildProxyK a, GObject.ObjectK b) =>
+    a                                       -- _obj
+    -> b                                    -- child
+    -> T.Text                               -- name
+    -> m ()                                 -- result
+childProxyChildAdded _obj child name = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let child' = unsafeManagedPtrCastPtr child
+    name' <- textToCString name
+    gst_child_proxy_child_added _obj' child' name'
+    touchManagedPtr _obj
+    touchManagedPtr child
+    freeMem name'
+    return ()
+
+data ChildProxyChildAddedMethodInfo
+instance (signature ~ (b -> T.Text -> m ()), MonadIO m, ChildProxyK a, GObject.ObjectK b) => MethodInfo ChildProxyChildAddedMethodInfo a signature where
+    overloadedMethod _ = childProxyChildAdded
+
+-- method ChildProxy::child_removed
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "ChildProxy", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "child", argType = TInterface "GObject" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_child_proxy_child_removed" gst_child_proxy_child_removed :: 
+    Ptr ChildProxy ->                       -- _obj : TInterface "Gst" "ChildProxy"
+    Ptr GObject.Object ->                   -- child : TInterface "GObject" "Object"
+    CString ->                              -- name : TBasicType TUTF8
+    IO ()
+
+
+childProxyChildRemoved ::
+    (MonadIO m, ChildProxyK a, GObject.ObjectK b) =>
+    a                                       -- _obj
+    -> b                                    -- child
+    -> T.Text                               -- name
+    -> m ()                                 -- result
+childProxyChildRemoved _obj child name = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let child' = unsafeManagedPtrCastPtr child
+    name' <- textToCString name
+    gst_child_proxy_child_removed _obj' child' name'
+    touchManagedPtr _obj
+    touchManagedPtr child
+    freeMem name'
+    return ()
+
+data ChildProxyChildRemovedMethodInfo
+instance (signature ~ (b -> T.Text -> m ()), MonadIO m, ChildProxyK a, GObject.ObjectK b) => MethodInfo ChildProxyChildRemovedMethodInfo a signature where
+    overloadedMethod _ = childProxyChildRemoved
+
+-- method ChildProxy::get_child_by_index
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "ChildProxy", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "GObject" "Object"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_child_proxy_get_child_by_index" gst_child_proxy_get_child_by_index :: 
+    Ptr ChildProxy ->                       -- _obj : TInterface "Gst" "ChildProxy"
+    Word32 ->                               -- index : TBasicType TUInt32
+    IO (Ptr GObject.Object)
+
+
+childProxyGetChildByIndex ::
+    (MonadIO m, ChildProxyK a) =>
+    a                                       -- _obj
+    -> Word32                               -- index
+    -> m GObject.Object                     -- result
+childProxyGetChildByIndex _obj index = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_child_proxy_get_child_by_index _obj' index
+    checkUnexpectedReturnNULL "gst_child_proxy_get_child_by_index" result
+    result' <- (wrapObject GObject.Object) result
+    touchManagedPtr _obj
+    return result'
+
+data ChildProxyGetChildByIndexMethodInfo
+instance (signature ~ (Word32 -> m GObject.Object), MonadIO m, ChildProxyK a) => MethodInfo ChildProxyGetChildByIndexMethodInfo a signature where
+    overloadedMethod _ = childProxyGetChildByIndex
+
+-- method ChildProxy::get_child_by_name
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "ChildProxy", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "GObject" "Object"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_child_proxy_get_child_by_name" gst_child_proxy_get_child_by_name :: 
+    Ptr ChildProxy ->                       -- _obj : TInterface "Gst" "ChildProxy"
+    CString ->                              -- name : TBasicType TUTF8
+    IO (Ptr GObject.Object)
+
+
+childProxyGetChildByName ::
+    (MonadIO m, ChildProxyK a) =>
+    a                                       -- _obj
+    -> T.Text                               -- name
+    -> m GObject.Object                     -- result
+childProxyGetChildByName _obj name = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    name' <- textToCString name
+    result <- gst_child_proxy_get_child_by_name _obj' name'
+    checkUnexpectedReturnNULL "gst_child_proxy_get_child_by_name" result
+    result' <- (wrapObject GObject.Object) result
+    touchManagedPtr _obj
+    freeMem name'
+    return result'
+
+data ChildProxyGetChildByNameMethodInfo
+instance (signature ~ (T.Text -> m GObject.Object), MonadIO m, ChildProxyK a) => MethodInfo ChildProxyGetChildByNameMethodInfo a signature where
+    overloadedMethod _ = childProxyGetChildByName
+
+-- method ChildProxy::get_children_count
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "ChildProxy", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUInt32
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_child_proxy_get_children_count" gst_child_proxy_get_children_count :: 
+    Ptr ChildProxy ->                       -- _obj : TInterface "Gst" "ChildProxy"
+    IO Word32
+
+
+childProxyGetChildrenCount ::
+    (MonadIO m, ChildProxyK a) =>
+    a                                       -- _obj
+    -> m Word32                             -- result
+childProxyGetChildrenCount _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_child_proxy_get_children_count _obj'
+    touchManagedPtr _obj
+    return result
+
+data ChildProxyGetChildrenCountMethodInfo
+instance (signature ~ (m Word32), MonadIO m, ChildProxyK a) => MethodInfo ChildProxyGetChildrenCountMethodInfo a signature where
+    overloadedMethod _ = childProxyGetChildrenCount
+
+-- method ChildProxy::get_property
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "ChildProxy", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_child_proxy_get_property" gst_child_proxy_get_property :: 
+    Ptr ChildProxy ->                       -- _obj : TInterface "Gst" "ChildProxy"
+    CString ->                              -- name : TBasicType TUTF8
+    Ptr GValue ->                           -- value : TInterface "GObject" "Value"
+    IO ()
+
+
+childProxyGetProperty ::
+    (MonadIO m, ChildProxyK a) =>
+    a                                       -- _obj
+    -> T.Text                               -- name
+    -> m (GValue)                           -- result
+childProxyGetProperty _obj name = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    name' <- textToCString name
+    value <- callocBoxedBytes 24 :: IO (Ptr GValue)
+    gst_child_proxy_get_property _obj' name' value
+    value' <- (wrapBoxed GValue) value
+    touchManagedPtr _obj
+    freeMem name'
+    return value'
+
+data ChildProxyGetPropertyMethodInfo
+instance (signature ~ (T.Text -> m (GValue)), MonadIO m, ChildProxyK a) => MethodInfo ChildProxyGetPropertyMethodInfo a signature where
+    overloadedMethod _ = childProxyGetProperty
+
+-- method ChildProxy::lookup
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "ChildProxy", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "target", argType = TInterface "GObject" "Object", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "pspec", argType = TParamSpec, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_child_proxy_lookup" gst_child_proxy_lookup :: 
+    Ptr ChildProxy ->                       -- _obj : TInterface "Gst" "ChildProxy"
+    CString ->                              -- name : TBasicType TUTF8
+    Ptr (Ptr GObject.Object) ->             -- target : TInterface "GObject" "Object"
+    Ptr (Ptr GParamSpec) ->                 -- pspec : TParamSpec
+    IO CInt
+
+
+childProxyLookup ::
+    (MonadIO m, ChildProxyK a) =>
+    a                                       -- _obj
+    -> T.Text                               -- name
+    -> m (Bool,GObject.Object,GParamSpec)   -- result
+childProxyLookup _obj name = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    name' <- textToCString name
+    target <- allocMem :: IO (Ptr (Ptr GObject.Object))
+    pspec <- allocMem :: IO (Ptr (Ptr GParamSpec))
+    result <- gst_child_proxy_lookup _obj' name' target pspec
+    let result' = (/= 0) result
+    target' <- peek target
+    target'' <- (wrapObject GObject.Object) target'
+    pspec' <- peek pspec
+    pspec'' <- newGParamSpecFromPtr pspec'
+    touchManagedPtr _obj
+    freeMem name'
+    freeMem target
+    freeMem pspec
+    return (result', target'', pspec'')
+
+data ChildProxyLookupMethodInfo
+instance (signature ~ (T.Text -> m (Bool,GObject.Object,GParamSpec)), MonadIO m, ChildProxyK a) => MethodInfo ChildProxyLookupMethodInfo a signature where
+    overloadedMethod _ = childProxyLookup
+
+-- method ChildProxy::set_property
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "ChildProxy", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_child_proxy_set_property" gst_child_proxy_set_property :: 
+    Ptr ChildProxy ->                       -- _obj : TInterface "Gst" "ChildProxy"
+    CString ->                              -- name : TBasicType TUTF8
+    Ptr GValue ->                           -- value : TInterface "GObject" "Value"
+    IO ()
+
+
+childProxySetProperty ::
+    (MonadIO m, ChildProxyK a) =>
+    a                                       -- _obj
+    -> T.Text                               -- name
+    -> GValue                               -- value
+    -> m ()                                 -- result
+childProxySetProperty _obj name value = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    name' <- textToCString name
+    let value' = unsafeManagedPtrGetPtr value
+    gst_child_proxy_set_property _obj' name' value'
+    touchManagedPtr _obj
+    touchManagedPtr value
+    freeMem name'
+    return ()
+
+data ChildProxySetPropertyMethodInfo
+instance (signature ~ (T.Text -> GValue -> m ()), MonadIO m, ChildProxyK a) => MethodInfo ChildProxySetPropertyMethodInfo a signature where
+    overloadedMethod _ = childProxySetProperty
+
+
diff --git a/GI/Gst/Interfaces/ChildProxy.hs-boot b/GI/Gst/Interfaces/ChildProxy.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Interfaces/ChildProxy.hs-boot
@@ -0,0 +1,23 @@
+module GI.Gst.Interfaces.ChildProxy where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+newtype ChildProxy = ChildProxy (ForeignPtr ChildProxy)
+data ChildProxyChildAddedSignalInfo
+data ChildProxyChildRemovedSignalInfo
+instance GObject ChildProxy where
+class GObject o => ChildProxyK o
+instance (GObject o, IsDescendantOf ChildProxy o) => ChildProxyK o
+data ChildProxyChildAddedMethodInfo
+data ChildProxyChildRemovedMethodInfo
+data ChildProxyGetChildByIndexMethodInfo
+data ChildProxyGetChildByNameMethodInfo
+data ChildProxyGetChildrenCountMethodInfo
+data ChildProxyGetPropertyMethodInfo
+data ChildProxyLookupMethodInfo
+data ChildProxySetPropertyMethodInfo
diff --git a/GI/Gst/Interfaces/Preset.hs b/GI/Gst/Interfaces/Preset.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Interfaces/Preset.hs
@@ -0,0 +1,476 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+-}
+
+module GI.Gst.Interfaces.Preset
+    ( 
+
+-- * Exported types
+    Preset(..)                              ,
+    noPreset                                ,
+    PresetK                                 ,
+
+
+ -- * Methods
+-- ** presetDeletePreset
+    PresetDeletePresetMethodInfo            ,
+    presetDeletePreset                      ,
+
+
+-- ** presetGetAppDir
+    presetGetAppDir                         ,
+
+
+-- ** presetGetMeta
+    PresetGetMetaMethodInfo                 ,
+    presetGetMeta                           ,
+
+
+-- ** presetGetPresetNames
+    PresetGetPresetNamesMethodInfo          ,
+    presetGetPresetNames                    ,
+
+
+-- ** presetGetPropertyNames
+    PresetGetPropertyNamesMethodInfo        ,
+    presetGetPropertyNames                  ,
+
+
+-- ** presetIsEditable
+    PresetIsEditableMethodInfo              ,
+    presetIsEditable                        ,
+
+
+-- ** presetLoadPreset
+    PresetLoadPresetMethodInfo              ,
+    presetLoadPreset                        ,
+
+
+-- ** presetRenamePreset
+    PresetRenamePresetMethodInfo            ,
+    presetRenamePreset                      ,
+
+
+-- ** presetSavePreset
+    PresetSavePresetMethodInfo              ,
+    presetSavePreset                        ,
+
+
+-- ** presetSetAppDir
+    presetSetAppDir                         ,
+
+
+-- ** presetSetMeta
+    PresetSetMetaMethodInfo                 ,
+    presetSetMeta                           ,
+
+
+
+
+    ) where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+import GI.Gst.Callbacks
+
+-- interface Preset 
+
+newtype Preset = Preset (ForeignPtr Preset)
+noPreset :: Maybe Preset
+noPreset = Nothing
+
+type family ResolvePresetMethod (t :: Symbol) (o :: *) :: * where
+    ResolvePresetMethod "deletePreset" o = PresetDeletePresetMethodInfo
+    ResolvePresetMethod "isEditable" o = PresetIsEditableMethodInfo
+    ResolvePresetMethod "loadPreset" o = PresetLoadPresetMethodInfo
+    ResolvePresetMethod "renamePreset" o = PresetRenamePresetMethodInfo
+    ResolvePresetMethod "savePreset" o = PresetSavePresetMethodInfo
+    ResolvePresetMethod "getMeta" o = PresetGetMetaMethodInfo
+    ResolvePresetMethod "getPresetNames" o = PresetGetPresetNamesMethodInfo
+    ResolvePresetMethod "getPropertyNames" o = PresetGetPropertyNamesMethodInfo
+    ResolvePresetMethod "setMeta" o = PresetSetMetaMethodInfo
+    ResolvePresetMethod l o = MethodResolutionFailed l o
+
+instance (info ~ ResolvePresetMethod t Preset, MethodInfo info Preset p) => IsLabelProxy t (Preset -> p) where
+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)
+
+#if MIN_VERSION_base(4,9,0)
+instance (info ~ ResolvePresetMethod t Preset, MethodInfo info Preset p) => IsLabel t (Preset -> p) where
+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)
+#endif
+
+type instance AttributeList Preset = PresetAttributeList
+type PresetAttributeList = ('[ ] :: [(Symbol, *)])
+
+type instance SignalList Preset = PresetSignalList
+type PresetSignalList = ('[ ] :: [(Symbol, *)])
+
+class ForeignPtrNewtype a => PresetK a
+instance (ForeignPtrNewtype o, IsDescendantOf Preset o) => PresetK o
+type instance ParentTypes Preset = PresetParentTypes
+type PresetParentTypes = '[]
+
+-- method Preset::delete_preset
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Preset", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_preset_delete_preset" gst_preset_delete_preset :: 
+    Ptr Preset ->                           -- _obj : TInterface "Gst" "Preset"
+    CString ->                              -- name : TBasicType TUTF8
+    IO CInt
+
+
+presetDeletePreset ::
+    (MonadIO m, PresetK a) =>
+    a                                       -- _obj
+    -> T.Text                               -- name
+    -> m Bool                               -- result
+presetDeletePreset _obj name = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    name' <- textToCString name
+    result <- gst_preset_delete_preset _obj' name'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    freeMem name'
+    return result'
+
+data PresetDeletePresetMethodInfo
+instance (signature ~ (T.Text -> m Bool), MonadIO m, PresetK a) => MethodInfo PresetDeletePresetMethodInfo a signature where
+    overloadedMethod _ = presetDeletePreset
+
+-- method Preset::get_meta
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Preset", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_preset_get_meta" gst_preset_get_meta :: 
+    Ptr Preset ->                           -- _obj : TInterface "Gst" "Preset"
+    CString ->                              -- name : TBasicType TUTF8
+    CString ->                              -- tag : TBasicType TUTF8
+    Ptr CString ->                          -- value : TBasicType TUTF8
+    IO CInt
+
+
+presetGetMeta ::
+    (MonadIO m, PresetK a) =>
+    a                                       -- _obj
+    -> T.Text                               -- name
+    -> T.Text                               -- tag
+    -> m (Bool,T.Text)                      -- result
+presetGetMeta _obj name tag = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    name' <- textToCString name
+    tag' <- textToCString tag
+    value <- allocMem :: IO (Ptr CString)
+    result <- gst_preset_get_meta _obj' name' tag' value
+    let result' = (/= 0) result
+    value' <- peek value
+    value'' <- cstringToText value'
+    freeMem value'
+    touchManagedPtr _obj
+    freeMem name'
+    freeMem tag'
+    freeMem value
+    return (result', value'')
+
+data PresetGetMetaMethodInfo
+instance (signature ~ (T.Text -> T.Text -> m (Bool,T.Text)), MonadIO m, PresetK a) => MethodInfo PresetGetMetaMethodInfo a signature where
+    overloadedMethod _ = presetGetMeta
+
+-- method Preset::get_preset_names
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Preset", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TCArray True (-1) (-1) (TBasicType TUTF8)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_preset_get_preset_names" gst_preset_get_preset_names :: 
+    Ptr Preset ->                           -- _obj : TInterface "Gst" "Preset"
+    IO (Ptr CString)
+
+
+presetGetPresetNames ::
+    (MonadIO m, PresetK a) =>
+    a                                       -- _obj
+    -> m [T.Text]                           -- result
+presetGetPresetNames _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_preset_get_preset_names _obj'
+    checkUnexpectedReturnNULL "gst_preset_get_preset_names" result
+    result' <- unpackZeroTerminatedUTF8CArray result
+    mapZeroTerminatedCArray freeMem result
+    freeMem result
+    touchManagedPtr _obj
+    return result'
+
+data PresetGetPresetNamesMethodInfo
+instance (signature ~ (m [T.Text]), MonadIO m, PresetK a) => MethodInfo PresetGetPresetNamesMethodInfo a signature where
+    overloadedMethod _ = presetGetPresetNames
+
+-- method Preset::get_property_names
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Preset", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TCArray True (-1) (-1) (TBasicType TUTF8)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_preset_get_property_names" gst_preset_get_property_names :: 
+    Ptr Preset ->                           -- _obj : TInterface "Gst" "Preset"
+    IO (Ptr CString)
+
+
+presetGetPropertyNames ::
+    (MonadIO m, PresetK a) =>
+    a                                       -- _obj
+    -> m [T.Text]                           -- result
+presetGetPropertyNames _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_preset_get_property_names _obj'
+    checkUnexpectedReturnNULL "gst_preset_get_property_names" result
+    result' <- unpackZeroTerminatedUTF8CArray result
+    mapZeroTerminatedCArray freeMem result
+    freeMem result
+    touchManagedPtr _obj
+    return result'
+
+data PresetGetPropertyNamesMethodInfo
+instance (signature ~ (m [T.Text]), MonadIO m, PresetK a) => MethodInfo PresetGetPropertyNamesMethodInfo a signature where
+    overloadedMethod _ = presetGetPropertyNames
+
+-- method Preset::is_editable
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Preset", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_preset_is_editable" gst_preset_is_editable :: 
+    Ptr Preset ->                           -- _obj : TInterface "Gst" "Preset"
+    IO CInt
+
+
+presetIsEditable ::
+    (MonadIO m, PresetK a) =>
+    a                                       -- _obj
+    -> m Bool                               -- result
+presetIsEditable _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_preset_is_editable _obj'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data PresetIsEditableMethodInfo
+instance (signature ~ (m Bool), MonadIO m, PresetK a) => MethodInfo PresetIsEditableMethodInfo a signature where
+    overloadedMethod _ = presetIsEditable
+
+-- method Preset::load_preset
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Preset", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_preset_load_preset" gst_preset_load_preset :: 
+    Ptr Preset ->                           -- _obj : TInterface "Gst" "Preset"
+    CString ->                              -- name : TBasicType TUTF8
+    IO CInt
+
+
+presetLoadPreset ::
+    (MonadIO m, PresetK a) =>
+    a                                       -- _obj
+    -> T.Text                               -- name
+    -> m Bool                               -- result
+presetLoadPreset _obj name = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    name' <- textToCString name
+    result <- gst_preset_load_preset _obj' name'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    freeMem name'
+    return result'
+
+data PresetLoadPresetMethodInfo
+instance (signature ~ (T.Text -> m Bool), MonadIO m, PresetK a) => MethodInfo PresetLoadPresetMethodInfo a signature where
+    overloadedMethod _ = presetLoadPreset
+
+-- method Preset::rename_preset
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Preset", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "old_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "new_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_preset_rename_preset" gst_preset_rename_preset :: 
+    Ptr Preset ->                           -- _obj : TInterface "Gst" "Preset"
+    CString ->                              -- old_name : TBasicType TUTF8
+    CString ->                              -- new_name : TBasicType TUTF8
+    IO CInt
+
+
+presetRenamePreset ::
+    (MonadIO m, PresetK a) =>
+    a                                       -- _obj
+    -> T.Text                               -- oldName
+    -> T.Text                               -- newName
+    -> m Bool                               -- result
+presetRenamePreset _obj oldName newName = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    oldName' <- textToCString oldName
+    newName' <- textToCString newName
+    result <- gst_preset_rename_preset _obj' oldName' newName'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    freeMem oldName'
+    freeMem newName'
+    return result'
+
+data PresetRenamePresetMethodInfo
+instance (signature ~ (T.Text -> T.Text -> m Bool), MonadIO m, PresetK a) => MethodInfo PresetRenamePresetMethodInfo a signature where
+    overloadedMethod _ = presetRenamePreset
+
+-- method Preset::save_preset
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Preset", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_preset_save_preset" gst_preset_save_preset :: 
+    Ptr Preset ->                           -- _obj : TInterface "Gst" "Preset"
+    CString ->                              -- name : TBasicType TUTF8
+    IO CInt
+
+
+presetSavePreset ::
+    (MonadIO m, PresetK a) =>
+    a                                       -- _obj
+    -> T.Text                               -- name
+    -> m Bool                               -- result
+presetSavePreset _obj name = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    name' <- textToCString name
+    result <- gst_preset_save_preset _obj' name'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    freeMem name'
+    return result'
+
+data PresetSavePresetMethodInfo
+instance (signature ~ (T.Text -> m Bool), MonadIO m, PresetK a) => MethodInfo PresetSavePresetMethodInfo a signature where
+    overloadedMethod _ = presetSavePreset
+
+-- method Preset::set_meta
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Preset", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_preset_set_meta" gst_preset_set_meta :: 
+    Ptr Preset ->                           -- _obj : TInterface "Gst" "Preset"
+    CString ->                              -- name : TBasicType TUTF8
+    CString ->                              -- tag : TBasicType TUTF8
+    CString ->                              -- value : TBasicType TUTF8
+    IO CInt
+
+
+presetSetMeta ::
+    (MonadIO m, PresetK a) =>
+    a                                       -- _obj
+    -> T.Text                               -- name
+    -> T.Text                               -- tag
+    -> Maybe (T.Text)                       -- value
+    -> m Bool                               -- result
+presetSetMeta _obj name tag value = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    name' <- textToCString name
+    tag' <- textToCString tag
+    maybeValue <- case value of
+        Nothing -> return nullPtr
+        Just jValue -> do
+            jValue' <- textToCString jValue
+            return jValue'
+    result <- gst_preset_set_meta _obj' name' tag' maybeValue
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    freeMem name'
+    freeMem tag'
+    freeMem maybeValue
+    return result'
+
+data PresetSetMetaMethodInfo
+instance (signature ~ (T.Text -> T.Text -> Maybe (T.Text) -> m Bool), MonadIO m, PresetK a) => MethodInfo PresetSetMetaMethodInfo a signature where
+    overloadedMethod _ = presetSetMeta
+
+-- method Preset::get_app_dir
+-- method type : MemberFunction
+-- Args : []
+-- Lengths : []
+-- returnType : TBasicType TUTF8
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_preset_get_app_dir" gst_preset_get_app_dir :: 
+    IO CString
+
+
+presetGetAppDir ::
+    (MonadIO m) =>
+    m T.Text                                -- result
+presetGetAppDir  = liftIO $ do
+    result <- gst_preset_get_app_dir
+    checkUnexpectedReturnNULL "gst_preset_get_app_dir" result
+    result' <- cstringToText result
+    return result'
+
+-- method Preset::set_app_dir
+-- method type : MemberFunction
+-- Args : [Arg {argCName = "app_dir", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_preset_set_app_dir" gst_preset_set_app_dir :: 
+    CString ->                              -- app_dir : TBasicType TUTF8
+    IO CInt
+
+
+presetSetAppDir ::
+    (MonadIO m) =>
+    T.Text                                  -- appDir
+    -> m Bool                               -- result
+presetSetAppDir appDir = liftIO $ do
+    appDir' <- textToCString appDir
+    result <- gst_preset_set_app_dir appDir'
+    let result' = (/= 0) result
+    freeMem appDir'
+    return result'
+
+
diff --git a/GI/Gst/Interfaces/Preset.hs-boot b/GI/Gst/Interfaces/Preset.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Interfaces/Preset.hs-boot
@@ -0,0 +1,21 @@
+module GI.Gst.Interfaces.Preset where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+newtype Preset = Preset (ForeignPtr Preset)
+class ForeignPtrNewtype a => PresetK a
+instance (ForeignPtrNewtype o, IsDescendantOf Preset o) => PresetK o
+data PresetDeletePresetMethodInfo
+data PresetGetMetaMethodInfo
+data PresetGetPresetNamesMethodInfo
+data PresetGetPropertyNamesMethodInfo
+data PresetIsEditableMethodInfo
+data PresetLoadPresetMethodInfo
+data PresetRenamePresetMethodInfo
+data PresetSavePresetMethodInfo
+data PresetSetMetaMethodInfo
diff --git a/GI/Gst/Interfaces/TagSetter.hs b/GI/Gst/Interfaces/TagSetter.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Interfaces/TagSetter.hs
@@ -0,0 +1,389 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+-}
+
+module GI.Gst.Interfaces.TagSetter
+    ( 
+
+-- * Exported types
+    TagSetter(..)                           ,
+    noTagSetter                             ,
+    TagSetterK                              ,
+    toTagSetter                             ,
+
+
+ -- * Methods
+-- ** tagSetterAddTagValue
+    TagSetterAddTagValueMethodInfo          ,
+    tagSetterAddTagValue                    ,
+
+
+-- ** tagSetterGetTagList
+    TagSetterGetTagListMethodInfo           ,
+    tagSetterGetTagList                     ,
+
+
+-- ** tagSetterGetTagMergeMode
+    TagSetterGetTagMergeModeMethodInfo      ,
+    tagSetterGetTagMergeMode                ,
+
+
+-- ** tagSetterMergeTags
+    TagSetterMergeTagsMethodInfo            ,
+    tagSetterMergeTags                      ,
+
+
+-- ** tagSetterResetTags
+    TagSetterResetTagsMethodInfo            ,
+    tagSetterResetTags                      ,
+
+
+-- ** tagSetterSetTagMergeMode
+    TagSetterSetTagMergeModeMethodInfo      ,
+    tagSetterSetTagMergeMode                ,
+
+
+
+
+    ) where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+import GI.Gst.Callbacks
+import qualified GI.GObject as GObject
+
+-- interface TagSetter 
+
+newtype TagSetter = TagSetter (ForeignPtr TagSetter)
+noTagSetter :: Maybe TagSetter
+noTagSetter = Nothing
+
+type family ResolveTagSetterMethod (t :: Symbol) (o :: *) :: * where
+    ResolveTagSetterMethod "abortState" o = ElementAbortStateMethodInfo
+    ResolveTagSetterMethod "addControlBinding" o = ObjectAddControlBindingMethodInfo
+    ResolveTagSetterMethod "addPad" o = ElementAddPadMethodInfo
+    ResolveTagSetterMethod "addTagValue" o = TagSetterAddTagValueMethodInfo
+    ResolveTagSetterMethod "bindProperty" o = GObject.ObjectBindPropertyMethodInfo
+    ResolveTagSetterMethod "bindPropertyFull" o = GObject.ObjectBindPropertyFullMethodInfo
+    ResolveTagSetterMethod "changeState" o = ElementChangeStateMethodInfo
+    ResolveTagSetterMethod "continueState" o = ElementContinueStateMethodInfo
+    ResolveTagSetterMethod "createAllPads" o = ElementCreateAllPadsMethodInfo
+    ResolveTagSetterMethod "defaultError" o = ObjectDefaultErrorMethodInfo
+    ResolveTagSetterMethod "forceFloating" o = GObject.ObjectForceFloatingMethodInfo
+    ResolveTagSetterMethod "freezeNotify" o = GObject.ObjectFreezeNotifyMethodInfo
+    ResolveTagSetterMethod "hasActiveControlBindings" o = ObjectHasActiveControlBindingsMethodInfo
+    ResolveTagSetterMethod "hasAncestor" o = ObjectHasAncestorMethodInfo
+    ResolveTagSetterMethod "hasAsAncestor" o = ObjectHasAsAncestorMethodInfo
+    ResolveTagSetterMethod "hasAsParent" o = ObjectHasAsParentMethodInfo
+    ResolveTagSetterMethod "isFloating" o = GObject.ObjectIsFloatingMethodInfo
+    ResolveTagSetterMethod "isLockedState" o = ElementIsLockedStateMethodInfo
+    ResolveTagSetterMethod "iteratePads" o = ElementIteratePadsMethodInfo
+    ResolveTagSetterMethod "iterateSinkPads" o = ElementIterateSinkPadsMethodInfo
+    ResolveTagSetterMethod "iterateSrcPads" o = ElementIterateSrcPadsMethodInfo
+    ResolveTagSetterMethod "link" o = ElementLinkMethodInfo
+    ResolveTagSetterMethod "linkFiltered" o = ElementLinkFilteredMethodInfo
+    ResolveTagSetterMethod "linkPads" o = ElementLinkPadsMethodInfo
+    ResolveTagSetterMethod "linkPadsFiltered" o = ElementLinkPadsFilteredMethodInfo
+    ResolveTagSetterMethod "linkPadsFull" o = ElementLinkPadsFullMethodInfo
+    ResolveTagSetterMethod "lostState" o = ElementLostStateMethodInfo
+    ResolveTagSetterMethod "mergeTags" o = TagSetterMergeTagsMethodInfo
+    ResolveTagSetterMethod "messageFull" o = ElementMessageFullMethodInfo
+    ResolveTagSetterMethod "noMorePads" o = ElementNoMorePadsMethodInfo
+    ResolveTagSetterMethod "notify" o = GObject.ObjectNotifyMethodInfo
+    ResolveTagSetterMethod "notifyByPspec" o = GObject.ObjectNotifyByPspecMethodInfo
+    ResolveTagSetterMethod "postMessage" o = ElementPostMessageMethodInfo
+    ResolveTagSetterMethod "provideClock" o = ElementProvideClockMethodInfo
+    ResolveTagSetterMethod "query" o = ElementQueryMethodInfo
+    ResolveTagSetterMethod "queryConvert" o = ElementQueryConvertMethodInfo
+    ResolveTagSetterMethod "queryDuration" o = ElementQueryDurationMethodInfo
+    ResolveTagSetterMethod "queryPosition" o = ElementQueryPositionMethodInfo
+    ResolveTagSetterMethod "refSink" o = GObject.ObjectRefSinkMethodInfo
+    ResolveTagSetterMethod "releaseRequestPad" o = ElementReleaseRequestPadMethodInfo
+    ResolveTagSetterMethod "removeControlBinding" o = ObjectRemoveControlBindingMethodInfo
+    ResolveTagSetterMethod "removePad" o = ElementRemovePadMethodInfo
+    ResolveTagSetterMethod "replaceData" o = GObject.ObjectReplaceDataMethodInfo
+    ResolveTagSetterMethod "replaceQdata" o = GObject.ObjectReplaceQdataMethodInfo
+    ResolveTagSetterMethod "requestPad" o = ElementRequestPadMethodInfo
+    ResolveTagSetterMethod "resetTags" o = TagSetterResetTagsMethodInfo
+    ResolveTagSetterMethod "runDispose" o = GObject.ObjectRunDisposeMethodInfo
+    ResolveTagSetterMethod "seek" o = ElementSeekMethodInfo
+    ResolveTagSetterMethod "seekSimple" o = ElementSeekSimpleMethodInfo
+    ResolveTagSetterMethod "sendEvent" o = ElementSendEventMethodInfo
+    ResolveTagSetterMethod "stealData" o = GObject.ObjectStealDataMethodInfo
+    ResolveTagSetterMethod "stealQdata" o = GObject.ObjectStealQdataMethodInfo
+    ResolveTagSetterMethod "suggestNextSync" o = ObjectSuggestNextSyncMethodInfo
+    ResolveTagSetterMethod "syncStateWithParent" o = ElementSyncStateWithParentMethodInfo
+    ResolveTagSetterMethod "syncValues" o = ObjectSyncValuesMethodInfo
+    ResolveTagSetterMethod "thawNotify" o = GObject.ObjectThawNotifyMethodInfo
+    ResolveTagSetterMethod "unlink" o = ElementUnlinkMethodInfo
+    ResolveTagSetterMethod "unlinkPads" o = ElementUnlinkPadsMethodInfo
+    ResolveTagSetterMethod "unparent" o = ObjectUnparentMethodInfo
+    ResolveTagSetterMethod "watchClosure" o = GObject.ObjectWatchClosureMethodInfo
+    ResolveTagSetterMethod "getBaseTime" o = ElementGetBaseTimeMethodInfo
+    ResolveTagSetterMethod "getBus" o = ElementGetBusMethodInfo
+    ResolveTagSetterMethod "getClock" o = ElementGetClockMethodInfo
+    ResolveTagSetterMethod "getCompatiblePad" o = ElementGetCompatiblePadMethodInfo
+    ResolveTagSetterMethod "getCompatiblePadTemplate" o = ElementGetCompatiblePadTemplateMethodInfo
+    ResolveTagSetterMethod "getControlBinding" o = ObjectGetControlBindingMethodInfo
+    ResolveTagSetterMethod "getControlRate" o = ObjectGetControlRateMethodInfo
+    ResolveTagSetterMethod "getData" o = GObject.ObjectGetDataMethodInfo
+    ResolveTagSetterMethod "getFactory" o = ElementGetFactoryMethodInfo
+    ResolveTagSetterMethod "getGValueArray" o = ObjectGetGValueArrayMethodInfo
+    ResolveTagSetterMethod "getName" o = ObjectGetNameMethodInfo
+    ResolveTagSetterMethod "getParent" o = ObjectGetParentMethodInfo
+    ResolveTagSetterMethod "getPathString" o = ObjectGetPathStringMethodInfo
+    ResolveTagSetterMethod "getProperty" o = GObject.ObjectGetPropertyMethodInfo
+    ResolveTagSetterMethod "getQdata" o = GObject.ObjectGetQdataMethodInfo
+    ResolveTagSetterMethod "getRequestPad" o = ElementGetRequestPadMethodInfo
+    ResolveTagSetterMethod "getStartTime" o = ElementGetStartTimeMethodInfo
+    ResolveTagSetterMethod "getState" o = ElementGetStateMethodInfo
+    ResolveTagSetterMethod "getStaticPad" o = ElementGetStaticPadMethodInfo
+    ResolveTagSetterMethod "getTagList" o = TagSetterGetTagListMethodInfo
+    ResolveTagSetterMethod "getTagMergeMode" o = TagSetterGetTagMergeModeMethodInfo
+    ResolveTagSetterMethod "getValue" o = ObjectGetValueMethodInfo
+    ResolveTagSetterMethod "getValueArray" o = ObjectGetValueArrayMethodInfo
+    ResolveTagSetterMethod "setBaseTime" o = ElementSetBaseTimeMethodInfo
+    ResolveTagSetterMethod "setBus" o = ElementSetBusMethodInfo
+    ResolveTagSetterMethod "setClock" o = ElementSetClockMethodInfo
+    ResolveTagSetterMethod "setContext" o = ElementSetContextMethodInfo
+    ResolveTagSetterMethod "setControlBindingDisabled" o = ObjectSetControlBindingDisabledMethodInfo
+    ResolveTagSetterMethod "setControlBindingsDisabled" o = ObjectSetControlBindingsDisabledMethodInfo
+    ResolveTagSetterMethod "setControlRate" o = ObjectSetControlRateMethodInfo
+    ResolveTagSetterMethod "setData" o = GObject.ObjectSetDataMethodInfo
+    ResolveTagSetterMethod "setLockedState" o = ElementSetLockedStateMethodInfo
+    ResolveTagSetterMethod "setName" o = ObjectSetNameMethodInfo
+    ResolveTagSetterMethod "setParent" o = ObjectSetParentMethodInfo
+    ResolveTagSetterMethod "setProperty" o = GObject.ObjectSetPropertyMethodInfo
+    ResolveTagSetterMethod "setStartTime" o = ElementSetStartTimeMethodInfo
+    ResolveTagSetterMethod "setState" o = ElementSetStateMethodInfo
+    ResolveTagSetterMethod "setTagMergeMode" o = TagSetterSetTagMergeModeMethodInfo
+    ResolveTagSetterMethod l o = MethodResolutionFailed l o
+
+instance (info ~ ResolveTagSetterMethod t TagSetter, MethodInfo info TagSetter p) => IsLabelProxy t (TagSetter -> p) where
+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)
+
+#if MIN_VERSION_base(4,9,0)
+instance (info ~ ResolveTagSetterMethod t TagSetter, MethodInfo info TagSetter p) => IsLabel t (TagSetter -> p) where
+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)
+#endif
+
+type instance AttributeList TagSetter = TagSetterAttributeList
+type TagSetterAttributeList = ('[ '("name", ObjectNamePropertyInfo), '("parent", ObjectParentPropertyInfo)] :: [(Symbol, *)])
+
+type instance SignalList TagSetter = TagSetterSignalList
+type TagSetterSignalList = ('[ '("deepNotify", ObjectDeepNotifySignalInfo), '("noMorePads", ElementNoMorePadsSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("padAdded", ElementPadAddedSignalInfo), '("padRemoved", ElementPadRemovedSignalInfo)] :: [(Symbol, *)])
+
+foreign import ccall "gst_tag_setter_get_type"
+    c_gst_tag_setter_get_type :: IO GType
+
+type instance ParentTypes TagSetter = TagSetterParentTypes
+type TagSetterParentTypes = '[Element, Object, GObject.Object]
+
+instance GObject TagSetter where
+    gobjectIsInitiallyUnowned _ = True
+    gobjectType _ = c_gst_tag_setter_get_type
+    
+
+class GObject o => TagSetterK o
+instance (GObject o, IsDescendantOf TagSetter o) => TagSetterK o
+
+toTagSetter :: TagSetterK o => o -> IO TagSetter
+toTagSetter = unsafeCastTo TagSetter
+
+-- method TagSetter::add_tag_value
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagSetter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mode", argType = TInterface "Gst" "TagMergeMode", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_tag_setter_add_tag_value" gst_tag_setter_add_tag_value :: 
+    Ptr TagSetter ->                        -- _obj : TInterface "Gst" "TagSetter"
+    CUInt ->                                -- mode : TInterface "Gst" "TagMergeMode"
+    CString ->                              -- tag : TBasicType TUTF8
+    Ptr GValue ->                           -- value : TInterface "GObject" "Value"
+    IO ()
+
+
+tagSetterAddTagValue ::
+    (MonadIO m, TagSetterK a) =>
+    a                                       -- _obj
+    -> TagMergeMode                         -- mode
+    -> T.Text                               -- tag
+    -> GValue                               -- value
+    -> m ()                                 -- result
+tagSetterAddTagValue _obj mode tag value = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let mode' = (fromIntegral . fromEnum) mode
+    tag' <- textToCString tag
+    let value' = unsafeManagedPtrGetPtr value
+    gst_tag_setter_add_tag_value _obj' mode' tag' value'
+    touchManagedPtr _obj
+    touchManagedPtr value
+    freeMem tag'
+    return ()
+
+data TagSetterAddTagValueMethodInfo
+instance (signature ~ (TagMergeMode -> T.Text -> GValue -> m ()), MonadIO m, TagSetterK a) => MethodInfo TagSetterAddTagValueMethodInfo a signature where
+    overloadedMethod _ = tagSetterAddTagValue
+
+-- method TagSetter::get_tag_list
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagSetter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "TagList"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_tag_setter_get_tag_list" gst_tag_setter_get_tag_list :: 
+    Ptr TagSetter ->                        -- _obj : TInterface "Gst" "TagSetter"
+    IO (Ptr TagList)
+
+
+tagSetterGetTagList ::
+    (MonadIO m, TagSetterK a) =>
+    a                                       -- _obj
+    -> m TagList                            -- result
+tagSetterGetTagList _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_tag_setter_get_tag_list _obj'
+    checkUnexpectedReturnNULL "gst_tag_setter_get_tag_list" result
+    result' <- (newBoxed TagList) result
+    touchManagedPtr _obj
+    return result'
+
+data TagSetterGetTagListMethodInfo
+instance (signature ~ (m TagList), MonadIO m, TagSetterK a) => MethodInfo TagSetterGetTagListMethodInfo a signature where
+    overloadedMethod _ = tagSetterGetTagList
+
+-- method TagSetter::get_tag_merge_mode
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagSetter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "TagMergeMode"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_tag_setter_get_tag_merge_mode" gst_tag_setter_get_tag_merge_mode :: 
+    Ptr TagSetter ->                        -- _obj : TInterface "Gst" "TagSetter"
+    IO CUInt
+
+
+tagSetterGetTagMergeMode ::
+    (MonadIO m, TagSetterK a) =>
+    a                                       -- _obj
+    -> m TagMergeMode                       -- result
+tagSetterGetTagMergeMode _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_tag_setter_get_tag_merge_mode _obj'
+    let result' = (toEnum . fromIntegral) result
+    touchManagedPtr _obj
+    return result'
+
+data TagSetterGetTagMergeModeMethodInfo
+instance (signature ~ (m TagMergeMode), MonadIO m, TagSetterK a) => MethodInfo TagSetterGetTagMergeModeMethodInfo a signature where
+    overloadedMethod _ = tagSetterGetTagMergeMode
+
+-- method TagSetter::merge_tags
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagSetter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "list", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mode", argType = TInterface "Gst" "TagMergeMode", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_tag_setter_merge_tags" gst_tag_setter_merge_tags :: 
+    Ptr TagSetter ->                        -- _obj : TInterface "Gst" "TagSetter"
+    Ptr TagList ->                          -- list : TInterface "Gst" "TagList"
+    CUInt ->                                -- mode : TInterface "Gst" "TagMergeMode"
+    IO ()
+
+
+tagSetterMergeTags ::
+    (MonadIO m, TagSetterK a) =>
+    a                                       -- _obj
+    -> TagList                              -- list
+    -> TagMergeMode                         -- mode
+    -> m ()                                 -- result
+tagSetterMergeTags _obj list mode = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let list' = unsafeManagedPtrGetPtr list
+    let mode' = (fromIntegral . fromEnum) mode
+    gst_tag_setter_merge_tags _obj' list' mode'
+    touchManagedPtr _obj
+    touchManagedPtr list
+    return ()
+
+data TagSetterMergeTagsMethodInfo
+instance (signature ~ (TagList -> TagMergeMode -> m ()), MonadIO m, TagSetterK a) => MethodInfo TagSetterMergeTagsMethodInfo a signature where
+    overloadedMethod _ = tagSetterMergeTags
+
+-- method TagSetter::reset_tags
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagSetter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_tag_setter_reset_tags" gst_tag_setter_reset_tags :: 
+    Ptr TagSetter ->                        -- _obj : TInterface "Gst" "TagSetter"
+    IO ()
+
+
+tagSetterResetTags ::
+    (MonadIO m, TagSetterK a) =>
+    a                                       -- _obj
+    -> m ()                                 -- result
+tagSetterResetTags _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    gst_tag_setter_reset_tags _obj'
+    touchManagedPtr _obj
+    return ()
+
+data TagSetterResetTagsMethodInfo
+instance (signature ~ (m ()), MonadIO m, TagSetterK a) => MethodInfo TagSetterResetTagsMethodInfo a signature where
+    overloadedMethod _ = tagSetterResetTags
+
+-- method TagSetter::set_tag_merge_mode
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagSetter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mode", argType = TInterface "Gst" "TagMergeMode", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_tag_setter_set_tag_merge_mode" gst_tag_setter_set_tag_merge_mode :: 
+    Ptr TagSetter ->                        -- _obj : TInterface "Gst" "TagSetter"
+    CUInt ->                                -- mode : TInterface "Gst" "TagMergeMode"
+    IO ()
+
+
+tagSetterSetTagMergeMode ::
+    (MonadIO m, TagSetterK a) =>
+    a                                       -- _obj
+    -> TagMergeMode                         -- mode
+    -> m ()                                 -- result
+tagSetterSetTagMergeMode _obj mode = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let mode' = (fromIntegral . fromEnum) mode
+    gst_tag_setter_set_tag_merge_mode _obj' mode'
+    touchManagedPtr _obj
+    return ()
+
+data TagSetterSetTagMergeModeMethodInfo
+instance (signature ~ (TagMergeMode -> m ()), MonadIO m, TagSetterK a) => MethodInfo TagSetterSetTagMergeModeMethodInfo a signature where
+    overloadedMethod _ = tagSetterSetTagMergeMode
+
+
diff --git a/GI/Gst/Interfaces/TagSetter.hs-boot b/GI/Gst/Interfaces/TagSetter.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Interfaces/TagSetter.hs-boot
@@ -0,0 +1,19 @@
+module GI.Gst.Interfaces.TagSetter where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+newtype TagSetter = TagSetter (ForeignPtr TagSetter)
+instance GObject TagSetter where
+class GObject o => TagSetterK o
+instance (GObject o, IsDescendantOf TagSetter o) => TagSetterK o
+data TagSetterAddTagValueMethodInfo
+data TagSetterGetTagListMethodInfo
+data TagSetterGetTagMergeModeMethodInfo
+data TagSetterMergeTagsMethodInfo
+data TagSetterResetTagsMethodInfo
+data TagSetterSetTagMergeModeMethodInfo
diff --git a/GI/Gst/Interfaces/TocSetter.hs b/GI/Gst/Interfaces/TocSetter.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Interfaces/TocSetter.hs
@@ -0,0 +1,276 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+-}
+
+module GI.Gst.Interfaces.TocSetter
+    ( 
+
+-- * Exported types
+    TocSetter(..)                           ,
+    noTocSetter                             ,
+    TocSetterK                              ,
+    toTocSetter                             ,
+
+
+ -- * Methods
+-- ** tocSetterGetToc
+    TocSetterGetTocMethodInfo               ,
+    tocSetterGetToc                         ,
+
+
+-- ** tocSetterReset
+    TocSetterResetMethodInfo                ,
+    tocSetterReset                          ,
+
+
+-- ** tocSetterSetToc
+    TocSetterSetTocMethodInfo               ,
+    tocSetterSetToc                         ,
+
+
+
+
+    ) where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+import GI.Gst.Callbacks
+import qualified GI.GObject as GObject
+
+-- interface TocSetter 
+
+newtype TocSetter = TocSetter (ForeignPtr TocSetter)
+noTocSetter :: Maybe TocSetter
+noTocSetter = Nothing
+
+type family ResolveTocSetterMethod (t :: Symbol) (o :: *) :: * where
+    ResolveTocSetterMethod "abortState" o = ElementAbortStateMethodInfo
+    ResolveTocSetterMethod "addControlBinding" o = ObjectAddControlBindingMethodInfo
+    ResolveTocSetterMethod "addPad" o = ElementAddPadMethodInfo
+    ResolveTocSetterMethod "bindProperty" o = GObject.ObjectBindPropertyMethodInfo
+    ResolveTocSetterMethod "bindPropertyFull" o = GObject.ObjectBindPropertyFullMethodInfo
+    ResolveTocSetterMethod "changeState" o = ElementChangeStateMethodInfo
+    ResolveTocSetterMethod "continueState" o = ElementContinueStateMethodInfo
+    ResolveTocSetterMethod "createAllPads" o = ElementCreateAllPadsMethodInfo
+    ResolveTocSetterMethod "defaultError" o = ObjectDefaultErrorMethodInfo
+    ResolveTocSetterMethod "forceFloating" o = GObject.ObjectForceFloatingMethodInfo
+    ResolveTocSetterMethod "freezeNotify" o = GObject.ObjectFreezeNotifyMethodInfo
+    ResolveTocSetterMethod "hasActiveControlBindings" o = ObjectHasActiveControlBindingsMethodInfo
+    ResolveTocSetterMethod "hasAncestor" o = ObjectHasAncestorMethodInfo
+    ResolveTocSetterMethod "hasAsAncestor" o = ObjectHasAsAncestorMethodInfo
+    ResolveTocSetterMethod "hasAsParent" o = ObjectHasAsParentMethodInfo
+    ResolveTocSetterMethod "isFloating" o = GObject.ObjectIsFloatingMethodInfo
+    ResolveTocSetterMethod "isLockedState" o = ElementIsLockedStateMethodInfo
+    ResolveTocSetterMethod "iteratePads" o = ElementIteratePadsMethodInfo
+    ResolveTocSetterMethod "iterateSinkPads" o = ElementIterateSinkPadsMethodInfo
+    ResolveTocSetterMethod "iterateSrcPads" o = ElementIterateSrcPadsMethodInfo
+    ResolveTocSetterMethod "link" o = ElementLinkMethodInfo
+    ResolveTocSetterMethod "linkFiltered" o = ElementLinkFilteredMethodInfo
+    ResolveTocSetterMethod "linkPads" o = ElementLinkPadsMethodInfo
+    ResolveTocSetterMethod "linkPadsFiltered" o = ElementLinkPadsFilteredMethodInfo
+    ResolveTocSetterMethod "linkPadsFull" o = ElementLinkPadsFullMethodInfo
+    ResolveTocSetterMethod "lostState" o = ElementLostStateMethodInfo
+    ResolveTocSetterMethod "messageFull" o = ElementMessageFullMethodInfo
+    ResolveTocSetterMethod "noMorePads" o = ElementNoMorePadsMethodInfo
+    ResolveTocSetterMethod "notify" o = GObject.ObjectNotifyMethodInfo
+    ResolveTocSetterMethod "notifyByPspec" o = GObject.ObjectNotifyByPspecMethodInfo
+    ResolveTocSetterMethod "postMessage" o = ElementPostMessageMethodInfo
+    ResolveTocSetterMethod "provideClock" o = ElementProvideClockMethodInfo
+    ResolveTocSetterMethod "query" o = ElementQueryMethodInfo
+    ResolveTocSetterMethod "queryConvert" o = ElementQueryConvertMethodInfo
+    ResolveTocSetterMethod "queryDuration" o = ElementQueryDurationMethodInfo
+    ResolveTocSetterMethod "queryPosition" o = ElementQueryPositionMethodInfo
+    ResolveTocSetterMethod "refSink" o = GObject.ObjectRefSinkMethodInfo
+    ResolveTocSetterMethod "releaseRequestPad" o = ElementReleaseRequestPadMethodInfo
+    ResolveTocSetterMethod "removeControlBinding" o = ObjectRemoveControlBindingMethodInfo
+    ResolveTocSetterMethod "removePad" o = ElementRemovePadMethodInfo
+    ResolveTocSetterMethod "replaceData" o = GObject.ObjectReplaceDataMethodInfo
+    ResolveTocSetterMethod "replaceQdata" o = GObject.ObjectReplaceQdataMethodInfo
+    ResolveTocSetterMethod "requestPad" o = ElementRequestPadMethodInfo
+    ResolveTocSetterMethod "reset" o = TocSetterResetMethodInfo
+    ResolveTocSetterMethod "runDispose" o = GObject.ObjectRunDisposeMethodInfo
+    ResolveTocSetterMethod "seek" o = ElementSeekMethodInfo
+    ResolveTocSetterMethod "seekSimple" o = ElementSeekSimpleMethodInfo
+    ResolveTocSetterMethod "sendEvent" o = ElementSendEventMethodInfo
+    ResolveTocSetterMethod "stealData" o = GObject.ObjectStealDataMethodInfo
+    ResolveTocSetterMethod "stealQdata" o = GObject.ObjectStealQdataMethodInfo
+    ResolveTocSetterMethod "suggestNextSync" o = ObjectSuggestNextSyncMethodInfo
+    ResolveTocSetterMethod "syncStateWithParent" o = ElementSyncStateWithParentMethodInfo
+    ResolveTocSetterMethod "syncValues" o = ObjectSyncValuesMethodInfo
+    ResolveTocSetterMethod "thawNotify" o = GObject.ObjectThawNotifyMethodInfo
+    ResolveTocSetterMethod "unlink" o = ElementUnlinkMethodInfo
+    ResolveTocSetterMethod "unlinkPads" o = ElementUnlinkPadsMethodInfo
+    ResolveTocSetterMethod "unparent" o = ObjectUnparentMethodInfo
+    ResolveTocSetterMethod "watchClosure" o = GObject.ObjectWatchClosureMethodInfo
+    ResolveTocSetterMethod "getBaseTime" o = ElementGetBaseTimeMethodInfo
+    ResolveTocSetterMethod "getBus" o = ElementGetBusMethodInfo
+    ResolveTocSetterMethod "getClock" o = ElementGetClockMethodInfo
+    ResolveTocSetterMethod "getCompatiblePad" o = ElementGetCompatiblePadMethodInfo
+    ResolveTocSetterMethod "getCompatiblePadTemplate" o = ElementGetCompatiblePadTemplateMethodInfo
+    ResolveTocSetterMethod "getControlBinding" o = ObjectGetControlBindingMethodInfo
+    ResolveTocSetterMethod "getControlRate" o = ObjectGetControlRateMethodInfo
+    ResolveTocSetterMethod "getData" o = GObject.ObjectGetDataMethodInfo
+    ResolveTocSetterMethod "getFactory" o = ElementGetFactoryMethodInfo
+    ResolveTocSetterMethod "getGValueArray" o = ObjectGetGValueArrayMethodInfo
+    ResolveTocSetterMethod "getName" o = ObjectGetNameMethodInfo
+    ResolveTocSetterMethod "getParent" o = ObjectGetParentMethodInfo
+    ResolveTocSetterMethod "getPathString" o = ObjectGetPathStringMethodInfo
+    ResolveTocSetterMethod "getProperty" o = GObject.ObjectGetPropertyMethodInfo
+    ResolveTocSetterMethod "getQdata" o = GObject.ObjectGetQdataMethodInfo
+    ResolveTocSetterMethod "getRequestPad" o = ElementGetRequestPadMethodInfo
+    ResolveTocSetterMethod "getStartTime" o = ElementGetStartTimeMethodInfo
+    ResolveTocSetterMethod "getState" o = ElementGetStateMethodInfo
+    ResolveTocSetterMethod "getStaticPad" o = ElementGetStaticPadMethodInfo
+    ResolveTocSetterMethod "getToc" o = TocSetterGetTocMethodInfo
+    ResolveTocSetterMethod "getValue" o = ObjectGetValueMethodInfo
+    ResolveTocSetterMethod "getValueArray" o = ObjectGetValueArrayMethodInfo
+    ResolveTocSetterMethod "setBaseTime" o = ElementSetBaseTimeMethodInfo
+    ResolveTocSetterMethod "setBus" o = ElementSetBusMethodInfo
+    ResolveTocSetterMethod "setClock" o = ElementSetClockMethodInfo
+    ResolveTocSetterMethod "setContext" o = ElementSetContextMethodInfo
+    ResolveTocSetterMethod "setControlBindingDisabled" o = ObjectSetControlBindingDisabledMethodInfo
+    ResolveTocSetterMethod "setControlBindingsDisabled" o = ObjectSetControlBindingsDisabledMethodInfo
+    ResolveTocSetterMethod "setControlRate" o = ObjectSetControlRateMethodInfo
+    ResolveTocSetterMethod "setData" o = GObject.ObjectSetDataMethodInfo
+    ResolveTocSetterMethod "setLockedState" o = ElementSetLockedStateMethodInfo
+    ResolveTocSetterMethod "setName" o = ObjectSetNameMethodInfo
+    ResolveTocSetterMethod "setParent" o = ObjectSetParentMethodInfo
+    ResolveTocSetterMethod "setProperty" o = GObject.ObjectSetPropertyMethodInfo
+    ResolveTocSetterMethod "setStartTime" o = ElementSetStartTimeMethodInfo
+    ResolveTocSetterMethod "setState" o = ElementSetStateMethodInfo
+    ResolveTocSetterMethod "setToc" o = TocSetterSetTocMethodInfo
+    ResolveTocSetterMethod l o = MethodResolutionFailed l o
+
+instance (info ~ ResolveTocSetterMethod t TocSetter, MethodInfo info TocSetter p) => IsLabelProxy t (TocSetter -> p) where
+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)
+
+#if MIN_VERSION_base(4,9,0)
+instance (info ~ ResolveTocSetterMethod t TocSetter, MethodInfo info TocSetter p) => IsLabel t (TocSetter -> p) where
+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)
+#endif
+
+type instance AttributeList TocSetter = TocSetterAttributeList
+type TocSetterAttributeList = ('[ '("name", ObjectNamePropertyInfo), '("parent", ObjectParentPropertyInfo)] :: [(Symbol, *)])
+
+type instance SignalList TocSetter = TocSetterSignalList
+type TocSetterSignalList = ('[ '("deepNotify", ObjectDeepNotifySignalInfo), '("noMorePads", ElementNoMorePadsSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("padAdded", ElementPadAddedSignalInfo), '("padRemoved", ElementPadRemovedSignalInfo)] :: [(Symbol, *)])
+
+foreign import ccall "gst_toc_setter_get_type"
+    c_gst_toc_setter_get_type :: IO GType
+
+type instance ParentTypes TocSetter = TocSetterParentTypes
+type TocSetterParentTypes = '[Element, Object, GObject.Object]
+
+instance GObject TocSetter where
+    gobjectIsInitiallyUnowned _ = True
+    gobjectType _ = c_gst_toc_setter_get_type
+    
+
+class GObject o => TocSetterK o
+instance (GObject o, IsDescendantOf TocSetter o) => TocSetterK o
+
+toTocSetter :: TocSetterK o => o -> IO TocSetter
+toTocSetter = unsafeCastTo TocSetter
+
+-- method TocSetter::get_toc
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TocSetter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Toc"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_toc_setter_get_toc" gst_toc_setter_get_toc :: 
+    Ptr TocSetter ->                        -- _obj : TInterface "Gst" "TocSetter"
+    IO (Ptr Toc)
+
+
+tocSetterGetToc ::
+    (MonadIO m, TocSetterK a) =>
+    a                                       -- _obj
+    -> m Toc                                -- result
+tocSetterGetToc _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_toc_setter_get_toc _obj'
+    checkUnexpectedReturnNULL "gst_toc_setter_get_toc" result
+    result' <- (wrapBoxed Toc) result
+    touchManagedPtr _obj
+    return result'
+
+data TocSetterGetTocMethodInfo
+instance (signature ~ (m Toc), MonadIO m, TocSetterK a) => MethodInfo TocSetterGetTocMethodInfo a signature where
+    overloadedMethod _ = tocSetterGetToc
+
+-- method TocSetter::reset
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TocSetter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_toc_setter_reset" gst_toc_setter_reset :: 
+    Ptr TocSetter ->                        -- _obj : TInterface "Gst" "TocSetter"
+    IO ()
+
+
+tocSetterReset ::
+    (MonadIO m, TocSetterK a) =>
+    a                                       -- _obj
+    -> m ()                                 -- result
+tocSetterReset _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    gst_toc_setter_reset _obj'
+    touchManagedPtr _obj
+    return ()
+
+data TocSetterResetMethodInfo
+instance (signature ~ (m ()), MonadIO m, TocSetterK a) => MethodInfo TocSetterResetMethodInfo a signature where
+    overloadedMethod _ = tocSetterReset
+
+-- method TocSetter::set_toc
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TocSetter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "toc", argType = TInterface "Gst" "Toc", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_toc_setter_set_toc" gst_toc_setter_set_toc :: 
+    Ptr TocSetter ->                        -- _obj : TInterface "Gst" "TocSetter"
+    Ptr Toc ->                              -- toc : TInterface "Gst" "Toc"
+    IO ()
+
+
+tocSetterSetToc ::
+    (MonadIO m, TocSetterK a) =>
+    a                                       -- _obj
+    -> Maybe (Toc)                          -- toc
+    -> m ()                                 -- result
+tocSetterSetToc _obj toc = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    maybeToc <- case toc of
+        Nothing -> return nullPtr
+        Just jToc -> do
+            let jToc' = unsafeManagedPtrGetPtr jToc
+            return jToc'
+    gst_toc_setter_set_toc _obj' maybeToc
+    touchManagedPtr _obj
+    whenJust toc touchManagedPtr
+    return ()
+
+data TocSetterSetTocMethodInfo
+instance (signature ~ (Maybe (Toc) -> m ()), MonadIO m, TocSetterK a) => MethodInfo TocSetterSetTocMethodInfo a signature where
+    overloadedMethod _ = tocSetterSetToc
+
+
diff --git a/GI/Gst/Interfaces/TocSetter.hs-boot b/GI/Gst/Interfaces/TocSetter.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Interfaces/TocSetter.hs-boot
@@ -0,0 +1,16 @@
+module GI.Gst.Interfaces.TocSetter where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+newtype TocSetter = TocSetter (ForeignPtr TocSetter)
+instance GObject TocSetter where
+class GObject o => TocSetterK o
+instance (GObject o, IsDescendantOf TocSetter o) => TocSetterK o
+data TocSetterGetTocMethodInfo
+data TocSetterResetMethodInfo
+data TocSetterSetTocMethodInfo
diff --git a/GI/Gst/Interfaces/URIHandler.hs b/GI/Gst/Interfaces/URIHandler.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Interfaces/URIHandler.hs
@@ -0,0 +1,208 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+-}
+
+module GI.Gst.Interfaces.URIHandler
+    ( 
+
+-- * Exported types
+    URIHandler(..)                          ,
+    noURIHandler                            ,
+    URIHandlerK                             ,
+
+
+ -- * Methods
+-- ** uRIHandlerGetProtocols
+    URIHandlerGetProtocolsMethodInfo        ,
+    uRIHandlerGetProtocols                  ,
+
+
+-- ** uRIHandlerGetUri
+    URIHandlerGetUriMethodInfo              ,
+    uRIHandlerGetUri                        ,
+
+
+-- ** uRIHandlerGetUriType
+    URIHandlerGetUriTypeMethodInfo          ,
+    uRIHandlerGetUriType                    ,
+
+
+-- ** uRIHandlerSetUri
+    URIHandlerSetUriMethodInfo              ,
+    uRIHandlerSetUri                        ,
+
+
+
+
+    ) where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+import GI.Gst.Callbacks
+
+-- interface URIHandler 
+
+newtype URIHandler = URIHandler (ForeignPtr URIHandler)
+noURIHandler :: Maybe URIHandler
+noURIHandler = Nothing
+
+type family ResolveURIHandlerMethod (t :: Symbol) (o :: *) :: * where
+    ResolveURIHandlerMethod "getProtocols" o = URIHandlerGetProtocolsMethodInfo
+    ResolveURIHandlerMethod "getUri" o = URIHandlerGetUriMethodInfo
+    ResolveURIHandlerMethod "getUriType" o = URIHandlerGetUriTypeMethodInfo
+    ResolveURIHandlerMethod "setUri" o = URIHandlerSetUriMethodInfo
+    ResolveURIHandlerMethod l o = MethodResolutionFailed l o
+
+instance (info ~ ResolveURIHandlerMethod t URIHandler, MethodInfo info URIHandler p) => IsLabelProxy t (URIHandler -> p) where
+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)
+
+#if MIN_VERSION_base(4,9,0)
+instance (info ~ ResolveURIHandlerMethod t URIHandler, MethodInfo info URIHandler p) => IsLabel t (URIHandler -> p) where
+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)
+#endif
+
+type instance AttributeList URIHandler = URIHandlerAttributeList
+type URIHandlerAttributeList = ('[ ] :: [(Symbol, *)])
+
+type instance SignalList URIHandler = URIHandlerSignalList
+type URIHandlerSignalList = ('[ ] :: [(Symbol, *)])
+
+class ForeignPtrNewtype a => URIHandlerK a
+instance (ForeignPtrNewtype o, IsDescendantOf URIHandler o) => URIHandlerK o
+type instance ParentTypes URIHandler = URIHandlerParentTypes
+type URIHandlerParentTypes = '[]
+
+-- method URIHandler::get_protocols
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "URIHandler", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TCArray True (-1) (-1) (TBasicType TUTF8)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_uri_handler_get_protocols" gst_uri_handler_get_protocols :: 
+    Ptr URIHandler ->                       -- _obj : TInterface "Gst" "URIHandler"
+    IO (Ptr CString)
+
+
+uRIHandlerGetProtocols ::
+    (MonadIO m, URIHandlerK a) =>
+    a                                       -- _obj
+    -> m [T.Text]                           -- result
+uRIHandlerGetProtocols _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_uri_handler_get_protocols _obj'
+    checkUnexpectedReturnNULL "gst_uri_handler_get_protocols" result
+    result' <- unpackZeroTerminatedUTF8CArray result
+    touchManagedPtr _obj
+    return result'
+
+data URIHandlerGetProtocolsMethodInfo
+instance (signature ~ (m [T.Text]), MonadIO m, URIHandlerK a) => MethodInfo URIHandlerGetProtocolsMethodInfo a signature where
+    overloadedMethod _ = uRIHandlerGetProtocols
+
+-- method URIHandler::get_uri
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "URIHandler", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUTF8
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_uri_handler_get_uri" gst_uri_handler_get_uri :: 
+    Ptr URIHandler ->                       -- _obj : TInterface "Gst" "URIHandler"
+    IO CString
+
+
+uRIHandlerGetUri ::
+    (MonadIO m, URIHandlerK a) =>
+    a                                       -- _obj
+    -> m T.Text                             -- result
+uRIHandlerGetUri _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_uri_handler_get_uri _obj'
+    checkUnexpectedReturnNULL "gst_uri_handler_get_uri" result
+    result' <- cstringToText result
+    freeMem result
+    touchManagedPtr _obj
+    return result'
+
+data URIHandlerGetUriMethodInfo
+instance (signature ~ (m T.Text), MonadIO m, URIHandlerK a) => MethodInfo URIHandlerGetUriMethodInfo a signature where
+    overloadedMethod _ = uRIHandlerGetUri
+
+-- method URIHandler::get_uri_type
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "URIHandler", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "URIType"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_uri_handler_get_uri_type" gst_uri_handler_get_uri_type :: 
+    Ptr URIHandler ->                       -- _obj : TInterface "Gst" "URIHandler"
+    IO CUInt
+
+
+uRIHandlerGetUriType ::
+    (MonadIO m, URIHandlerK a) =>
+    a                                       -- _obj
+    -> m URIType                            -- result
+uRIHandlerGetUriType _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_uri_handler_get_uri_type _obj'
+    let result' = (toEnum . fromIntegral) result
+    touchManagedPtr _obj
+    return result'
+
+data URIHandlerGetUriTypeMethodInfo
+instance (signature ~ (m URIType), MonadIO m, URIHandlerK a) => MethodInfo URIHandlerGetUriTypeMethodInfo a signature where
+    overloadedMethod _ = uRIHandlerGetUriType
+
+-- method URIHandler::set_uri
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "URIHandler", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : True
+-- Skip return : False
+
+foreign import ccall "gst_uri_handler_set_uri" gst_uri_handler_set_uri :: 
+    Ptr URIHandler ->                       -- _obj : TInterface "Gst" "URIHandler"
+    CString ->                              -- uri : TBasicType TUTF8
+    Ptr (Ptr GError) ->                     -- error
+    IO CInt
+
+
+uRIHandlerSetUri ::
+    (MonadIO m, URIHandlerK a) =>
+    a                                       -- _obj
+    -> T.Text                               -- uri
+    -> m ()                                 -- result
+uRIHandlerSetUri _obj uri = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    uri' <- textToCString uri
+    onException (do
+        _ <- propagateGError $ gst_uri_handler_set_uri _obj' uri'
+        touchManagedPtr _obj
+        freeMem uri'
+        return ()
+     ) (do
+        freeMem uri'
+     )
+
+data URIHandlerSetUriMethodInfo
+instance (signature ~ (T.Text -> m ()), MonadIO m, URIHandlerK a) => MethodInfo URIHandlerSetUriMethodInfo a signature where
+    overloadedMethod _ = uRIHandlerSetUri
+
+
diff --git a/GI/Gst/Interfaces/URIHandler.hs-boot b/GI/Gst/Interfaces/URIHandler.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Interfaces/URIHandler.hs-boot
@@ -0,0 +1,16 @@
+module GI.Gst.Interfaces.URIHandler where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+newtype URIHandler = URIHandler (ForeignPtr URIHandler)
+class ForeignPtrNewtype a => URIHandlerK a
+instance (ForeignPtrNewtype o, IsDescendantOf URIHandler o) => URIHandlerK o
+data URIHandlerGetProtocolsMethodInfo
+data URIHandlerGetUriMethodInfo
+data URIHandlerGetUriTypeMethodInfo
+data URIHandlerSetUriMethodInfo
diff --git a/GI/Gst/Objects.hs b/GI/Gst/Objects.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Objects.hs
@@ -0,0 +1,77 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+-}
+
+module GI.Gst.Objects
+    (     module GI.Gst.Objects.Allocator         ,
+    module GI.Gst.Objects.Bin               ,
+    module GI.Gst.Objects.BufferPool        ,
+    module GI.Gst.Objects.Bus               ,
+    module GI.Gst.Objects.Clock             ,
+    module GI.Gst.Objects.ControlBinding    ,
+    module GI.Gst.Objects.ControlSource     ,
+    module GI.Gst.Objects.Device            ,
+    module GI.Gst.Objects.DeviceMonitor     ,
+    module GI.Gst.Objects.DeviceProvider    ,
+    module GI.Gst.Objects.DeviceProviderFactory,
+    module GI.Gst.Objects.Element           ,
+    module GI.Gst.Objects.ElementFactory    ,
+    module GI.Gst.Objects.GhostPad          ,
+    module GI.Gst.Objects.Object            ,
+    module GI.Gst.Objects.Pad               ,
+    module GI.Gst.Objects.PadTemplate       ,
+    module GI.Gst.Objects.Pipeline          ,
+    module GI.Gst.Objects.Plugin            ,
+    module GI.Gst.Objects.PluginFeature     ,
+    module GI.Gst.Objects.ProxyPad          ,
+    module GI.Gst.Objects.Registry          ,
+    module GI.Gst.Objects.SystemClock       ,
+    module GI.Gst.Objects.Task              ,
+    module GI.Gst.Objects.TaskPool          ,
+    module GI.Gst.Objects.TypeFindFactory   ,
+
+
+    ) where
+
+import GI.Gst.Objects.Allocator
+import GI.Gst.Objects.Bin
+import GI.Gst.Objects.BufferPool
+import GI.Gst.Objects.Bus
+import GI.Gst.Objects.Clock
+import GI.Gst.Objects.ControlBinding
+import GI.Gst.Objects.ControlSource
+import GI.Gst.Objects.Device
+import GI.Gst.Objects.DeviceMonitor
+import GI.Gst.Objects.DeviceProvider
+import GI.Gst.Objects.DeviceProviderFactory
+import GI.Gst.Objects.Element
+import GI.Gst.Objects.ElementFactory
+import GI.Gst.Objects.GhostPad
+import GI.Gst.Objects.Object
+import GI.Gst.Objects.Pad
+import GI.Gst.Objects.PadTemplate
+import GI.Gst.Objects.Pipeline
+import GI.Gst.Objects.Plugin
+import GI.Gst.Objects.PluginFeature
+import GI.Gst.Objects.ProxyPad
+import GI.Gst.Objects.Registry
+import GI.Gst.Objects.SystemClock
+import GI.Gst.Objects.Task
+import GI.Gst.Objects.TaskPool
+import GI.Gst.Objects.TypeFindFactory
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+import GI.Gst.Callbacks
+
+
diff --git a/GI/Gst/Objects/Allocator.hs b/GI/Gst/Objects/Allocator.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Objects/Allocator.hs
@@ -0,0 +1,295 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+-}
+
+module GI.Gst.Objects.Allocator
+    ( 
+
+-- * Exported types
+    Allocator(..)                           ,
+    AllocatorK                              ,
+    toAllocator                             ,
+    noAllocator                             ,
+
+
+ -- * Methods
+-- ** allocatorAlloc
+    AllocatorAllocMethodInfo                ,
+    allocatorAlloc                          ,
+
+
+-- ** allocatorFind
+    allocatorFind                           ,
+
+
+-- ** allocatorFree
+    AllocatorFreeMethodInfo                 ,
+    allocatorFree                           ,
+
+
+-- ** allocatorRegister
+    allocatorRegister                       ,
+
+
+-- ** allocatorSetDefault
+    AllocatorSetDefaultMethodInfo           ,
+    allocatorSetDefault                     ,
+
+
+
+
+    ) where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+import GI.Gst.Callbacks
+import qualified GI.GObject as GObject
+
+newtype Allocator = Allocator (ForeignPtr Allocator)
+foreign import ccall "gst_allocator_get_type"
+    c_gst_allocator_get_type :: IO GType
+
+type instance ParentTypes Allocator = AllocatorParentTypes
+type AllocatorParentTypes = '[Object, GObject.Object]
+
+instance GObject Allocator where
+    gobjectIsInitiallyUnowned _ = True
+    gobjectType _ = c_gst_allocator_get_type
+    
+
+class GObject o => AllocatorK o
+instance (GObject o, IsDescendantOf Allocator o) => AllocatorK o
+
+toAllocator :: AllocatorK o => o -> IO Allocator
+toAllocator = unsafeCastTo Allocator
+
+noAllocator :: Maybe Allocator
+noAllocator = Nothing
+
+type family ResolveAllocatorMethod (t :: Symbol) (o :: *) :: * where
+    ResolveAllocatorMethod "addControlBinding" o = ObjectAddControlBindingMethodInfo
+    ResolveAllocatorMethod "alloc" o = AllocatorAllocMethodInfo
+    ResolveAllocatorMethod "bindProperty" o = GObject.ObjectBindPropertyMethodInfo
+    ResolveAllocatorMethod "bindPropertyFull" o = GObject.ObjectBindPropertyFullMethodInfo
+    ResolveAllocatorMethod "defaultError" o = ObjectDefaultErrorMethodInfo
+    ResolveAllocatorMethod "forceFloating" o = GObject.ObjectForceFloatingMethodInfo
+    ResolveAllocatorMethod "free" o = AllocatorFreeMethodInfo
+    ResolveAllocatorMethod "freezeNotify" o = GObject.ObjectFreezeNotifyMethodInfo
+    ResolveAllocatorMethod "hasActiveControlBindings" o = ObjectHasActiveControlBindingsMethodInfo
+    ResolveAllocatorMethod "hasAncestor" o = ObjectHasAncestorMethodInfo
+    ResolveAllocatorMethod "hasAsAncestor" o = ObjectHasAsAncestorMethodInfo
+    ResolveAllocatorMethod "hasAsParent" o = ObjectHasAsParentMethodInfo
+    ResolveAllocatorMethod "isFloating" o = GObject.ObjectIsFloatingMethodInfo
+    ResolveAllocatorMethod "notify" o = GObject.ObjectNotifyMethodInfo
+    ResolveAllocatorMethod "notifyByPspec" o = GObject.ObjectNotifyByPspecMethodInfo
+    ResolveAllocatorMethod "refSink" o = GObject.ObjectRefSinkMethodInfo
+    ResolveAllocatorMethod "removeControlBinding" o = ObjectRemoveControlBindingMethodInfo
+    ResolveAllocatorMethod "replaceData" o = GObject.ObjectReplaceDataMethodInfo
+    ResolveAllocatorMethod "replaceQdata" o = GObject.ObjectReplaceQdataMethodInfo
+    ResolveAllocatorMethod "runDispose" o = GObject.ObjectRunDisposeMethodInfo
+    ResolveAllocatorMethod "stealData" o = GObject.ObjectStealDataMethodInfo
+    ResolveAllocatorMethod "stealQdata" o = GObject.ObjectStealQdataMethodInfo
+    ResolveAllocatorMethod "suggestNextSync" o = ObjectSuggestNextSyncMethodInfo
+    ResolveAllocatorMethod "syncValues" o = ObjectSyncValuesMethodInfo
+    ResolveAllocatorMethod "thawNotify" o = GObject.ObjectThawNotifyMethodInfo
+    ResolveAllocatorMethod "unparent" o = ObjectUnparentMethodInfo
+    ResolveAllocatorMethod "watchClosure" o = GObject.ObjectWatchClosureMethodInfo
+    ResolveAllocatorMethod "getControlBinding" o = ObjectGetControlBindingMethodInfo
+    ResolveAllocatorMethod "getControlRate" o = ObjectGetControlRateMethodInfo
+    ResolveAllocatorMethod "getData" o = GObject.ObjectGetDataMethodInfo
+    ResolveAllocatorMethod "getGValueArray" o = ObjectGetGValueArrayMethodInfo
+    ResolveAllocatorMethod "getName" o = ObjectGetNameMethodInfo
+    ResolveAllocatorMethod "getParent" o = ObjectGetParentMethodInfo
+    ResolveAllocatorMethod "getPathString" o = ObjectGetPathStringMethodInfo
+    ResolveAllocatorMethod "getProperty" o = GObject.ObjectGetPropertyMethodInfo
+    ResolveAllocatorMethod "getQdata" o = GObject.ObjectGetQdataMethodInfo
+    ResolveAllocatorMethod "getValue" o = ObjectGetValueMethodInfo
+    ResolveAllocatorMethod "getValueArray" o = ObjectGetValueArrayMethodInfo
+    ResolveAllocatorMethod "setControlBindingDisabled" o = ObjectSetControlBindingDisabledMethodInfo
+    ResolveAllocatorMethod "setControlBindingsDisabled" o = ObjectSetControlBindingsDisabledMethodInfo
+    ResolveAllocatorMethod "setControlRate" o = ObjectSetControlRateMethodInfo
+    ResolveAllocatorMethod "setData" o = GObject.ObjectSetDataMethodInfo
+    ResolveAllocatorMethod "setDefault" o = AllocatorSetDefaultMethodInfo
+    ResolveAllocatorMethod "setName" o = ObjectSetNameMethodInfo
+    ResolveAllocatorMethod "setParent" o = ObjectSetParentMethodInfo
+    ResolveAllocatorMethod "setProperty" o = GObject.ObjectSetPropertyMethodInfo
+    ResolveAllocatorMethod l o = MethodResolutionFailed l o
+
+instance (info ~ ResolveAllocatorMethod t Allocator, MethodInfo info Allocator p) => IsLabelProxy t (Allocator -> p) where
+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)
+
+#if MIN_VERSION_base(4,9,0)
+instance (info ~ ResolveAllocatorMethod t Allocator, MethodInfo info Allocator p) => IsLabel t (Allocator -> p) where
+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)
+#endif
+
+type instance AttributeList Allocator = AllocatorAttributeList
+type AllocatorAttributeList = ('[ '("name", ObjectNamePropertyInfo), '("parent", ObjectParentPropertyInfo)] :: [(Symbol, *)])
+
+type instance SignalList Allocator = AllocatorSignalList
+type AllocatorSignalList = ('[ '("deepNotify", ObjectDeepNotifySignalInfo), '("notify", GObject.ObjectNotifySignalInfo)] :: [(Symbol, *)])
+
+-- method Allocator::alloc
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Allocator", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "params", argType = TInterface "Gst" "AllocationParams", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Memory"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_allocator_alloc" gst_allocator_alloc :: 
+    Ptr Allocator ->                        -- _obj : TInterface "Gst" "Allocator"
+    Word64 ->                               -- size : TBasicType TUInt64
+    Ptr AllocationParams ->                 -- params : TInterface "Gst" "AllocationParams"
+    IO (Ptr Memory)
+
+
+allocatorAlloc ::
+    (MonadIO m, AllocatorK a) =>
+    a                                       -- _obj
+    -> Word64                               -- size
+    -> Maybe (AllocationParams)             -- params
+    -> m Memory                             -- result
+allocatorAlloc _obj size params = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    maybeParams <- case params of
+        Nothing -> return nullPtr
+        Just jParams -> do
+            let jParams' = unsafeManagedPtrGetPtr jParams
+            return jParams'
+    result <- gst_allocator_alloc _obj' size maybeParams
+    checkUnexpectedReturnNULL "gst_allocator_alloc" result
+    result' <- (wrapBoxed Memory) result
+    touchManagedPtr _obj
+    whenJust params touchManagedPtr
+    return result'
+
+data AllocatorAllocMethodInfo
+instance (signature ~ (Word64 -> Maybe (AllocationParams) -> m Memory), MonadIO m, AllocatorK a) => MethodInfo AllocatorAllocMethodInfo a signature where
+    overloadedMethod _ = allocatorAlloc
+
+-- method Allocator::free
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Allocator", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "memory", argType = TInterface "Gst" "Memory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_allocator_free" gst_allocator_free :: 
+    Ptr Allocator ->                        -- _obj : TInterface "Gst" "Allocator"
+    Ptr Memory ->                           -- memory : TInterface "Gst" "Memory"
+    IO ()
+
+
+allocatorFree ::
+    (MonadIO m, AllocatorK a) =>
+    a                                       -- _obj
+    -> Memory                               -- memory
+    -> m ()                                 -- result
+allocatorFree _obj memory = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    memory' <- copyBoxed memory
+    gst_allocator_free _obj' memory'
+    touchManagedPtr _obj
+    touchManagedPtr memory
+    return ()
+
+data AllocatorFreeMethodInfo
+instance (signature ~ (Memory -> m ()), MonadIO m, AllocatorK a) => MethodInfo AllocatorFreeMethodInfo a signature where
+    overloadedMethod _ = allocatorFree
+
+-- method Allocator::set_default
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Allocator", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_allocator_set_default" gst_allocator_set_default :: 
+    Ptr Allocator ->                        -- _obj : TInterface "Gst" "Allocator"
+    IO ()
+
+
+allocatorSetDefault ::
+    (MonadIO m, AllocatorK a) =>
+    a                                       -- _obj
+    -> m ()                                 -- result
+allocatorSetDefault _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    gst_allocator_set_default _obj'
+    touchManagedPtr _obj
+    return ()
+
+data AllocatorSetDefaultMethodInfo
+instance (signature ~ (m ()), MonadIO m, AllocatorK a) => MethodInfo AllocatorSetDefaultMethodInfo a signature where
+    overloadedMethod _ = allocatorSetDefault
+
+-- method Allocator::find
+-- method type : MemberFunction
+-- Args : [Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Allocator"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_allocator_find" gst_allocator_find :: 
+    CString ->                              -- name : TBasicType TUTF8
+    IO (Ptr Allocator)
+
+
+allocatorFind ::
+    (MonadIO m) =>
+    Maybe (T.Text)                          -- name
+    -> m Allocator                          -- result
+allocatorFind name = liftIO $ do
+    maybeName <- case name of
+        Nothing -> return nullPtr
+        Just jName -> do
+            jName' <- textToCString jName
+            return jName'
+    result <- gst_allocator_find maybeName
+    checkUnexpectedReturnNULL "gst_allocator_find" result
+    result' <- (wrapObject Allocator) result
+    freeMem maybeName
+    return result'
+
+-- method Allocator::register
+-- method type : MemberFunction
+-- Args : [Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "allocator", argType = TInterface "Gst" "Allocator", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_allocator_register" gst_allocator_register :: 
+    CString ->                              -- name : TBasicType TUTF8
+    Ptr Allocator ->                        -- allocator : TInterface "Gst" "Allocator"
+    IO ()
+
+
+allocatorRegister ::
+    (MonadIO m, AllocatorK a) =>
+    T.Text                                  -- name
+    -> a                                    -- allocator
+    -> m ()                                 -- result
+allocatorRegister name allocator = liftIO $ do
+    name' <- textToCString name
+    allocator' <- refObject allocator
+    gst_allocator_register name' allocator'
+    touchManagedPtr allocator
+    freeMem name'
+    return ()
+
+
diff --git a/GI/Gst/Objects/Allocator.hs-boot b/GI/Gst/Objects/Allocator.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Objects/Allocator.hs-boot
@@ -0,0 +1,16 @@
+module GI.Gst.Objects.Allocator where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+newtype Allocator = Allocator (ForeignPtr Allocator)
+instance GObject Allocator where
+class GObject o => AllocatorK o
+instance (GObject o, IsDescendantOf Allocator o) => AllocatorK o
+data AllocatorAllocMethodInfo
+data AllocatorFreeMethodInfo
+data AllocatorSetDefaultMethodInfo
diff --git a/GI/Gst/Objects/Bin.hs b/GI/Gst/Objects/Bin.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Objects/Bin.hs
@@ -0,0 +1,956 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+-}
+
+module GI.Gst.Objects.Bin
+    ( 
+
+-- * Exported types
+    Bin(..)                                 ,
+    BinK                                    ,
+    toBin                                   ,
+    noBin                                   ,
+
+
+ -- * Methods
+-- ** binAdd
+    BinAddMethodInfo                        ,
+    binAdd                                  ,
+
+
+-- ** binFindUnlinkedPad
+    BinFindUnlinkedPadMethodInfo            ,
+    binFindUnlinkedPad                      ,
+
+
+-- ** binGetByInterface
+    BinGetByInterfaceMethodInfo             ,
+    binGetByInterface                       ,
+
+
+-- ** binGetByName
+    BinGetByNameMethodInfo                  ,
+    binGetByName                            ,
+
+
+-- ** binGetByNameRecurseUp
+    BinGetByNameRecurseUpMethodInfo         ,
+    binGetByNameRecurseUp                   ,
+
+
+-- ** binIterateAllByInterface
+    BinIterateAllByInterfaceMethodInfo      ,
+    binIterateAllByInterface                ,
+
+
+-- ** binIterateElements
+    BinIterateElementsMethodInfo            ,
+    binIterateElements                      ,
+
+
+-- ** binIterateRecurse
+    BinIterateRecurseMethodInfo             ,
+    binIterateRecurse                       ,
+
+
+-- ** binIterateSinks
+    BinIterateSinksMethodInfo               ,
+    binIterateSinks                         ,
+
+
+-- ** binIterateSorted
+    BinIterateSortedMethodInfo              ,
+    binIterateSorted                        ,
+
+
+-- ** binIterateSources
+    BinIterateSourcesMethodInfo             ,
+    binIterateSources                       ,
+
+
+-- ** binNew
+    binNew                                  ,
+
+
+-- ** binRecalculateLatency
+    BinRecalculateLatencyMethodInfo         ,
+    binRecalculateLatency                   ,
+
+
+-- ** binRemove
+    BinRemoveMethodInfo                     ,
+    binRemove                               ,
+
+
+-- ** binSyncChildrenStates
+    BinSyncChildrenStatesMethodInfo         ,
+    binSyncChildrenStates                   ,
+
+
+
+
+ -- * Properties
+-- ** AsyncHandling
+    BinAsyncHandlingPropertyInfo            ,
+    constructBinAsyncHandling               ,
+    getBinAsyncHandling                     ,
+    setBinAsyncHandling                     ,
+
+
+-- ** MessageForward
+    BinMessageForwardPropertyInfo           ,
+    constructBinMessageForward              ,
+    getBinMessageForward                    ,
+    setBinMessageForward                    ,
+
+
+
+
+ -- * Signals
+-- ** DoLatency
+    BinDoLatencyCallback                    ,
+    BinDoLatencyCallbackC                   ,
+    BinDoLatencySignalInfo                  ,
+    afterBinDoLatency                       ,
+    binDoLatencyCallbackWrapper             ,
+    binDoLatencyClosure                     ,
+    mkBinDoLatencyCallback                  ,
+    noBinDoLatencyCallback                  ,
+    onBinDoLatency                          ,
+
+
+-- ** ElementAdded
+    BinElementAddedCallback                 ,
+    BinElementAddedCallbackC                ,
+    BinElementAddedSignalInfo               ,
+    afterBinElementAdded                    ,
+    binElementAddedCallbackWrapper          ,
+    binElementAddedClosure                  ,
+    mkBinElementAddedCallback               ,
+    noBinElementAddedCallback               ,
+    onBinElementAdded                       ,
+
+
+-- ** ElementRemoved
+    BinElementRemovedCallback               ,
+    BinElementRemovedCallbackC              ,
+    BinElementRemovedSignalInfo             ,
+    afterBinElementRemoved                  ,
+    binElementRemovedCallbackWrapper        ,
+    binElementRemovedClosure                ,
+    mkBinElementRemovedCallback             ,
+    noBinElementRemovedCallback             ,
+    onBinElementRemoved                     ,
+
+
+
+
+    ) where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+import GI.Gst.Callbacks
+import qualified GI.GObject as GObject
+
+newtype Bin = Bin (ForeignPtr Bin)
+foreign import ccall "gst_bin_get_type"
+    c_gst_bin_get_type :: IO GType
+
+type instance ParentTypes Bin = BinParentTypes
+type BinParentTypes = '[Element, Object, GObject.Object, ChildProxy]
+
+instance GObject Bin where
+    gobjectIsInitiallyUnowned _ = True
+    gobjectType _ = c_gst_bin_get_type
+    
+
+class GObject o => BinK o
+instance (GObject o, IsDescendantOf Bin o) => BinK o
+
+toBin :: BinK o => o -> IO Bin
+toBin = unsafeCastTo Bin
+
+noBin :: Maybe Bin
+noBin = Nothing
+
+type family ResolveBinMethod (t :: Symbol) (o :: *) :: * where
+    ResolveBinMethod "abortState" o = ElementAbortStateMethodInfo
+    ResolveBinMethod "add" o = BinAddMethodInfo
+    ResolveBinMethod "addControlBinding" o = ObjectAddControlBindingMethodInfo
+    ResolveBinMethod "addPad" o = ElementAddPadMethodInfo
+    ResolveBinMethod "bindProperty" o = GObject.ObjectBindPropertyMethodInfo
+    ResolveBinMethod "bindPropertyFull" o = GObject.ObjectBindPropertyFullMethodInfo
+    ResolveBinMethod "changeState" o = ElementChangeStateMethodInfo
+    ResolveBinMethod "childAdded" o = ChildProxyChildAddedMethodInfo
+    ResolveBinMethod "childRemoved" o = ChildProxyChildRemovedMethodInfo
+    ResolveBinMethod "continueState" o = ElementContinueStateMethodInfo
+    ResolveBinMethod "createAllPads" o = ElementCreateAllPadsMethodInfo
+    ResolveBinMethod "defaultError" o = ObjectDefaultErrorMethodInfo
+    ResolveBinMethod "findUnlinkedPad" o = BinFindUnlinkedPadMethodInfo
+    ResolveBinMethod "forceFloating" o = GObject.ObjectForceFloatingMethodInfo
+    ResolveBinMethod "freezeNotify" o = GObject.ObjectFreezeNotifyMethodInfo
+    ResolveBinMethod "hasActiveControlBindings" o = ObjectHasActiveControlBindingsMethodInfo
+    ResolveBinMethod "hasAncestor" o = ObjectHasAncestorMethodInfo
+    ResolveBinMethod "hasAsAncestor" o = ObjectHasAsAncestorMethodInfo
+    ResolveBinMethod "hasAsParent" o = ObjectHasAsParentMethodInfo
+    ResolveBinMethod "isFloating" o = GObject.ObjectIsFloatingMethodInfo
+    ResolveBinMethod "isLockedState" o = ElementIsLockedStateMethodInfo
+    ResolveBinMethod "iterateAllByInterface" o = BinIterateAllByInterfaceMethodInfo
+    ResolveBinMethod "iterateElements" o = BinIterateElementsMethodInfo
+    ResolveBinMethod "iteratePads" o = ElementIteratePadsMethodInfo
+    ResolveBinMethod "iterateRecurse" o = BinIterateRecurseMethodInfo
+    ResolveBinMethod "iterateSinkPads" o = ElementIterateSinkPadsMethodInfo
+    ResolveBinMethod "iterateSinks" o = BinIterateSinksMethodInfo
+    ResolveBinMethod "iterateSorted" o = BinIterateSortedMethodInfo
+    ResolveBinMethod "iterateSources" o = BinIterateSourcesMethodInfo
+    ResolveBinMethod "iterateSrcPads" o = ElementIterateSrcPadsMethodInfo
+    ResolveBinMethod "link" o = ElementLinkMethodInfo
+    ResolveBinMethod "linkFiltered" o = ElementLinkFilteredMethodInfo
+    ResolveBinMethod "linkPads" o = ElementLinkPadsMethodInfo
+    ResolveBinMethod "linkPadsFiltered" o = ElementLinkPadsFilteredMethodInfo
+    ResolveBinMethod "linkPadsFull" o = ElementLinkPadsFullMethodInfo
+    ResolveBinMethod "lookup" o = ChildProxyLookupMethodInfo
+    ResolveBinMethod "lostState" o = ElementLostStateMethodInfo
+    ResolveBinMethod "messageFull" o = ElementMessageFullMethodInfo
+    ResolveBinMethod "noMorePads" o = ElementNoMorePadsMethodInfo
+    ResolveBinMethod "notify" o = GObject.ObjectNotifyMethodInfo
+    ResolveBinMethod "notifyByPspec" o = GObject.ObjectNotifyByPspecMethodInfo
+    ResolveBinMethod "postMessage" o = ElementPostMessageMethodInfo
+    ResolveBinMethod "provideClock" o = ElementProvideClockMethodInfo
+    ResolveBinMethod "query" o = ElementQueryMethodInfo
+    ResolveBinMethod "queryConvert" o = ElementQueryConvertMethodInfo
+    ResolveBinMethod "queryDuration" o = ElementQueryDurationMethodInfo
+    ResolveBinMethod "queryPosition" o = ElementQueryPositionMethodInfo
+    ResolveBinMethod "recalculateLatency" o = BinRecalculateLatencyMethodInfo
+    ResolveBinMethod "refSink" o = GObject.ObjectRefSinkMethodInfo
+    ResolveBinMethod "releaseRequestPad" o = ElementReleaseRequestPadMethodInfo
+    ResolveBinMethod "remove" o = BinRemoveMethodInfo
+    ResolveBinMethod "removeControlBinding" o = ObjectRemoveControlBindingMethodInfo
+    ResolveBinMethod "removePad" o = ElementRemovePadMethodInfo
+    ResolveBinMethod "replaceData" o = GObject.ObjectReplaceDataMethodInfo
+    ResolveBinMethod "replaceQdata" o = GObject.ObjectReplaceQdataMethodInfo
+    ResolveBinMethod "requestPad" o = ElementRequestPadMethodInfo
+    ResolveBinMethod "runDispose" o = GObject.ObjectRunDisposeMethodInfo
+    ResolveBinMethod "seek" o = ElementSeekMethodInfo
+    ResolveBinMethod "seekSimple" o = ElementSeekSimpleMethodInfo
+    ResolveBinMethod "sendEvent" o = ElementSendEventMethodInfo
+    ResolveBinMethod "stealData" o = GObject.ObjectStealDataMethodInfo
+    ResolveBinMethod "stealQdata" o = GObject.ObjectStealQdataMethodInfo
+    ResolveBinMethod "suggestNextSync" o = ObjectSuggestNextSyncMethodInfo
+    ResolveBinMethod "syncChildrenStates" o = BinSyncChildrenStatesMethodInfo
+    ResolveBinMethod "syncStateWithParent" o = ElementSyncStateWithParentMethodInfo
+    ResolveBinMethod "syncValues" o = ObjectSyncValuesMethodInfo
+    ResolveBinMethod "thawNotify" o = GObject.ObjectThawNotifyMethodInfo
+    ResolveBinMethod "unlink" o = ElementUnlinkMethodInfo
+    ResolveBinMethod "unlinkPads" o = ElementUnlinkPadsMethodInfo
+    ResolveBinMethod "unparent" o = ObjectUnparentMethodInfo
+    ResolveBinMethod "watchClosure" o = GObject.ObjectWatchClosureMethodInfo
+    ResolveBinMethod "getBaseTime" o = ElementGetBaseTimeMethodInfo
+    ResolveBinMethod "getBus" o = ElementGetBusMethodInfo
+    ResolveBinMethod "getByInterface" o = BinGetByInterfaceMethodInfo
+    ResolveBinMethod "getByName" o = BinGetByNameMethodInfo
+    ResolveBinMethod "getByNameRecurseUp" o = BinGetByNameRecurseUpMethodInfo
+    ResolveBinMethod "getChildByIndex" o = ChildProxyGetChildByIndexMethodInfo
+    ResolveBinMethod "getChildByName" o = ChildProxyGetChildByNameMethodInfo
+    ResolveBinMethod "getChildrenCount" o = ChildProxyGetChildrenCountMethodInfo
+    ResolveBinMethod "getClock" o = ElementGetClockMethodInfo
+    ResolveBinMethod "getCompatiblePad" o = ElementGetCompatiblePadMethodInfo
+    ResolveBinMethod "getCompatiblePadTemplate" o = ElementGetCompatiblePadTemplateMethodInfo
+    ResolveBinMethod "getControlBinding" o = ObjectGetControlBindingMethodInfo
+    ResolveBinMethod "getControlRate" o = ObjectGetControlRateMethodInfo
+    ResolveBinMethod "getData" o = GObject.ObjectGetDataMethodInfo
+    ResolveBinMethod "getFactory" o = ElementGetFactoryMethodInfo
+    ResolveBinMethod "getGValueArray" o = ObjectGetGValueArrayMethodInfo
+    ResolveBinMethod "getName" o = ObjectGetNameMethodInfo
+    ResolveBinMethod "getParent" o = ObjectGetParentMethodInfo
+    ResolveBinMethod "getPathString" o = ObjectGetPathStringMethodInfo
+    ResolveBinMethod "getQdata" o = GObject.ObjectGetQdataMethodInfo
+    ResolveBinMethod "getRequestPad" o = ElementGetRequestPadMethodInfo
+    ResolveBinMethod "getStartTime" o = ElementGetStartTimeMethodInfo
+    ResolveBinMethod "getState" o = ElementGetStateMethodInfo
+    ResolveBinMethod "getStaticPad" o = ElementGetStaticPadMethodInfo
+    ResolveBinMethod "getValue" o = ObjectGetValueMethodInfo
+    ResolveBinMethod "getValueArray" o = ObjectGetValueArrayMethodInfo
+    ResolveBinMethod "setBaseTime" o = ElementSetBaseTimeMethodInfo
+    ResolveBinMethod "setBus" o = ElementSetBusMethodInfo
+    ResolveBinMethod "setClock" o = ElementSetClockMethodInfo
+    ResolveBinMethod "setContext" o = ElementSetContextMethodInfo
+    ResolveBinMethod "setControlBindingDisabled" o = ObjectSetControlBindingDisabledMethodInfo
+    ResolveBinMethod "setControlBindingsDisabled" o = ObjectSetControlBindingsDisabledMethodInfo
+    ResolveBinMethod "setControlRate" o = ObjectSetControlRateMethodInfo
+    ResolveBinMethod "setData" o = GObject.ObjectSetDataMethodInfo
+    ResolveBinMethod "setLockedState" o = ElementSetLockedStateMethodInfo
+    ResolveBinMethod "setName" o = ObjectSetNameMethodInfo
+    ResolveBinMethod "setParent" o = ObjectSetParentMethodInfo
+    ResolveBinMethod "setStartTime" o = ElementSetStartTimeMethodInfo
+    ResolveBinMethod "setState" o = ElementSetStateMethodInfo
+    ResolveBinMethod l o = MethodResolutionFailed l o
+
+instance (info ~ ResolveBinMethod t Bin, MethodInfo info Bin p) => IsLabelProxy t (Bin -> p) where
+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)
+
+#if MIN_VERSION_base(4,9,0)
+instance (info ~ ResolveBinMethod t Bin, MethodInfo info Bin p) => IsLabel t (Bin -> p) where
+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)
+#endif
+
+-- signal Bin::do-latency
+type BinDoLatencyCallback =
+    IO Bool
+
+noBinDoLatencyCallback :: Maybe BinDoLatencyCallback
+noBinDoLatencyCallback = Nothing
+
+type BinDoLatencyCallbackC =
+    Ptr () ->                               -- object
+    Ptr () ->                               -- user_data
+    IO CInt
+
+foreign import ccall "wrapper"
+    mkBinDoLatencyCallback :: BinDoLatencyCallbackC -> IO (FunPtr BinDoLatencyCallbackC)
+
+binDoLatencyClosure :: BinDoLatencyCallback -> IO Closure
+binDoLatencyClosure cb = newCClosure =<< mkBinDoLatencyCallback wrapped
+    where wrapped = binDoLatencyCallbackWrapper cb
+
+binDoLatencyCallbackWrapper ::
+    BinDoLatencyCallback ->
+    Ptr () ->
+    Ptr () ->
+    IO CInt
+binDoLatencyCallbackWrapper _cb _ _ = do
+    result <- _cb 
+    let result' = (fromIntegral . fromEnum) result
+    return result'
+
+onBinDoLatency :: (GObject a, MonadIO m) => a -> BinDoLatencyCallback -> m SignalHandlerId
+onBinDoLatency obj cb = liftIO $ connectBinDoLatency obj cb SignalConnectBefore
+afterBinDoLatency :: (GObject a, MonadIO m) => a -> BinDoLatencyCallback -> m SignalHandlerId
+afterBinDoLatency obj cb = connectBinDoLatency obj cb SignalConnectAfter
+
+connectBinDoLatency :: (GObject a, MonadIO m) =>
+                       a -> BinDoLatencyCallback -> SignalConnectMode -> m SignalHandlerId
+connectBinDoLatency obj cb after = liftIO $ do
+    cb' <- mkBinDoLatencyCallback (binDoLatencyCallbackWrapper cb)
+    connectSignalFunPtr obj "do-latency" cb' after
+
+-- signal Bin::element-added
+type BinElementAddedCallback =
+    Element ->
+    IO ()
+
+noBinElementAddedCallback :: Maybe BinElementAddedCallback
+noBinElementAddedCallback = Nothing
+
+type BinElementAddedCallbackC =
+    Ptr () ->                               -- object
+    Ptr Element ->
+    Ptr () ->                               -- user_data
+    IO ()
+
+foreign import ccall "wrapper"
+    mkBinElementAddedCallback :: BinElementAddedCallbackC -> IO (FunPtr BinElementAddedCallbackC)
+
+binElementAddedClosure :: BinElementAddedCallback -> IO Closure
+binElementAddedClosure cb = newCClosure =<< mkBinElementAddedCallback wrapped
+    where wrapped = binElementAddedCallbackWrapper cb
+
+binElementAddedCallbackWrapper ::
+    BinElementAddedCallback ->
+    Ptr () ->
+    Ptr Element ->
+    Ptr () ->
+    IO ()
+binElementAddedCallbackWrapper _cb _ element _ = do
+    element' <- (newObject Element) element
+    _cb  element'
+
+onBinElementAdded :: (GObject a, MonadIO m) => a -> BinElementAddedCallback -> m SignalHandlerId
+onBinElementAdded obj cb = liftIO $ connectBinElementAdded obj cb SignalConnectBefore
+afterBinElementAdded :: (GObject a, MonadIO m) => a -> BinElementAddedCallback -> m SignalHandlerId
+afterBinElementAdded obj cb = connectBinElementAdded obj cb SignalConnectAfter
+
+connectBinElementAdded :: (GObject a, MonadIO m) =>
+                          a -> BinElementAddedCallback -> SignalConnectMode -> m SignalHandlerId
+connectBinElementAdded obj cb after = liftIO $ do
+    cb' <- mkBinElementAddedCallback (binElementAddedCallbackWrapper cb)
+    connectSignalFunPtr obj "element-added" cb' after
+
+-- signal Bin::element-removed
+type BinElementRemovedCallback =
+    Element ->
+    IO ()
+
+noBinElementRemovedCallback :: Maybe BinElementRemovedCallback
+noBinElementRemovedCallback = Nothing
+
+type BinElementRemovedCallbackC =
+    Ptr () ->                               -- object
+    Ptr Element ->
+    Ptr () ->                               -- user_data
+    IO ()
+
+foreign import ccall "wrapper"
+    mkBinElementRemovedCallback :: BinElementRemovedCallbackC -> IO (FunPtr BinElementRemovedCallbackC)
+
+binElementRemovedClosure :: BinElementRemovedCallback -> IO Closure
+binElementRemovedClosure cb = newCClosure =<< mkBinElementRemovedCallback wrapped
+    where wrapped = binElementRemovedCallbackWrapper cb
+
+binElementRemovedCallbackWrapper ::
+    BinElementRemovedCallback ->
+    Ptr () ->
+    Ptr Element ->
+    Ptr () ->
+    IO ()
+binElementRemovedCallbackWrapper _cb _ element _ = do
+    element' <- (newObject Element) element
+    _cb  element'
+
+onBinElementRemoved :: (GObject a, MonadIO m) => a -> BinElementRemovedCallback -> m SignalHandlerId
+onBinElementRemoved obj cb = liftIO $ connectBinElementRemoved obj cb SignalConnectBefore
+afterBinElementRemoved :: (GObject a, MonadIO m) => a -> BinElementRemovedCallback -> m SignalHandlerId
+afterBinElementRemoved obj cb = connectBinElementRemoved obj cb SignalConnectAfter
+
+connectBinElementRemoved :: (GObject a, MonadIO m) =>
+                            a -> BinElementRemovedCallback -> SignalConnectMode -> m SignalHandlerId
+connectBinElementRemoved obj cb after = liftIO $ do
+    cb' <- mkBinElementRemovedCallback (binElementRemovedCallbackWrapper cb)
+    connectSignalFunPtr obj "element-removed" cb' after
+
+-- VVV Prop "async-handling"
+   -- Type: TBasicType TBoolean
+   -- Flags: [PropertyReadable,PropertyWritable]
+
+getBinAsyncHandling :: (MonadIO m, BinK o) => o -> m Bool
+getBinAsyncHandling obj = liftIO $ getObjectPropertyBool obj "async-handling"
+
+setBinAsyncHandling :: (MonadIO m, BinK o) => o -> Bool -> m ()
+setBinAsyncHandling obj val = liftIO $ setObjectPropertyBool obj "async-handling" val
+
+constructBinAsyncHandling :: Bool -> IO ([Char], GValue)
+constructBinAsyncHandling val = constructObjectPropertyBool "async-handling" val
+
+data BinAsyncHandlingPropertyInfo
+instance AttrInfo BinAsyncHandlingPropertyInfo where
+    type AttrAllowedOps BinAsyncHandlingPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
+    type AttrSetTypeConstraint BinAsyncHandlingPropertyInfo = (~) Bool
+    type AttrBaseTypeConstraint BinAsyncHandlingPropertyInfo = BinK
+    type AttrGetType BinAsyncHandlingPropertyInfo = Bool
+    type AttrLabel BinAsyncHandlingPropertyInfo = "async-handling"
+    attrGet _ = getBinAsyncHandling
+    attrSet _ = setBinAsyncHandling
+    attrConstruct _ = constructBinAsyncHandling
+
+-- VVV Prop "message-forward"
+   -- Type: TBasicType TBoolean
+   -- Flags: [PropertyReadable,PropertyWritable]
+
+getBinMessageForward :: (MonadIO m, BinK o) => o -> m Bool
+getBinMessageForward obj = liftIO $ getObjectPropertyBool obj "message-forward"
+
+setBinMessageForward :: (MonadIO m, BinK o) => o -> Bool -> m ()
+setBinMessageForward obj val = liftIO $ setObjectPropertyBool obj "message-forward" val
+
+constructBinMessageForward :: Bool -> IO ([Char], GValue)
+constructBinMessageForward val = constructObjectPropertyBool "message-forward" val
+
+data BinMessageForwardPropertyInfo
+instance AttrInfo BinMessageForwardPropertyInfo where
+    type AttrAllowedOps BinMessageForwardPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
+    type AttrSetTypeConstraint BinMessageForwardPropertyInfo = (~) Bool
+    type AttrBaseTypeConstraint BinMessageForwardPropertyInfo = BinK
+    type AttrGetType BinMessageForwardPropertyInfo = Bool
+    type AttrLabel BinMessageForwardPropertyInfo = "message-forward"
+    attrGet _ = getBinMessageForward
+    attrSet _ = setBinMessageForward
+    attrConstruct _ = constructBinMessageForward
+
+type instance AttributeList Bin = BinAttributeList
+type BinAttributeList = ('[ '("asyncHandling", BinAsyncHandlingPropertyInfo), '("messageForward", BinMessageForwardPropertyInfo), '("name", ObjectNamePropertyInfo), '("parent", ObjectParentPropertyInfo)] :: [(Symbol, *)])
+
+data BinDoLatencySignalInfo
+instance SignalInfo BinDoLatencySignalInfo where
+    type HaskellCallbackType BinDoLatencySignalInfo = BinDoLatencyCallback
+    connectSignal _ = connectBinDoLatency
+
+data BinElementAddedSignalInfo
+instance SignalInfo BinElementAddedSignalInfo where
+    type HaskellCallbackType BinElementAddedSignalInfo = BinElementAddedCallback
+    connectSignal _ = connectBinElementAdded
+
+data BinElementRemovedSignalInfo
+instance SignalInfo BinElementRemovedSignalInfo where
+    type HaskellCallbackType BinElementRemovedSignalInfo = BinElementRemovedCallback
+    connectSignal _ = connectBinElementRemoved
+
+type instance SignalList Bin = BinSignalList
+type BinSignalList = ('[ '("childAdded", ChildProxyChildAddedSignalInfo), '("childRemoved", ChildProxyChildRemovedSignalInfo), '("deepNotify", ObjectDeepNotifySignalInfo), '("doLatency", BinDoLatencySignalInfo), '("elementAdded", BinElementAddedSignalInfo), '("elementRemoved", BinElementRemovedSignalInfo), '("noMorePads", ElementNoMorePadsSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("padAdded", ElementPadAddedSignalInfo), '("padRemoved", ElementPadRemovedSignalInfo)] :: [(Symbol, *)])
+
+-- method Bin::new
+-- method type : Constructor
+-- Args : [Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Bin"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_bin_new" gst_bin_new :: 
+    CString ->                              -- name : TBasicType TUTF8
+    IO (Ptr Bin)
+
+
+binNew ::
+    (MonadIO m) =>
+    Maybe (T.Text)                          -- name
+    -> m Bin                                -- result
+binNew name = liftIO $ do
+    maybeName <- case name of
+        Nothing -> return nullPtr
+        Just jName -> do
+            jName' <- textToCString jName
+            return jName'
+    result <- gst_bin_new maybeName
+    checkUnexpectedReturnNULL "gst_bin_new" result
+    result' <- (newObject Bin) result
+    freeMem maybeName
+    return result'
+
+-- method Bin::add
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Bin", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "element", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_bin_add" gst_bin_add :: 
+    Ptr Bin ->                              -- _obj : TInterface "Gst" "Bin"
+    Ptr Element ->                          -- element : TInterface "Gst" "Element"
+    IO CInt
+
+
+binAdd ::
+    (MonadIO m, BinK a, ElementK b) =>
+    a                                       -- _obj
+    -> b                                    -- element
+    -> m Bool                               -- result
+binAdd _obj element = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    element' <- refObject element
+    result <- gst_bin_add _obj' element'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    touchManagedPtr element
+    return result'
+
+data BinAddMethodInfo
+instance (signature ~ (b -> m Bool), MonadIO m, BinK a, ElementK b) => MethodInfo BinAddMethodInfo a signature where
+    overloadedMethod _ = binAdd
+
+-- method Bin::find_unlinked_pad
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Bin", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "direction", argType = TInterface "Gst" "PadDirection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Pad"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_bin_find_unlinked_pad" gst_bin_find_unlinked_pad :: 
+    Ptr Bin ->                              -- _obj : TInterface "Gst" "Bin"
+    CUInt ->                                -- direction : TInterface "Gst" "PadDirection"
+    IO (Ptr Pad)
+
+
+binFindUnlinkedPad ::
+    (MonadIO m, BinK a) =>
+    a                                       -- _obj
+    -> PadDirection                         -- direction
+    -> m Pad                                -- result
+binFindUnlinkedPad _obj direction = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let direction' = (fromIntegral . fromEnum) direction
+    result <- gst_bin_find_unlinked_pad _obj' direction'
+    checkUnexpectedReturnNULL "gst_bin_find_unlinked_pad" result
+    result' <- (wrapObject Pad) result
+    touchManagedPtr _obj
+    return result'
+
+data BinFindUnlinkedPadMethodInfo
+instance (signature ~ (PadDirection -> m Pad), MonadIO m, BinK a) => MethodInfo BinFindUnlinkedPadMethodInfo a signature where
+    overloadedMethod _ = binFindUnlinkedPad
+
+-- method Bin::get_by_interface
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Bin", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "iface", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Element"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_bin_get_by_interface" gst_bin_get_by_interface :: 
+    Ptr Bin ->                              -- _obj : TInterface "Gst" "Bin"
+    CGType ->                               -- iface : TBasicType TGType
+    IO (Ptr Element)
+
+
+binGetByInterface ::
+    (MonadIO m, BinK a) =>
+    a                                       -- _obj
+    -> GType                                -- iface
+    -> m Element                            -- result
+binGetByInterface _obj iface = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let iface' = gtypeToCGType iface
+    result <- gst_bin_get_by_interface _obj' iface'
+    checkUnexpectedReturnNULL "gst_bin_get_by_interface" result
+    result' <- (wrapObject Element) result
+    touchManagedPtr _obj
+    return result'
+
+data BinGetByInterfaceMethodInfo
+instance (signature ~ (GType -> m Element), MonadIO m, BinK a) => MethodInfo BinGetByInterfaceMethodInfo a signature where
+    overloadedMethod _ = binGetByInterface
+
+-- method Bin::get_by_name
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Bin", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Element"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_bin_get_by_name" gst_bin_get_by_name :: 
+    Ptr Bin ->                              -- _obj : TInterface "Gst" "Bin"
+    CString ->                              -- name : TBasicType TUTF8
+    IO (Ptr Element)
+
+
+binGetByName ::
+    (MonadIO m, BinK a) =>
+    a                                       -- _obj
+    -> T.Text                               -- name
+    -> m Element                            -- result
+binGetByName _obj name = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    name' <- textToCString name
+    result <- gst_bin_get_by_name _obj' name'
+    checkUnexpectedReturnNULL "gst_bin_get_by_name" result
+    result' <- (wrapObject Element) result
+    touchManagedPtr _obj
+    freeMem name'
+    return result'
+
+data BinGetByNameMethodInfo
+instance (signature ~ (T.Text -> m Element), MonadIO m, BinK a) => MethodInfo BinGetByNameMethodInfo a signature where
+    overloadedMethod _ = binGetByName
+
+-- method Bin::get_by_name_recurse_up
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Bin", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Element"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_bin_get_by_name_recurse_up" gst_bin_get_by_name_recurse_up :: 
+    Ptr Bin ->                              -- _obj : TInterface "Gst" "Bin"
+    CString ->                              -- name : TBasicType TUTF8
+    IO (Ptr Element)
+
+
+binGetByNameRecurseUp ::
+    (MonadIO m, BinK a) =>
+    a                                       -- _obj
+    -> T.Text                               -- name
+    -> m Element                            -- result
+binGetByNameRecurseUp _obj name = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    name' <- textToCString name
+    result <- gst_bin_get_by_name_recurse_up _obj' name'
+    checkUnexpectedReturnNULL "gst_bin_get_by_name_recurse_up" result
+    result' <- (wrapObject Element) result
+    touchManagedPtr _obj
+    freeMem name'
+    return result'
+
+data BinGetByNameRecurseUpMethodInfo
+instance (signature ~ (T.Text -> m Element), MonadIO m, BinK a) => MethodInfo BinGetByNameRecurseUpMethodInfo a signature where
+    overloadedMethod _ = binGetByNameRecurseUp
+
+-- method Bin::iterate_all_by_interface
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Bin", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "iface", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Iterator"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_bin_iterate_all_by_interface" gst_bin_iterate_all_by_interface :: 
+    Ptr Bin ->                              -- _obj : TInterface "Gst" "Bin"
+    CGType ->                               -- iface : TBasicType TGType
+    IO (Ptr Iterator)
+
+
+binIterateAllByInterface ::
+    (MonadIO m, BinK a) =>
+    a                                       -- _obj
+    -> GType                                -- iface
+    -> m Iterator                           -- result
+binIterateAllByInterface _obj iface = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let iface' = gtypeToCGType iface
+    result <- gst_bin_iterate_all_by_interface _obj' iface'
+    checkUnexpectedReturnNULL "gst_bin_iterate_all_by_interface" result
+    result' <- (wrapBoxed Iterator) result
+    touchManagedPtr _obj
+    return result'
+
+data BinIterateAllByInterfaceMethodInfo
+instance (signature ~ (GType -> m Iterator), MonadIO m, BinK a) => MethodInfo BinIterateAllByInterfaceMethodInfo a signature where
+    overloadedMethod _ = binIterateAllByInterface
+
+-- method Bin::iterate_elements
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Bin", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Iterator"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_bin_iterate_elements" gst_bin_iterate_elements :: 
+    Ptr Bin ->                              -- _obj : TInterface "Gst" "Bin"
+    IO (Ptr Iterator)
+
+
+binIterateElements ::
+    (MonadIO m, BinK a) =>
+    a                                       -- _obj
+    -> m Iterator                           -- result
+binIterateElements _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_bin_iterate_elements _obj'
+    checkUnexpectedReturnNULL "gst_bin_iterate_elements" result
+    result' <- (wrapBoxed Iterator) result
+    touchManagedPtr _obj
+    return result'
+
+data BinIterateElementsMethodInfo
+instance (signature ~ (m Iterator), MonadIO m, BinK a) => MethodInfo BinIterateElementsMethodInfo a signature where
+    overloadedMethod _ = binIterateElements
+
+-- method Bin::iterate_recurse
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Bin", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Iterator"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_bin_iterate_recurse" gst_bin_iterate_recurse :: 
+    Ptr Bin ->                              -- _obj : TInterface "Gst" "Bin"
+    IO (Ptr Iterator)
+
+
+binIterateRecurse ::
+    (MonadIO m, BinK a) =>
+    a                                       -- _obj
+    -> m Iterator                           -- result
+binIterateRecurse _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_bin_iterate_recurse _obj'
+    checkUnexpectedReturnNULL "gst_bin_iterate_recurse" result
+    result' <- (wrapBoxed Iterator) result
+    touchManagedPtr _obj
+    return result'
+
+data BinIterateRecurseMethodInfo
+instance (signature ~ (m Iterator), MonadIO m, BinK a) => MethodInfo BinIterateRecurseMethodInfo a signature where
+    overloadedMethod _ = binIterateRecurse
+
+-- method Bin::iterate_sinks
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Bin", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Iterator"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_bin_iterate_sinks" gst_bin_iterate_sinks :: 
+    Ptr Bin ->                              -- _obj : TInterface "Gst" "Bin"
+    IO (Ptr Iterator)
+
+
+binIterateSinks ::
+    (MonadIO m, BinK a) =>
+    a                                       -- _obj
+    -> m Iterator                           -- result
+binIterateSinks _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_bin_iterate_sinks _obj'
+    checkUnexpectedReturnNULL "gst_bin_iterate_sinks" result
+    result' <- (wrapBoxed Iterator) result
+    touchManagedPtr _obj
+    return result'
+
+data BinIterateSinksMethodInfo
+instance (signature ~ (m Iterator), MonadIO m, BinK a) => MethodInfo BinIterateSinksMethodInfo a signature where
+    overloadedMethod _ = binIterateSinks
+
+-- method Bin::iterate_sorted
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Bin", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Iterator"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_bin_iterate_sorted" gst_bin_iterate_sorted :: 
+    Ptr Bin ->                              -- _obj : TInterface "Gst" "Bin"
+    IO (Ptr Iterator)
+
+
+binIterateSorted ::
+    (MonadIO m, BinK a) =>
+    a                                       -- _obj
+    -> m Iterator                           -- result
+binIterateSorted _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_bin_iterate_sorted _obj'
+    checkUnexpectedReturnNULL "gst_bin_iterate_sorted" result
+    result' <- (wrapBoxed Iterator) result
+    touchManagedPtr _obj
+    return result'
+
+data BinIterateSortedMethodInfo
+instance (signature ~ (m Iterator), MonadIO m, BinK a) => MethodInfo BinIterateSortedMethodInfo a signature where
+    overloadedMethod _ = binIterateSorted
+
+-- method Bin::iterate_sources
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Bin", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Iterator"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_bin_iterate_sources" gst_bin_iterate_sources :: 
+    Ptr Bin ->                              -- _obj : TInterface "Gst" "Bin"
+    IO (Ptr Iterator)
+
+
+binIterateSources ::
+    (MonadIO m, BinK a) =>
+    a                                       -- _obj
+    -> m Iterator                           -- result
+binIterateSources _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_bin_iterate_sources _obj'
+    checkUnexpectedReturnNULL "gst_bin_iterate_sources" result
+    result' <- (wrapBoxed Iterator) result
+    touchManagedPtr _obj
+    return result'
+
+data BinIterateSourcesMethodInfo
+instance (signature ~ (m Iterator), MonadIO m, BinK a) => MethodInfo BinIterateSourcesMethodInfo a signature where
+    overloadedMethod _ = binIterateSources
+
+-- method Bin::recalculate_latency
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Bin", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_bin_recalculate_latency" gst_bin_recalculate_latency :: 
+    Ptr Bin ->                              -- _obj : TInterface "Gst" "Bin"
+    IO CInt
+
+
+binRecalculateLatency ::
+    (MonadIO m, BinK a) =>
+    a                                       -- _obj
+    -> m Bool                               -- result
+binRecalculateLatency _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_bin_recalculate_latency _obj'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data BinRecalculateLatencyMethodInfo
+instance (signature ~ (m Bool), MonadIO m, BinK a) => MethodInfo BinRecalculateLatencyMethodInfo a signature where
+    overloadedMethod _ = binRecalculateLatency
+
+-- method Bin::remove
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Bin", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "element", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_bin_remove" gst_bin_remove :: 
+    Ptr Bin ->                              -- _obj : TInterface "Gst" "Bin"
+    Ptr Element ->                          -- element : TInterface "Gst" "Element"
+    IO CInt
+
+
+binRemove ::
+    (MonadIO m, BinK a, ElementK b) =>
+    a                                       -- _obj
+    -> b                                    -- element
+    -> m Bool                               -- result
+binRemove _obj element = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let element' = unsafeManagedPtrCastPtr element
+    result <- gst_bin_remove _obj' element'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    touchManagedPtr element
+    return result'
+
+data BinRemoveMethodInfo
+instance (signature ~ (b -> m Bool), MonadIO m, BinK a, ElementK b) => MethodInfo BinRemoveMethodInfo a signature where
+    overloadedMethod _ = binRemove
+
+-- method Bin::sync_children_states
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Bin", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_bin_sync_children_states" gst_bin_sync_children_states :: 
+    Ptr Bin ->                              -- _obj : TInterface "Gst" "Bin"
+    IO CInt
+
+
+binSyncChildrenStates ::
+    (MonadIO m, BinK a) =>
+    a                                       -- _obj
+    -> m Bool                               -- result
+binSyncChildrenStates _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_bin_sync_children_states _obj'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data BinSyncChildrenStatesMethodInfo
+instance (signature ~ (m Bool), MonadIO m, BinK a) => MethodInfo BinSyncChildrenStatesMethodInfo a signature where
+    overloadedMethod _ = binSyncChildrenStates
+
+
diff --git a/GI/Gst/Objects/Bin.hs-boot b/GI/Gst/Objects/Bin.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Objects/Bin.hs-boot
@@ -0,0 +1,32 @@
+module GI.Gst.Objects.Bin where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+newtype Bin = Bin (ForeignPtr Bin)
+instance GObject Bin where
+class GObject o => BinK o
+instance (GObject o, IsDescendantOf Bin o) => BinK o
+data BinAsyncHandlingPropertyInfo
+data BinMessageForwardPropertyInfo
+data BinDoLatencySignalInfo
+data BinElementAddedSignalInfo
+data BinElementRemovedSignalInfo
+data BinAddMethodInfo
+data BinFindUnlinkedPadMethodInfo
+data BinGetByInterfaceMethodInfo
+data BinGetByNameMethodInfo
+data BinGetByNameRecurseUpMethodInfo
+data BinIterateAllByInterfaceMethodInfo
+data BinIterateElementsMethodInfo
+data BinIterateRecurseMethodInfo
+data BinIterateSinksMethodInfo
+data BinIterateSortedMethodInfo
+data BinIterateSourcesMethodInfo
+data BinRecalculateLatencyMethodInfo
+data BinRemoveMethodInfo
+data BinSyncChildrenStatesMethodInfo
diff --git a/GI/Gst/Objects/BufferPool.hs b/GI/Gst/Objects/BufferPool.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Objects/BufferPool.hs
@@ -0,0 +1,794 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+-}
+
+module GI.Gst.Objects.BufferPool
+    ( 
+
+-- * Exported types
+    BufferPool(..)                          ,
+    BufferPoolK                             ,
+    toBufferPool                            ,
+    noBufferPool                            ,
+
+
+ -- * Methods
+-- ** bufferPoolAcquireBuffer
+    BufferPoolAcquireBufferMethodInfo       ,
+    bufferPoolAcquireBuffer                 ,
+
+
+-- ** bufferPoolConfigAddOption
+    bufferPoolConfigAddOption               ,
+
+
+-- ** bufferPoolConfigGetAllocator
+    bufferPoolConfigGetAllocator            ,
+
+
+-- ** bufferPoolConfigGetOption
+    bufferPoolConfigGetOption               ,
+
+
+-- ** bufferPoolConfigGetParams
+    bufferPoolConfigGetParams               ,
+
+
+-- ** bufferPoolConfigHasOption
+    bufferPoolConfigHasOption               ,
+
+
+-- ** bufferPoolConfigNOptions
+    bufferPoolConfigNOptions                ,
+
+
+-- ** bufferPoolConfigSetAllocator
+    bufferPoolConfigSetAllocator            ,
+
+
+-- ** bufferPoolConfigSetParams
+    bufferPoolConfigSetParams               ,
+
+
+-- ** bufferPoolConfigValidateParams
+    bufferPoolConfigValidateParams          ,
+
+
+-- ** bufferPoolGetConfig
+    BufferPoolGetConfigMethodInfo           ,
+    bufferPoolGetConfig                     ,
+
+
+-- ** bufferPoolGetOptions
+    BufferPoolGetOptionsMethodInfo          ,
+    bufferPoolGetOptions                    ,
+
+
+-- ** bufferPoolHasOption
+    BufferPoolHasOptionMethodInfo           ,
+    bufferPoolHasOption                     ,
+
+
+-- ** bufferPoolIsActive
+    BufferPoolIsActiveMethodInfo            ,
+    bufferPoolIsActive                      ,
+
+
+-- ** bufferPoolNew
+    bufferPoolNew                           ,
+
+
+-- ** bufferPoolReleaseBuffer
+    BufferPoolReleaseBufferMethodInfo       ,
+    bufferPoolReleaseBuffer                 ,
+
+
+-- ** bufferPoolSetActive
+    BufferPoolSetActiveMethodInfo           ,
+    bufferPoolSetActive                     ,
+
+
+-- ** bufferPoolSetConfig
+    BufferPoolSetConfigMethodInfo           ,
+    bufferPoolSetConfig                     ,
+
+
+-- ** bufferPoolSetFlushing
+    BufferPoolSetFlushingMethodInfo         ,
+    bufferPoolSetFlushing                   ,
+
+
+
+
+    ) where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+import GI.Gst.Callbacks
+import qualified GI.GObject as GObject
+
+newtype BufferPool = BufferPool (ForeignPtr BufferPool)
+foreign import ccall "gst_buffer_pool_get_type"
+    c_gst_buffer_pool_get_type :: IO GType
+
+type instance ParentTypes BufferPool = BufferPoolParentTypes
+type BufferPoolParentTypes = '[Object, GObject.Object]
+
+instance GObject BufferPool where
+    gobjectIsInitiallyUnowned _ = True
+    gobjectType _ = c_gst_buffer_pool_get_type
+    
+
+class GObject o => BufferPoolK o
+instance (GObject o, IsDescendantOf BufferPool o) => BufferPoolK o
+
+toBufferPool :: BufferPoolK o => o -> IO BufferPool
+toBufferPool = unsafeCastTo BufferPool
+
+noBufferPool :: Maybe BufferPool
+noBufferPool = Nothing
+
+type family ResolveBufferPoolMethod (t :: Symbol) (o :: *) :: * where
+    ResolveBufferPoolMethod "acquireBuffer" o = BufferPoolAcquireBufferMethodInfo
+    ResolveBufferPoolMethod "addControlBinding" o = ObjectAddControlBindingMethodInfo
+    ResolveBufferPoolMethod "bindProperty" o = GObject.ObjectBindPropertyMethodInfo
+    ResolveBufferPoolMethod "bindPropertyFull" o = GObject.ObjectBindPropertyFullMethodInfo
+    ResolveBufferPoolMethod "defaultError" o = ObjectDefaultErrorMethodInfo
+    ResolveBufferPoolMethod "forceFloating" o = GObject.ObjectForceFloatingMethodInfo
+    ResolveBufferPoolMethod "freezeNotify" o = GObject.ObjectFreezeNotifyMethodInfo
+    ResolveBufferPoolMethod "hasActiveControlBindings" o = ObjectHasActiveControlBindingsMethodInfo
+    ResolveBufferPoolMethod "hasAncestor" o = ObjectHasAncestorMethodInfo
+    ResolveBufferPoolMethod "hasAsAncestor" o = ObjectHasAsAncestorMethodInfo
+    ResolveBufferPoolMethod "hasAsParent" o = ObjectHasAsParentMethodInfo
+    ResolveBufferPoolMethod "hasOption" o = BufferPoolHasOptionMethodInfo
+    ResolveBufferPoolMethod "isActive" o = BufferPoolIsActiveMethodInfo
+    ResolveBufferPoolMethod "isFloating" o = GObject.ObjectIsFloatingMethodInfo
+    ResolveBufferPoolMethod "notify" o = GObject.ObjectNotifyMethodInfo
+    ResolveBufferPoolMethod "notifyByPspec" o = GObject.ObjectNotifyByPspecMethodInfo
+    ResolveBufferPoolMethod "refSink" o = GObject.ObjectRefSinkMethodInfo
+    ResolveBufferPoolMethod "releaseBuffer" o = BufferPoolReleaseBufferMethodInfo
+    ResolveBufferPoolMethod "removeControlBinding" o = ObjectRemoveControlBindingMethodInfo
+    ResolveBufferPoolMethod "replaceData" o = GObject.ObjectReplaceDataMethodInfo
+    ResolveBufferPoolMethod "replaceQdata" o = GObject.ObjectReplaceQdataMethodInfo
+    ResolveBufferPoolMethod "runDispose" o = GObject.ObjectRunDisposeMethodInfo
+    ResolveBufferPoolMethod "stealData" o = GObject.ObjectStealDataMethodInfo
+    ResolveBufferPoolMethod "stealQdata" o = GObject.ObjectStealQdataMethodInfo
+    ResolveBufferPoolMethod "suggestNextSync" o = ObjectSuggestNextSyncMethodInfo
+    ResolveBufferPoolMethod "syncValues" o = ObjectSyncValuesMethodInfo
+    ResolveBufferPoolMethod "thawNotify" o = GObject.ObjectThawNotifyMethodInfo
+    ResolveBufferPoolMethod "unparent" o = ObjectUnparentMethodInfo
+    ResolveBufferPoolMethod "watchClosure" o = GObject.ObjectWatchClosureMethodInfo
+    ResolveBufferPoolMethod "getConfig" o = BufferPoolGetConfigMethodInfo
+    ResolveBufferPoolMethod "getControlBinding" o = ObjectGetControlBindingMethodInfo
+    ResolveBufferPoolMethod "getControlRate" o = ObjectGetControlRateMethodInfo
+    ResolveBufferPoolMethod "getData" o = GObject.ObjectGetDataMethodInfo
+    ResolveBufferPoolMethod "getGValueArray" o = ObjectGetGValueArrayMethodInfo
+    ResolveBufferPoolMethod "getName" o = ObjectGetNameMethodInfo
+    ResolveBufferPoolMethod "getOptions" o = BufferPoolGetOptionsMethodInfo
+    ResolveBufferPoolMethod "getParent" o = ObjectGetParentMethodInfo
+    ResolveBufferPoolMethod "getPathString" o = ObjectGetPathStringMethodInfo
+    ResolveBufferPoolMethod "getProperty" o = GObject.ObjectGetPropertyMethodInfo
+    ResolveBufferPoolMethod "getQdata" o = GObject.ObjectGetQdataMethodInfo
+    ResolveBufferPoolMethod "getValue" o = ObjectGetValueMethodInfo
+    ResolveBufferPoolMethod "getValueArray" o = ObjectGetValueArrayMethodInfo
+    ResolveBufferPoolMethod "setActive" o = BufferPoolSetActiveMethodInfo
+    ResolveBufferPoolMethod "setConfig" o = BufferPoolSetConfigMethodInfo
+    ResolveBufferPoolMethod "setControlBindingDisabled" o = ObjectSetControlBindingDisabledMethodInfo
+    ResolveBufferPoolMethod "setControlBindingsDisabled" o = ObjectSetControlBindingsDisabledMethodInfo
+    ResolveBufferPoolMethod "setControlRate" o = ObjectSetControlRateMethodInfo
+    ResolveBufferPoolMethod "setData" o = GObject.ObjectSetDataMethodInfo
+    ResolveBufferPoolMethod "setFlushing" o = BufferPoolSetFlushingMethodInfo
+    ResolveBufferPoolMethod "setName" o = ObjectSetNameMethodInfo
+    ResolveBufferPoolMethod "setParent" o = ObjectSetParentMethodInfo
+    ResolveBufferPoolMethod "setProperty" o = GObject.ObjectSetPropertyMethodInfo
+    ResolveBufferPoolMethod l o = MethodResolutionFailed l o
+
+instance (info ~ ResolveBufferPoolMethod t BufferPool, MethodInfo info BufferPool p) => IsLabelProxy t (BufferPool -> p) where
+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)
+
+#if MIN_VERSION_base(4,9,0)
+instance (info ~ ResolveBufferPoolMethod t BufferPool, MethodInfo info BufferPool p) => IsLabel t (BufferPool -> p) where
+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)
+#endif
+
+type instance AttributeList BufferPool = BufferPoolAttributeList
+type BufferPoolAttributeList = ('[ '("name", ObjectNamePropertyInfo), '("parent", ObjectParentPropertyInfo)] :: [(Symbol, *)])
+
+type instance SignalList BufferPool = BufferPoolSignalList
+type BufferPoolSignalList = ('[ '("deepNotify", ObjectDeepNotifySignalInfo), '("notify", GObject.ObjectNotifySignalInfo)] :: [(Symbol, *)])
+
+-- method BufferPool::new
+-- method type : Constructor
+-- Args : []
+-- Lengths : []
+-- returnType : TInterface "Gst" "BufferPool"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_buffer_pool_new" gst_buffer_pool_new :: 
+    IO (Ptr BufferPool)
+
+
+bufferPoolNew ::
+    (MonadIO m) =>
+    m BufferPool                            -- result
+bufferPoolNew  = liftIO $ do
+    result <- gst_buffer_pool_new
+    checkUnexpectedReturnNULL "gst_buffer_pool_new" result
+    result' <- (newObject BufferPool) result
+    return result'
+
+-- method BufferPool::acquire_buffer
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "BufferPool", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "buffer", argType = TInterface "Gst" "Buffer", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "params", argType = TInterface "Gst" "BufferPoolAcquireParams", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "FlowReturn"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_buffer_pool_acquire_buffer" gst_buffer_pool_acquire_buffer :: 
+    Ptr BufferPool ->                       -- _obj : TInterface "Gst" "BufferPool"
+    Ptr Buffer ->                           -- buffer : TInterface "Gst" "Buffer"
+    Ptr BufferPoolAcquireParams ->          -- params : TInterface "Gst" "BufferPoolAcquireParams"
+    IO CUInt
+
+
+bufferPoolAcquireBuffer ::
+    (MonadIO m, BufferPoolK a) =>
+    a                                       -- _obj
+    -> Maybe (BufferPoolAcquireParams)      -- params
+    -> m (FlowReturn,Buffer)                -- result
+bufferPoolAcquireBuffer _obj params = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    buffer <- callocBoxedBytes 112 :: IO (Ptr Buffer)
+    maybeParams <- case params of
+        Nothing -> return nullPtr
+        Just jParams -> do
+            let jParams' = unsafeManagedPtrGetPtr jParams
+            return jParams'
+    result <- gst_buffer_pool_acquire_buffer _obj' buffer maybeParams
+    let result' = (toEnum . fromIntegral) result
+    buffer' <- (wrapBoxed Buffer) buffer
+    touchManagedPtr _obj
+    whenJust params touchManagedPtr
+    return (result', buffer')
+
+data BufferPoolAcquireBufferMethodInfo
+instance (signature ~ (Maybe (BufferPoolAcquireParams) -> m (FlowReturn,Buffer)), MonadIO m, BufferPoolK a) => MethodInfo BufferPoolAcquireBufferMethodInfo a signature where
+    overloadedMethod _ = bufferPoolAcquireBuffer
+
+-- method BufferPool::get_config
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "BufferPool", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Structure"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_buffer_pool_get_config" gst_buffer_pool_get_config :: 
+    Ptr BufferPool ->                       -- _obj : TInterface "Gst" "BufferPool"
+    IO (Ptr Structure)
+
+
+bufferPoolGetConfig ::
+    (MonadIO m, BufferPoolK a) =>
+    a                                       -- _obj
+    -> m Structure                          -- result
+bufferPoolGetConfig _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_buffer_pool_get_config _obj'
+    checkUnexpectedReturnNULL "gst_buffer_pool_get_config" result
+    result' <- (wrapBoxed Structure) result
+    touchManagedPtr _obj
+    return result'
+
+data BufferPoolGetConfigMethodInfo
+instance (signature ~ (m Structure), MonadIO m, BufferPoolK a) => MethodInfo BufferPoolGetConfigMethodInfo a signature where
+    overloadedMethod _ = bufferPoolGetConfig
+
+-- method BufferPool::get_options
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "BufferPool", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TCArray True (-1) (-1) (TBasicType TUTF8)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_buffer_pool_get_options" gst_buffer_pool_get_options :: 
+    Ptr BufferPool ->                       -- _obj : TInterface "Gst" "BufferPool"
+    IO (Ptr CString)
+
+
+bufferPoolGetOptions ::
+    (MonadIO m, BufferPoolK a) =>
+    a                                       -- _obj
+    -> m [T.Text]                           -- result
+bufferPoolGetOptions _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_buffer_pool_get_options _obj'
+    checkUnexpectedReturnNULL "gst_buffer_pool_get_options" result
+    result' <- unpackZeroTerminatedUTF8CArray result
+    touchManagedPtr _obj
+    return result'
+
+data BufferPoolGetOptionsMethodInfo
+instance (signature ~ (m [T.Text]), MonadIO m, BufferPoolK a) => MethodInfo BufferPoolGetOptionsMethodInfo a signature where
+    overloadedMethod _ = bufferPoolGetOptions
+
+-- method BufferPool::has_option
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "BufferPool", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "option", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_buffer_pool_has_option" gst_buffer_pool_has_option :: 
+    Ptr BufferPool ->                       -- _obj : TInterface "Gst" "BufferPool"
+    CString ->                              -- option : TBasicType TUTF8
+    IO CInt
+
+
+bufferPoolHasOption ::
+    (MonadIO m, BufferPoolK a) =>
+    a                                       -- _obj
+    -> T.Text                               -- option
+    -> m Bool                               -- result
+bufferPoolHasOption _obj option = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    option' <- textToCString option
+    result <- gst_buffer_pool_has_option _obj' option'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    freeMem option'
+    return result'
+
+data BufferPoolHasOptionMethodInfo
+instance (signature ~ (T.Text -> m Bool), MonadIO m, BufferPoolK a) => MethodInfo BufferPoolHasOptionMethodInfo a signature where
+    overloadedMethod _ = bufferPoolHasOption
+
+-- method BufferPool::is_active
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "BufferPool", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_buffer_pool_is_active" gst_buffer_pool_is_active :: 
+    Ptr BufferPool ->                       -- _obj : TInterface "Gst" "BufferPool"
+    IO CInt
+
+
+bufferPoolIsActive ::
+    (MonadIO m, BufferPoolK a) =>
+    a                                       -- _obj
+    -> m Bool                               -- result
+bufferPoolIsActive _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_buffer_pool_is_active _obj'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data BufferPoolIsActiveMethodInfo
+instance (signature ~ (m Bool), MonadIO m, BufferPoolK a) => MethodInfo BufferPoolIsActiveMethodInfo a signature where
+    overloadedMethod _ = bufferPoolIsActive
+
+-- method BufferPool::release_buffer
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "BufferPool", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "buffer", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_buffer_pool_release_buffer" gst_buffer_pool_release_buffer :: 
+    Ptr BufferPool ->                       -- _obj : TInterface "Gst" "BufferPool"
+    Ptr Buffer ->                           -- buffer : TInterface "Gst" "Buffer"
+    IO ()
+
+
+bufferPoolReleaseBuffer ::
+    (MonadIO m, BufferPoolK a) =>
+    a                                       -- _obj
+    -> Buffer                               -- buffer
+    -> m ()                                 -- result
+bufferPoolReleaseBuffer _obj buffer = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    buffer' <- copyBoxed buffer
+    gst_buffer_pool_release_buffer _obj' buffer'
+    touchManagedPtr _obj
+    touchManagedPtr buffer
+    return ()
+
+data BufferPoolReleaseBufferMethodInfo
+instance (signature ~ (Buffer -> m ()), MonadIO m, BufferPoolK a) => MethodInfo BufferPoolReleaseBufferMethodInfo a signature where
+    overloadedMethod _ = bufferPoolReleaseBuffer
+
+-- method BufferPool::set_active
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "BufferPool", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "active", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_buffer_pool_set_active" gst_buffer_pool_set_active :: 
+    Ptr BufferPool ->                       -- _obj : TInterface "Gst" "BufferPool"
+    CInt ->                                 -- active : TBasicType TBoolean
+    IO CInt
+
+
+bufferPoolSetActive ::
+    (MonadIO m, BufferPoolK a) =>
+    a                                       -- _obj
+    -> Bool                                 -- active
+    -> m Bool                               -- result
+bufferPoolSetActive _obj active = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let active' = (fromIntegral . fromEnum) active
+    result <- gst_buffer_pool_set_active _obj' active'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data BufferPoolSetActiveMethodInfo
+instance (signature ~ (Bool -> m Bool), MonadIO m, BufferPoolK a) => MethodInfo BufferPoolSetActiveMethodInfo a signature where
+    overloadedMethod _ = bufferPoolSetActive
+
+-- method BufferPool::set_config
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "BufferPool", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "config", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_buffer_pool_set_config" gst_buffer_pool_set_config :: 
+    Ptr BufferPool ->                       -- _obj : TInterface "Gst" "BufferPool"
+    Ptr Structure ->                        -- config : TInterface "Gst" "Structure"
+    IO CInt
+
+
+bufferPoolSetConfig ::
+    (MonadIO m, BufferPoolK a) =>
+    a                                       -- _obj
+    -> Structure                            -- config
+    -> m Bool                               -- result
+bufferPoolSetConfig _obj config = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    config' <- copyBoxed config
+    result <- gst_buffer_pool_set_config _obj' config'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    touchManagedPtr config
+    return result'
+
+data BufferPoolSetConfigMethodInfo
+instance (signature ~ (Structure -> m Bool), MonadIO m, BufferPoolK a) => MethodInfo BufferPoolSetConfigMethodInfo a signature where
+    overloadedMethod _ = bufferPoolSetConfig
+
+-- method BufferPool::set_flushing
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "BufferPool", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flushing", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_buffer_pool_set_flushing" gst_buffer_pool_set_flushing :: 
+    Ptr BufferPool ->                       -- _obj : TInterface "Gst" "BufferPool"
+    CInt ->                                 -- flushing : TBasicType TBoolean
+    IO ()
+
+
+bufferPoolSetFlushing ::
+    (MonadIO m, BufferPoolK a) =>
+    a                                       -- _obj
+    -> Bool                                 -- flushing
+    -> m ()                                 -- result
+bufferPoolSetFlushing _obj flushing = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let flushing' = (fromIntegral . fromEnum) flushing
+    gst_buffer_pool_set_flushing _obj' flushing'
+    touchManagedPtr _obj
+    return ()
+
+data BufferPoolSetFlushingMethodInfo
+instance (signature ~ (Bool -> m ()), MonadIO m, BufferPoolK a) => MethodInfo BufferPoolSetFlushingMethodInfo a signature where
+    overloadedMethod _ = bufferPoolSetFlushing
+
+-- method BufferPool::config_add_option
+-- method type : MemberFunction
+-- Args : [Arg {argCName = "config", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "option", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_buffer_pool_config_add_option" gst_buffer_pool_config_add_option :: 
+    Ptr Structure ->                        -- config : TInterface "Gst" "Structure"
+    CString ->                              -- option : TBasicType TUTF8
+    IO ()
+
+
+bufferPoolConfigAddOption ::
+    (MonadIO m) =>
+    Structure                               -- config
+    -> T.Text                               -- option
+    -> m ()                                 -- result
+bufferPoolConfigAddOption config option = liftIO $ do
+    let config' = unsafeManagedPtrGetPtr config
+    option' <- textToCString option
+    gst_buffer_pool_config_add_option config' option'
+    touchManagedPtr config
+    freeMem option'
+    return ()
+
+-- method BufferPool::config_get_allocator
+-- method type : MemberFunction
+-- Args : [Arg {argCName = "config", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "allocator", argType = TInterface "Gst" "Allocator", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "params", argType = TInterface "Gst" "AllocationParams", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_buffer_pool_config_get_allocator" gst_buffer_pool_config_get_allocator :: 
+    Ptr Structure ->                        -- config : TInterface "Gst" "Structure"
+    Ptr (Ptr Allocator) ->                  -- allocator : TInterface "Gst" "Allocator"
+    Ptr AllocationParams ->                 -- params : TInterface "Gst" "AllocationParams"
+    IO CInt
+
+
+bufferPoolConfigGetAllocator ::
+    (MonadIO m) =>
+    Structure                               -- config
+    -> m (Bool,Allocator,AllocationParams)  -- result
+bufferPoolConfigGetAllocator config = liftIO $ do
+    let config' = unsafeManagedPtrGetPtr config
+    allocator <- allocMem :: IO (Ptr (Ptr Allocator))
+    params <- callocBoxedBytes 64 :: IO (Ptr AllocationParams)
+    result <- gst_buffer_pool_config_get_allocator config' allocator params
+    let result' = (/= 0) result
+    allocator' <- peek allocator
+    allocator'' <- (newObject Allocator) allocator'
+    params' <- (wrapBoxed AllocationParams) params
+    touchManagedPtr config
+    freeMem allocator
+    return (result', allocator'', params')
+
+-- method BufferPool::config_get_option
+-- method type : MemberFunction
+-- Args : [Arg {argCName = "config", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUTF8
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_buffer_pool_config_get_option" gst_buffer_pool_config_get_option :: 
+    Ptr Structure ->                        -- config : TInterface "Gst" "Structure"
+    Word32 ->                               -- index : TBasicType TUInt32
+    IO CString
+
+
+bufferPoolConfigGetOption ::
+    (MonadIO m) =>
+    Structure                               -- config
+    -> Word32                               -- index
+    -> m T.Text                             -- result
+bufferPoolConfigGetOption config index = liftIO $ do
+    let config' = unsafeManagedPtrGetPtr config
+    result <- gst_buffer_pool_config_get_option config' index
+    checkUnexpectedReturnNULL "gst_buffer_pool_config_get_option" result
+    result' <- cstringToText result
+    touchManagedPtr config
+    return result'
+
+-- method BufferPool::config_get_params
+-- method type : MemberFunction
+-- Args : [Arg {argCName = "config", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps", argType = TInterface "Gst" "Caps", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "min_buffers", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "max_buffers", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_buffer_pool_config_get_params" gst_buffer_pool_config_get_params :: 
+    Ptr Structure ->                        -- config : TInterface "Gst" "Structure"
+    Ptr Caps ->                             -- caps : TInterface "Gst" "Caps"
+    Ptr Word32 ->                           -- size : TBasicType TUInt32
+    Ptr Word32 ->                           -- min_buffers : TBasicType TUInt32
+    Ptr Word32 ->                           -- max_buffers : TBasicType TUInt32
+    IO CInt
+
+
+bufferPoolConfigGetParams ::
+    (MonadIO m) =>
+    Structure                               -- config
+    -> m (Bool,Caps,Word32,Word32,Word32)   -- result
+bufferPoolConfigGetParams config = liftIO $ do
+    let config' = unsafeManagedPtrGetPtr config
+    caps <- callocBoxedBytes 64 :: IO (Ptr Caps)
+    size <- allocMem :: IO (Ptr Word32)
+    minBuffers <- allocMem :: IO (Ptr Word32)
+    maxBuffers <- allocMem :: IO (Ptr Word32)
+    result <- gst_buffer_pool_config_get_params config' caps size minBuffers maxBuffers
+    let result' = (/= 0) result
+    caps' <- (wrapBoxed Caps) caps
+    size' <- peek size
+    minBuffers' <- peek minBuffers
+    maxBuffers' <- peek maxBuffers
+    touchManagedPtr config
+    freeMem size
+    freeMem minBuffers
+    freeMem maxBuffers
+    return (result', caps', size', minBuffers', maxBuffers')
+
+-- method BufferPool::config_has_option
+-- method type : MemberFunction
+-- Args : [Arg {argCName = "config", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "option", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_buffer_pool_config_has_option" gst_buffer_pool_config_has_option :: 
+    Ptr Structure ->                        -- config : TInterface "Gst" "Structure"
+    CString ->                              -- option : TBasicType TUTF8
+    IO CInt
+
+
+bufferPoolConfigHasOption ::
+    (MonadIO m) =>
+    Structure                               -- config
+    -> T.Text                               -- option
+    -> m Bool                               -- result
+bufferPoolConfigHasOption config option = liftIO $ do
+    let config' = unsafeManagedPtrGetPtr config
+    option' <- textToCString option
+    result <- gst_buffer_pool_config_has_option config' option'
+    let result' = (/= 0) result
+    touchManagedPtr config
+    freeMem option'
+    return result'
+
+-- method BufferPool::config_n_options
+-- method type : MemberFunction
+-- Args : [Arg {argCName = "config", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUInt32
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_buffer_pool_config_n_options" gst_buffer_pool_config_n_options :: 
+    Ptr Structure ->                        -- config : TInterface "Gst" "Structure"
+    IO Word32
+
+
+bufferPoolConfigNOptions ::
+    (MonadIO m) =>
+    Structure                               -- config
+    -> m Word32                             -- result
+bufferPoolConfigNOptions config = liftIO $ do
+    let config' = unsafeManagedPtrGetPtr config
+    result <- gst_buffer_pool_config_n_options config'
+    touchManagedPtr config
+    return result
+
+-- method BufferPool::config_set_allocator
+-- method type : MemberFunction
+-- Args : [Arg {argCName = "config", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "allocator", argType = TInterface "Gst" "Allocator", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "params", argType = TInterface "Gst" "AllocationParams", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_buffer_pool_config_set_allocator" gst_buffer_pool_config_set_allocator :: 
+    Ptr Structure ->                        -- config : TInterface "Gst" "Structure"
+    Ptr Allocator ->                        -- allocator : TInterface "Gst" "Allocator"
+    Ptr AllocationParams ->                 -- params : TInterface "Gst" "AllocationParams"
+    IO ()
+
+
+bufferPoolConfigSetAllocator ::
+    (MonadIO m, AllocatorK a) =>
+    Structure                               -- config
+    -> Maybe (a)                            -- allocator
+    -> Maybe (AllocationParams)             -- params
+    -> m ()                                 -- result
+bufferPoolConfigSetAllocator config allocator params = liftIO $ do
+    let config' = unsafeManagedPtrGetPtr config
+    maybeAllocator <- case allocator of
+        Nothing -> return nullPtr
+        Just jAllocator -> do
+            let jAllocator' = unsafeManagedPtrCastPtr jAllocator
+            return jAllocator'
+    maybeParams <- case params of
+        Nothing -> return nullPtr
+        Just jParams -> do
+            let jParams' = unsafeManagedPtrGetPtr jParams
+            return jParams'
+    gst_buffer_pool_config_set_allocator config' maybeAllocator maybeParams
+    touchManagedPtr config
+    whenJust allocator touchManagedPtr
+    whenJust params touchManagedPtr
+    return ()
+
+-- method BufferPool::config_set_params
+-- method type : MemberFunction
+-- Args : [Arg {argCName = "config", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "min_buffers", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "max_buffers", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_buffer_pool_config_set_params" gst_buffer_pool_config_set_params :: 
+    Ptr Structure ->                        -- config : TInterface "Gst" "Structure"
+    Ptr Caps ->                             -- caps : TInterface "Gst" "Caps"
+    Word32 ->                               -- size : TBasicType TUInt32
+    Word32 ->                               -- min_buffers : TBasicType TUInt32
+    Word32 ->                               -- max_buffers : TBasicType TUInt32
+    IO ()
+
+
+bufferPoolConfigSetParams ::
+    (MonadIO m) =>
+    Structure                               -- config
+    -> Caps                                 -- caps
+    -> Word32                               -- size
+    -> Word32                               -- minBuffers
+    -> Word32                               -- maxBuffers
+    -> m ()                                 -- result
+bufferPoolConfigSetParams config caps size minBuffers maxBuffers = liftIO $ do
+    let config' = unsafeManagedPtrGetPtr config
+    let caps' = unsafeManagedPtrGetPtr caps
+    gst_buffer_pool_config_set_params config' caps' size minBuffers maxBuffers
+    touchManagedPtr config
+    touchManagedPtr caps
+    return ()
+
+-- method BufferPool::config_validate_params
+-- method type : MemberFunction
+-- Args : [Arg {argCName = "config", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "min_buffers", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "max_buffers", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_buffer_pool_config_validate_params" gst_buffer_pool_config_validate_params :: 
+    Ptr Structure ->                        -- config : TInterface "Gst" "Structure"
+    Ptr Caps ->                             -- caps : TInterface "Gst" "Caps"
+    Word32 ->                               -- size : TBasicType TUInt32
+    Word32 ->                               -- min_buffers : TBasicType TUInt32
+    Word32 ->                               -- max_buffers : TBasicType TUInt32
+    IO CInt
+
+
+bufferPoolConfigValidateParams ::
+    (MonadIO m) =>
+    Structure                               -- config
+    -> Caps                                 -- caps
+    -> Word32                               -- size
+    -> Word32                               -- minBuffers
+    -> Word32                               -- maxBuffers
+    -> m Bool                               -- result
+bufferPoolConfigValidateParams config caps size minBuffers maxBuffers = liftIO $ do
+    let config' = unsafeManagedPtrGetPtr config
+    let caps' = unsafeManagedPtrGetPtr caps
+    result <- gst_buffer_pool_config_validate_params config' caps' size minBuffers maxBuffers
+    let result' = (/= 0) result
+    touchManagedPtr config
+    touchManagedPtr caps
+    return result'
+
+
diff --git a/GI/Gst/Objects/BufferPool.hs-boot b/GI/Gst/Objects/BufferPool.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Objects/BufferPool.hs-boot
@@ -0,0 +1,22 @@
+module GI.Gst.Objects.BufferPool where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+newtype BufferPool = BufferPool (ForeignPtr BufferPool)
+instance GObject BufferPool where
+class GObject o => BufferPoolK o
+instance (GObject o, IsDescendantOf BufferPool o) => BufferPoolK o
+data BufferPoolAcquireBufferMethodInfo
+data BufferPoolGetConfigMethodInfo
+data BufferPoolGetOptionsMethodInfo
+data BufferPoolHasOptionMethodInfo
+data BufferPoolIsActiveMethodInfo
+data BufferPoolReleaseBufferMethodInfo
+data BufferPoolSetActiveMethodInfo
+data BufferPoolSetConfigMethodInfo
+data BufferPoolSetFlushingMethodInfo
diff --git a/GI/Gst/Objects/Bus.hs b/GI/Gst/Objects/Bus.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Objects/Bus.hs
@@ -0,0 +1,1024 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+-}
+
+module GI.Gst.Objects.Bus
+    ( 
+
+-- * Exported types
+    Bus(..)                                 ,
+    BusK                                    ,
+    toBus                                   ,
+    noBus                                   ,
+
+
+ -- * Methods
+-- ** busAddSignalWatch
+    BusAddSignalWatchMethodInfo             ,
+    busAddSignalWatch                       ,
+
+
+-- ** busAddSignalWatchFull
+    BusAddSignalWatchFullMethodInfo         ,
+    busAddSignalWatchFull                   ,
+
+
+-- ** busAddWatch
+    BusAddWatchMethodInfo                   ,
+    busAddWatch                             ,
+
+
+-- ** busAsyncSignalFunc
+    BusAsyncSignalFuncMethodInfo            ,
+    busAsyncSignalFunc                      ,
+
+
+-- ** busCreateWatch
+    BusCreateWatchMethodInfo                ,
+    busCreateWatch                          ,
+
+
+-- ** busDisableSyncMessageEmission
+    BusDisableSyncMessageEmissionMethodInfo ,
+    busDisableSyncMessageEmission           ,
+
+
+-- ** busEnableSyncMessageEmission
+    BusEnableSyncMessageEmissionMethodInfo  ,
+    busEnableSyncMessageEmission            ,
+
+
+-- ** busHavePending
+    BusHavePendingMethodInfo                ,
+    busHavePending                          ,
+
+
+-- ** busNew
+    busNew                                  ,
+
+
+-- ** busPeek
+    BusPeekMethodInfo                       ,
+    busPeek                                 ,
+
+
+-- ** busPoll
+    BusPollMethodInfo                       ,
+    busPoll                                 ,
+
+
+-- ** busPop
+    BusPopMethodInfo                        ,
+    busPop                                  ,
+
+
+-- ** busPopFiltered
+    BusPopFilteredMethodInfo                ,
+    busPopFiltered                          ,
+
+
+-- ** busPost
+    BusPostMethodInfo                       ,
+    busPost                                 ,
+
+
+-- ** busRemoveSignalWatch
+    BusRemoveSignalWatchMethodInfo          ,
+    busRemoveSignalWatch                    ,
+
+
+-- ** busRemoveWatch
+    BusRemoveWatchMethodInfo                ,
+    busRemoveWatch                          ,
+
+
+-- ** busSetFlushing
+    BusSetFlushingMethodInfo                ,
+    busSetFlushing                          ,
+
+
+-- ** busSetSyncHandler
+    BusSetSyncHandlerMethodInfo             ,
+    busSetSyncHandler                       ,
+
+
+-- ** busSyncSignalHandler
+    BusSyncSignalHandlerMethodInfo          ,
+    busSyncSignalHandler                    ,
+
+
+-- ** busTimedPop
+    BusTimedPopMethodInfo                   ,
+    busTimedPop                             ,
+
+
+-- ** busTimedPopFiltered
+    BusTimedPopFilteredMethodInfo           ,
+    busTimedPopFiltered                     ,
+
+
+
+
+ -- * Properties
+-- ** EnableAsync
+    BusEnableAsyncPropertyInfo              ,
+    constructBusEnableAsync                 ,
+
+
+
+
+ -- * Signals
+-- ** Message
+    BusMessageCallback                      ,
+    BusMessageCallbackC                     ,
+    BusMessageSignalInfo                    ,
+    afterBusMessage                         ,
+    busMessageCallbackWrapper               ,
+    busMessageClosure                       ,
+    mkBusMessageCallback                    ,
+    noBusMessageCallback                    ,
+    onBusMessage                            ,
+
+
+-- ** SyncMessage
+    BusSyncMessageCallback                  ,
+    BusSyncMessageCallbackC                 ,
+    BusSyncMessageSignalInfo                ,
+    afterBusSyncMessage                     ,
+    busSyncMessageCallbackWrapper           ,
+    busSyncMessageClosure                   ,
+    mkBusSyncMessageCallback                ,
+    noBusSyncMessageCallback                ,
+    onBusSyncMessage                        ,
+
+
+
+
+    ) where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+import GI.Gst.Callbacks
+import qualified GI.GLib as GLib
+import qualified GI.GObject as GObject
+
+newtype Bus = Bus (ForeignPtr Bus)
+foreign import ccall "gst_bus_get_type"
+    c_gst_bus_get_type :: IO GType
+
+type instance ParentTypes Bus = BusParentTypes
+type BusParentTypes = '[Object, GObject.Object]
+
+instance GObject Bus where
+    gobjectIsInitiallyUnowned _ = True
+    gobjectType _ = c_gst_bus_get_type
+    
+
+class GObject o => BusK o
+instance (GObject o, IsDescendantOf Bus o) => BusK o
+
+toBus :: BusK o => o -> IO Bus
+toBus = unsafeCastTo Bus
+
+noBus :: Maybe Bus
+noBus = Nothing
+
+type family ResolveBusMethod (t :: Symbol) (o :: *) :: * where
+    ResolveBusMethod "addControlBinding" o = ObjectAddControlBindingMethodInfo
+    ResolveBusMethod "addSignalWatch" o = BusAddSignalWatchMethodInfo
+    ResolveBusMethod "addSignalWatchFull" o = BusAddSignalWatchFullMethodInfo
+    ResolveBusMethod "addWatch" o = BusAddWatchMethodInfo
+    ResolveBusMethod "asyncSignalFunc" o = BusAsyncSignalFuncMethodInfo
+    ResolveBusMethod "bindProperty" o = GObject.ObjectBindPropertyMethodInfo
+    ResolveBusMethod "bindPropertyFull" o = GObject.ObjectBindPropertyFullMethodInfo
+    ResolveBusMethod "createWatch" o = BusCreateWatchMethodInfo
+    ResolveBusMethod "defaultError" o = ObjectDefaultErrorMethodInfo
+    ResolveBusMethod "disableSyncMessageEmission" o = BusDisableSyncMessageEmissionMethodInfo
+    ResolveBusMethod "enableSyncMessageEmission" o = BusEnableSyncMessageEmissionMethodInfo
+    ResolveBusMethod "forceFloating" o = GObject.ObjectForceFloatingMethodInfo
+    ResolveBusMethod "freezeNotify" o = GObject.ObjectFreezeNotifyMethodInfo
+    ResolveBusMethod "hasActiveControlBindings" o = ObjectHasActiveControlBindingsMethodInfo
+    ResolveBusMethod "hasAncestor" o = ObjectHasAncestorMethodInfo
+    ResolveBusMethod "hasAsAncestor" o = ObjectHasAsAncestorMethodInfo
+    ResolveBusMethod "hasAsParent" o = ObjectHasAsParentMethodInfo
+    ResolveBusMethod "havePending" o = BusHavePendingMethodInfo
+    ResolveBusMethod "isFloating" o = GObject.ObjectIsFloatingMethodInfo
+    ResolveBusMethod "notify" o = GObject.ObjectNotifyMethodInfo
+    ResolveBusMethod "notifyByPspec" o = GObject.ObjectNotifyByPspecMethodInfo
+    ResolveBusMethod "peek" o = BusPeekMethodInfo
+    ResolveBusMethod "poll" o = BusPollMethodInfo
+    ResolveBusMethod "pop" o = BusPopMethodInfo
+    ResolveBusMethod "popFiltered" o = BusPopFilteredMethodInfo
+    ResolveBusMethod "post" o = BusPostMethodInfo
+    ResolveBusMethod "refSink" o = GObject.ObjectRefSinkMethodInfo
+    ResolveBusMethod "removeControlBinding" o = ObjectRemoveControlBindingMethodInfo
+    ResolveBusMethod "removeSignalWatch" o = BusRemoveSignalWatchMethodInfo
+    ResolveBusMethod "removeWatch" o = BusRemoveWatchMethodInfo
+    ResolveBusMethod "replaceData" o = GObject.ObjectReplaceDataMethodInfo
+    ResolveBusMethod "replaceQdata" o = GObject.ObjectReplaceQdataMethodInfo
+    ResolveBusMethod "runDispose" o = GObject.ObjectRunDisposeMethodInfo
+    ResolveBusMethod "stealData" o = GObject.ObjectStealDataMethodInfo
+    ResolveBusMethod "stealQdata" o = GObject.ObjectStealQdataMethodInfo
+    ResolveBusMethod "suggestNextSync" o = ObjectSuggestNextSyncMethodInfo
+    ResolveBusMethod "syncSignalHandler" o = BusSyncSignalHandlerMethodInfo
+    ResolveBusMethod "syncValues" o = ObjectSyncValuesMethodInfo
+    ResolveBusMethod "thawNotify" o = GObject.ObjectThawNotifyMethodInfo
+    ResolveBusMethod "timedPop" o = BusTimedPopMethodInfo
+    ResolveBusMethod "timedPopFiltered" o = BusTimedPopFilteredMethodInfo
+    ResolveBusMethod "unparent" o = ObjectUnparentMethodInfo
+    ResolveBusMethod "watchClosure" o = GObject.ObjectWatchClosureMethodInfo
+    ResolveBusMethod "getControlBinding" o = ObjectGetControlBindingMethodInfo
+    ResolveBusMethod "getControlRate" o = ObjectGetControlRateMethodInfo
+    ResolveBusMethod "getData" o = GObject.ObjectGetDataMethodInfo
+    ResolveBusMethod "getGValueArray" o = ObjectGetGValueArrayMethodInfo
+    ResolveBusMethod "getName" o = ObjectGetNameMethodInfo
+    ResolveBusMethod "getParent" o = ObjectGetParentMethodInfo
+    ResolveBusMethod "getPathString" o = ObjectGetPathStringMethodInfo
+    ResolveBusMethod "getProperty" o = GObject.ObjectGetPropertyMethodInfo
+    ResolveBusMethod "getQdata" o = GObject.ObjectGetQdataMethodInfo
+    ResolveBusMethod "getValue" o = ObjectGetValueMethodInfo
+    ResolveBusMethod "getValueArray" o = ObjectGetValueArrayMethodInfo
+    ResolveBusMethod "setControlBindingDisabled" o = ObjectSetControlBindingDisabledMethodInfo
+    ResolveBusMethod "setControlBindingsDisabled" o = ObjectSetControlBindingsDisabledMethodInfo
+    ResolveBusMethod "setControlRate" o = ObjectSetControlRateMethodInfo
+    ResolveBusMethod "setData" o = GObject.ObjectSetDataMethodInfo
+    ResolveBusMethod "setFlushing" o = BusSetFlushingMethodInfo
+    ResolveBusMethod "setName" o = ObjectSetNameMethodInfo
+    ResolveBusMethod "setParent" o = ObjectSetParentMethodInfo
+    ResolveBusMethod "setProperty" o = GObject.ObjectSetPropertyMethodInfo
+    ResolveBusMethod "setSyncHandler" o = BusSetSyncHandlerMethodInfo
+    ResolveBusMethod l o = MethodResolutionFailed l o
+
+instance (info ~ ResolveBusMethod t Bus, MethodInfo info Bus p) => IsLabelProxy t (Bus -> p) where
+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)
+
+#if MIN_VERSION_base(4,9,0)
+instance (info ~ ResolveBusMethod t Bus, MethodInfo info Bus p) => IsLabel t (Bus -> p) where
+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)
+#endif
+
+-- signal Bus::message
+type BusMessageCallback =
+    Message ->
+    IO ()
+
+noBusMessageCallback :: Maybe BusMessageCallback
+noBusMessageCallback = Nothing
+
+type BusMessageCallbackC =
+    Ptr () ->                               -- object
+    Ptr Message ->
+    Ptr () ->                               -- user_data
+    IO ()
+
+foreign import ccall "wrapper"
+    mkBusMessageCallback :: BusMessageCallbackC -> IO (FunPtr BusMessageCallbackC)
+
+busMessageClosure :: BusMessageCallback -> IO Closure
+busMessageClosure cb = newCClosure =<< mkBusMessageCallback wrapped
+    where wrapped = busMessageCallbackWrapper cb
+
+busMessageCallbackWrapper ::
+    BusMessageCallback ->
+    Ptr () ->
+    Ptr Message ->
+    Ptr () ->
+    IO ()
+busMessageCallbackWrapper _cb _ message _ = do
+    message' <- (newBoxed Message) message
+    _cb  message'
+
+onBusMessage :: (GObject a, MonadIO m) => a -> BusMessageCallback -> m SignalHandlerId
+onBusMessage obj cb = liftIO $ connectBusMessage obj cb SignalConnectBefore
+afterBusMessage :: (GObject a, MonadIO m) => a -> BusMessageCallback -> m SignalHandlerId
+afterBusMessage obj cb = connectBusMessage obj cb SignalConnectAfter
+
+connectBusMessage :: (GObject a, MonadIO m) =>
+                     a -> BusMessageCallback -> SignalConnectMode -> m SignalHandlerId
+connectBusMessage obj cb after = liftIO $ do
+    cb' <- mkBusMessageCallback (busMessageCallbackWrapper cb)
+    connectSignalFunPtr obj "message" cb' after
+
+-- signal Bus::sync-message
+type BusSyncMessageCallback =
+    Message ->
+    IO ()
+
+noBusSyncMessageCallback :: Maybe BusSyncMessageCallback
+noBusSyncMessageCallback = Nothing
+
+type BusSyncMessageCallbackC =
+    Ptr () ->                               -- object
+    Ptr Message ->
+    Ptr () ->                               -- user_data
+    IO ()
+
+foreign import ccall "wrapper"
+    mkBusSyncMessageCallback :: BusSyncMessageCallbackC -> IO (FunPtr BusSyncMessageCallbackC)
+
+busSyncMessageClosure :: BusSyncMessageCallback -> IO Closure
+busSyncMessageClosure cb = newCClosure =<< mkBusSyncMessageCallback wrapped
+    where wrapped = busSyncMessageCallbackWrapper cb
+
+busSyncMessageCallbackWrapper ::
+    BusSyncMessageCallback ->
+    Ptr () ->
+    Ptr Message ->
+    Ptr () ->
+    IO ()
+busSyncMessageCallbackWrapper _cb _ message _ = do
+    message' <- (newBoxed Message) message
+    _cb  message'
+
+onBusSyncMessage :: (GObject a, MonadIO m) => a -> BusSyncMessageCallback -> m SignalHandlerId
+onBusSyncMessage obj cb = liftIO $ connectBusSyncMessage obj cb SignalConnectBefore
+afterBusSyncMessage :: (GObject a, MonadIO m) => a -> BusSyncMessageCallback -> m SignalHandlerId
+afterBusSyncMessage obj cb = connectBusSyncMessage obj cb SignalConnectAfter
+
+connectBusSyncMessage :: (GObject a, MonadIO m) =>
+                         a -> BusSyncMessageCallback -> SignalConnectMode -> m SignalHandlerId
+connectBusSyncMessage obj cb after = liftIO $ do
+    cb' <- mkBusSyncMessageCallback (busSyncMessageCallbackWrapper cb)
+    connectSignalFunPtr obj "sync-message" cb' after
+
+-- VVV Prop "enable-async"
+   -- Type: TBasicType TBoolean
+   -- Flags: [PropertyWritable,PropertyConstructOnly]
+
+constructBusEnableAsync :: Bool -> IO ([Char], GValue)
+constructBusEnableAsync val = constructObjectPropertyBool "enable-async" val
+
+data BusEnableAsyncPropertyInfo
+instance AttrInfo BusEnableAsyncPropertyInfo where
+    type AttrAllowedOps BusEnableAsyncPropertyInfo = '[ 'AttrConstruct]
+    type AttrSetTypeConstraint BusEnableAsyncPropertyInfo = (~) Bool
+    type AttrBaseTypeConstraint BusEnableAsyncPropertyInfo = BusK
+    type AttrGetType BusEnableAsyncPropertyInfo = ()
+    type AttrLabel BusEnableAsyncPropertyInfo = "enable-async"
+    attrGet _ = undefined
+    attrSet _ = undefined
+    attrConstruct _ = constructBusEnableAsync
+
+type instance AttributeList Bus = BusAttributeList
+type BusAttributeList = ('[ '("enableAsync", BusEnableAsyncPropertyInfo), '("name", ObjectNamePropertyInfo), '("parent", ObjectParentPropertyInfo)] :: [(Symbol, *)])
+
+data BusMessageSignalInfo
+instance SignalInfo BusMessageSignalInfo where
+    type HaskellCallbackType BusMessageSignalInfo = BusMessageCallback
+    connectSignal _ = connectBusMessage
+
+data BusSyncMessageSignalInfo
+instance SignalInfo BusSyncMessageSignalInfo where
+    type HaskellCallbackType BusSyncMessageSignalInfo = BusSyncMessageCallback
+    connectSignal _ = connectBusSyncMessage
+
+type instance SignalList Bus = BusSignalList
+type BusSignalList = ('[ '("deepNotify", ObjectDeepNotifySignalInfo), '("message", BusMessageSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("syncMessage", BusSyncMessageSignalInfo)] :: [(Symbol, *)])
+
+-- method Bus::new
+-- method type : Constructor
+-- Args : []
+-- Lengths : []
+-- returnType : TInterface "Gst" "Bus"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_bus_new" gst_bus_new :: 
+    IO (Ptr Bus)
+
+
+busNew ::
+    (MonadIO m) =>
+    m Bus                                   -- result
+busNew  = liftIO $ do
+    result <- gst_bus_new
+    checkUnexpectedReturnNULL "gst_bus_new" result
+    result' <- (wrapObject Bus) result
+    return result'
+
+-- method Bus::add_signal_watch
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Bus", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_bus_add_signal_watch" gst_bus_add_signal_watch :: 
+    Ptr Bus ->                              -- _obj : TInterface "Gst" "Bus"
+    IO ()
+
+
+busAddSignalWatch ::
+    (MonadIO m, BusK a) =>
+    a                                       -- _obj
+    -> m ()                                 -- result
+busAddSignalWatch _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    gst_bus_add_signal_watch _obj'
+    touchManagedPtr _obj
+    return ()
+
+data BusAddSignalWatchMethodInfo
+instance (signature ~ (m ()), MonadIO m, BusK a) => MethodInfo BusAddSignalWatchMethodInfo a signature where
+    overloadedMethod _ = busAddSignalWatch
+
+-- method Bus::add_signal_watch_full
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Bus", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_bus_add_signal_watch_full" gst_bus_add_signal_watch_full :: 
+    Ptr Bus ->                              -- _obj : TInterface "Gst" "Bus"
+    Int32 ->                                -- priority : TBasicType TInt32
+    IO ()
+
+
+busAddSignalWatchFull ::
+    (MonadIO m, BusK a) =>
+    a                                       -- _obj
+    -> Int32                                -- priority
+    -> m ()                                 -- result
+busAddSignalWatchFull _obj priority = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    gst_bus_add_signal_watch_full _obj' priority
+    touchManagedPtr _obj
+    return ()
+
+data BusAddSignalWatchFullMethodInfo
+instance (signature ~ (Int32 -> m ()), MonadIO m, BusK a) => MethodInfo BusAddSignalWatchFullMethodInfo a signature where
+    overloadedMethod _ = busAddSignalWatchFull
+
+-- method Bus::add_watch
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Bus", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "priority", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "func", argType = TInterface "Gst" "BusFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeNotified, argClosure = 3, argDestroy = 4, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "notify", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUInt32
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_bus_add_watch_full" gst_bus_add_watch_full :: 
+    Ptr Bus ->                              -- _obj : TInterface "Gst" "Bus"
+    Int32 ->                                -- priority : TBasicType TInt32
+    FunPtr BusFuncC ->                      -- func : TInterface "Gst" "BusFunc"
+    Ptr () ->                               -- user_data : TBasicType TVoid
+    FunPtr GLib.DestroyNotifyC ->           -- notify : TInterface "GLib" "DestroyNotify"
+    IO Word32
+
+
+busAddWatch ::
+    (MonadIO m, BusK a) =>
+    a                                       -- _obj
+    -> Int32                                -- priority
+    -> BusFunc                              -- func
+    -> m Word32                             -- result
+busAddWatch _obj priority func = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    func' <- mkBusFunc (busFuncWrapper Nothing func)
+    let userData = castFunPtrToPtr func'
+    let notify = safeFreeFunPtrPtr
+    result <- gst_bus_add_watch_full _obj' priority func' userData notify
+    touchManagedPtr _obj
+    return result
+
+data BusAddWatchMethodInfo
+instance (signature ~ (Int32 -> BusFunc -> m Word32), MonadIO m, BusK a) => MethodInfo BusAddWatchMethodInfo a signature where
+    overloadedMethod _ = busAddWatch
+
+-- method Bus::async_signal_func
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Bus", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "message", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_bus_async_signal_func" gst_bus_async_signal_func :: 
+    Ptr Bus ->                              -- _obj : TInterface "Gst" "Bus"
+    Ptr Message ->                          -- message : TInterface "Gst" "Message"
+    Ptr () ->                               -- data : TBasicType TVoid
+    IO CInt
+
+
+busAsyncSignalFunc ::
+    (MonadIO m, BusK a) =>
+    a                                       -- _obj
+    -> Message                              -- message
+    -> Ptr ()                               -- data_
+    -> m Bool                               -- result
+busAsyncSignalFunc _obj message data_ = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let message' = unsafeManagedPtrGetPtr message
+    result <- gst_bus_async_signal_func _obj' message' data_
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    touchManagedPtr message
+    return result'
+
+data BusAsyncSignalFuncMethodInfo
+instance (signature ~ (Message -> Ptr () -> m Bool), MonadIO m, BusK a) => MethodInfo BusAsyncSignalFuncMethodInfo a signature where
+    overloadedMethod _ = busAsyncSignalFunc
+
+-- method Bus::create_watch
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Bus", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "GLib" "Source"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_bus_create_watch" gst_bus_create_watch :: 
+    Ptr Bus ->                              -- _obj : TInterface "Gst" "Bus"
+    IO (Ptr GLib.Source)
+
+
+busCreateWatch ::
+    (MonadIO m, BusK a) =>
+    a                                       -- _obj
+    -> m GLib.Source                        -- result
+busCreateWatch _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_bus_create_watch _obj'
+    checkUnexpectedReturnNULL "gst_bus_create_watch" result
+    result' <- (wrapBoxed GLib.Source) result
+    touchManagedPtr _obj
+    return result'
+
+data BusCreateWatchMethodInfo
+instance (signature ~ (m GLib.Source), MonadIO m, BusK a) => MethodInfo BusCreateWatchMethodInfo a signature where
+    overloadedMethod _ = busCreateWatch
+
+-- method Bus::disable_sync_message_emission
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Bus", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_bus_disable_sync_message_emission" gst_bus_disable_sync_message_emission :: 
+    Ptr Bus ->                              -- _obj : TInterface "Gst" "Bus"
+    IO ()
+
+
+busDisableSyncMessageEmission ::
+    (MonadIO m, BusK a) =>
+    a                                       -- _obj
+    -> m ()                                 -- result
+busDisableSyncMessageEmission _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    gst_bus_disable_sync_message_emission _obj'
+    touchManagedPtr _obj
+    return ()
+
+data BusDisableSyncMessageEmissionMethodInfo
+instance (signature ~ (m ()), MonadIO m, BusK a) => MethodInfo BusDisableSyncMessageEmissionMethodInfo a signature where
+    overloadedMethod _ = busDisableSyncMessageEmission
+
+-- method Bus::enable_sync_message_emission
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Bus", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_bus_enable_sync_message_emission" gst_bus_enable_sync_message_emission :: 
+    Ptr Bus ->                              -- _obj : TInterface "Gst" "Bus"
+    IO ()
+
+
+busEnableSyncMessageEmission ::
+    (MonadIO m, BusK a) =>
+    a                                       -- _obj
+    -> m ()                                 -- result
+busEnableSyncMessageEmission _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    gst_bus_enable_sync_message_emission _obj'
+    touchManagedPtr _obj
+    return ()
+
+data BusEnableSyncMessageEmissionMethodInfo
+instance (signature ~ (m ()), MonadIO m, BusK a) => MethodInfo BusEnableSyncMessageEmissionMethodInfo a signature where
+    overloadedMethod _ = busEnableSyncMessageEmission
+
+-- method Bus::have_pending
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Bus", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_bus_have_pending" gst_bus_have_pending :: 
+    Ptr Bus ->                              -- _obj : TInterface "Gst" "Bus"
+    IO CInt
+
+
+busHavePending ::
+    (MonadIO m, BusK a) =>
+    a                                       -- _obj
+    -> m Bool                               -- result
+busHavePending _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_bus_have_pending _obj'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data BusHavePendingMethodInfo
+instance (signature ~ (m Bool), MonadIO m, BusK a) => MethodInfo BusHavePendingMethodInfo a signature where
+    overloadedMethod _ = busHavePending
+
+-- method Bus::peek
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Bus", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Message"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_bus_peek" gst_bus_peek :: 
+    Ptr Bus ->                              -- _obj : TInterface "Gst" "Bus"
+    IO (Ptr Message)
+
+
+busPeek ::
+    (MonadIO m, BusK a) =>
+    a                                       -- _obj
+    -> m Message                            -- result
+busPeek _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_bus_peek _obj'
+    checkUnexpectedReturnNULL "gst_bus_peek" result
+    result' <- (wrapBoxed Message) result
+    touchManagedPtr _obj
+    return result'
+
+data BusPeekMethodInfo
+instance (signature ~ (m Message), MonadIO m, BusK a) => MethodInfo BusPeekMethodInfo a signature where
+    overloadedMethod _ = busPeek
+
+-- method Bus::poll
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Bus", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "events", argType = TInterface "Gst" "MessageType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "timeout", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Message"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_bus_poll" gst_bus_poll :: 
+    Ptr Bus ->                              -- _obj : TInterface "Gst" "Bus"
+    CUInt ->                                -- events : TInterface "Gst" "MessageType"
+    Word64 ->                               -- timeout : TBasicType TUInt64
+    IO (Ptr Message)
+
+
+busPoll ::
+    (MonadIO m, BusK a) =>
+    a                                       -- _obj
+    -> [MessageType]                        -- events
+    -> Word64                               -- timeout
+    -> m Message                            -- result
+busPoll _obj events timeout = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let events' = gflagsToWord events
+    result <- gst_bus_poll _obj' events' timeout
+    checkUnexpectedReturnNULL "gst_bus_poll" result
+    result' <- (wrapBoxed Message) result
+    touchManagedPtr _obj
+    return result'
+
+data BusPollMethodInfo
+instance (signature ~ ([MessageType] -> Word64 -> m Message), MonadIO m, BusK a) => MethodInfo BusPollMethodInfo a signature where
+    overloadedMethod _ = busPoll
+
+-- method Bus::pop
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Bus", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Message"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_bus_pop" gst_bus_pop :: 
+    Ptr Bus ->                              -- _obj : TInterface "Gst" "Bus"
+    IO (Ptr Message)
+
+
+busPop ::
+    (MonadIO m, BusK a) =>
+    a                                       -- _obj
+    -> m Message                            -- result
+busPop _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_bus_pop _obj'
+    checkUnexpectedReturnNULL "gst_bus_pop" result
+    result' <- (wrapBoxed Message) result
+    touchManagedPtr _obj
+    return result'
+
+data BusPopMethodInfo
+instance (signature ~ (m Message), MonadIO m, BusK a) => MethodInfo BusPopMethodInfo a signature where
+    overloadedMethod _ = busPop
+
+-- method Bus::pop_filtered
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Bus", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "types", argType = TInterface "Gst" "MessageType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Message"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_bus_pop_filtered" gst_bus_pop_filtered :: 
+    Ptr Bus ->                              -- _obj : TInterface "Gst" "Bus"
+    CUInt ->                                -- types : TInterface "Gst" "MessageType"
+    IO (Ptr Message)
+
+
+busPopFiltered ::
+    (MonadIO m, BusK a) =>
+    a                                       -- _obj
+    -> [MessageType]                        -- types
+    -> m Message                            -- result
+busPopFiltered _obj types = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let types' = gflagsToWord types
+    result <- gst_bus_pop_filtered _obj' types'
+    checkUnexpectedReturnNULL "gst_bus_pop_filtered" result
+    result' <- (wrapBoxed Message) result
+    touchManagedPtr _obj
+    return result'
+
+data BusPopFilteredMethodInfo
+instance (signature ~ ([MessageType] -> m Message), MonadIO m, BusK a) => MethodInfo BusPopFilteredMethodInfo a signature where
+    overloadedMethod _ = busPopFiltered
+
+-- method Bus::post
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Bus", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "message", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_bus_post" gst_bus_post :: 
+    Ptr Bus ->                              -- _obj : TInterface "Gst" "Bus"
+    Ptr Message ->                          -- message : TInterface "Gst" "Message"
+    IO CInt
+
+
+busPost ::
+    (MonadIO m, BusK a) =>
+    a                                       -- _obj
+    -> Message                              -- message
+    -> m Bool                               -- result
+busPost _obj message = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    message' <- copyBoxed message
+    result <- gst_bus_post _obj' message'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    touchManagedPtr message
+    return result'
+
+data BusPostMethodInfo
+instance (signature ~ (Message -> m Bool), MonadIO m, BusK a) => MethodInfo BusPostMethodInfo a signature where
+    overloadedMethod _ = busPost
+
+-- method Bus::remove_signal_watch
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Bus", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_bus_remove_signal_watch" gst_bus_remove_signal_watch :: 
+    Ptr Bus ->                              -- _obj : TInterface "Gst" "Bus"
+    IO ()
+
+
+busRemoveSignalWatch ::
+    (MonadIO m, BusK a) =>
+    a                                       -- _obj
+    -> m ()                                 -- result
+busRemoveSignalWatch _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    gst_bus_remove_signal_watch _obj'
+    touchManagedPtr _obj
+    return ()
+
+data BusRemoveSignalWatchMethodInfo
+instance (signature ~ (m ()), MonadIO m, BusK a) => MethodInfo BusRemoveSignalWatchMethodInfo a signature where
+    overloadedMethod _ = busRemoveSignalWatch
+
+-- method Bus::remove_watch
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Bus", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_bus_remove_watch" gst_bus_remove_watch :: 
+    Ptr Bus ->                              -- _obj : TInterface "Gst" "Bus"
+    IO CInt
+
+
+busRemoveWatch ::
+    (MonadIO m, BusK a) =>
+    a                                       -- _obj
+    -> m Bool                               -- result
+busRemoveWatch _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_bus_remove_watch _obj'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data BusRemoveWatchMethodInfo
+instance (signature ~ (m Bool), MonadIO m, BusK a) => MethodInfo BusRemoveWatchMethodInfo a signature where
+    overloadedMethod _ = busRemoveWatch
+
+-- method Bus::set_flushing
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Bus", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flushing", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_bus_set_flushing" gst_bus_set_flushing :: 
+    Ptr Bus ->                              -- _obj : TInterface "Gst" "Bus"
+    CInt ->                                 -- flushing : TBasicType TBoolean
+    IO ()
+
+
+busSetFlushing ::
+    (MonadIO m, BusK a) =>
+    a                                       -- _obj
+    -> Bool                                 -- flushing
+    -> m ()                                 -- result
+busSetFlushing _obj flushing = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let flushing' = (fromIntegral . fromEnum) flushing
+    gst_bus_set_flushing _obj' flushing'
+    touchManagedPtr _obj
+    return ()
+
+data BusSetFlushingMethodInfo
+instance (signature ~ (Bool -> m ()), MonadIO m, BusK a) => MethodInfo BusSetFlushingMethodInfo a signature where
+    overloadedMethod _ = busSetFlushing
+
+-- method Bus::set_sync_handler
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Bus", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "func", argType = TInterface "Gst" "BusSyncHandler", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "notify", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_bus_set_sync_handler" gst_bus_set_sync_handler :: 
+    Ptr Bus ->                              -- _obj : TInterface "Gst" "Bus"
+    FunPtr BusSyncHandlerC ->               -- func : TInterface "Gst" "BusSyncHandler"
+    Ptr () ->                               -- user_data : TBasicType TVoid
+    FunPtr GLib.DestroyNotifyC ->           -- notify : TInterface "GLib" "DestroyNotify"
+    IO ()
+
+
+busSetSyncHandler ::
+    (MonadIO m, BusK a) =>
+    a                                       -- _obj
+    -> Maybe (BusSyncHandler)               -- func
+    -> m ()                                 -- result
+busSetSyncHandler _obj func = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    maybeFunc <- case func of
+        Nothing -> return (castPtrToFunPtr nullPtr)
+        Just jFunc -> do
+            jFunc' <- mkBusSyncHandler (busSyncHandlerWrapper Nothing jFunc)
+            return jFunc'
+    let userData = castFunPtrToPtr maybeFunc
+    let notify = safeFreeFunPtrPtr
+    gst_bus_set_sync_handler _obj' maybeFunc userData notify
+    touchManagedPtr _obj
+    return ()
+
+data BusSetSyncHandlerMethodInfo
+instance (signature ~ (Maybe (BusSyncHandler) -> m ()), MonadIO m, BusK a) => MethodInfo BusSetSyncHandlerMethodInfo a signature where
+    overloadedMethod _ = busSetSyncHandler
+
+-- method Bus::sync_signal_handler
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Bus", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "message", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "BusSyncReply"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_bus_sync_signal_handler" gst_bus_sync_signal_handler :: 
+    Ptr Bus ->                              -- _obj : TInterface "Gst" "Bus"
+    Ptr Message ->                          -- message : TInterface "Gst" "Message"
+    Ptr () ->                               -- data : TBasicType TVoid
+    IO CUInt
+
+
+busSyncSignalHandler ::
+    (MonadIO m, BusK a) =>
+    a                                       -- _obj
+    -> Message                              -- message
+    -> Ptr ()                               -- data_
+    -> m BusSyncReply                       -- result
+busSyncSignalHandler _obj message data_ = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let message' = unsafeManagedPtrGetPtr message
+    result <- gst_bus_sync_signal_handler _obj' message' data_
+    let result' = (toEnum . fromIntegral) result
+    touchManagedPtr _obj
+    touchManagedPtr message
+    return result'
+
+data BusSyncSignalHandlerMethodInfo
+instance (signature ~ (Message -> Ptr () -> m BusSyncReply), MonadIO m, BusK a) => MethodInfo BusSyncSignalHandlerMethodInfo a signature where
+    overloadedMethod _ = busSyncSignalHandler
+
+-- method Bus::timed_pop
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Bus", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "timeout", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Message"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_bus_timed_pop" gst_bus_timed_pop :: 
+    Ptr Bus ->                              -- _obj : TInterface "Gst" "Bus"
+    Word64 ->                               -- timeout : TBasicType TUInt64
+    IO (Ptr Message)
+
+
+busTimedPop ::
+    (MonadIO m, BusK a) =>
+    a                                       -- _obj
+    -> Word64                               -- timeout
+    -> m Message                            -- result
+busTimedPop _obj timeout = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_bus_timed_pop _obj' timeout
+    checkUnexpectedReturnNULL "gst_bus_timed_pop" result
+    result' <- (wrapBoxed Message) result
+    touchManagedPtr _obj
+    return result'
+
+data BusTimedPopMethodInfo
+instance (signature ~ (Word64 -> m Message), MonadIO m, BusK a) => MethodInfo BusTimedPopMethodInfo a signature where
+    overloadedMethod _ = busTimedPop
+
+-- method Bus::timed_pop_filtered
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Bus", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "timeout", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "types", argType = TInterface "Gst" "MessageType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Message"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_bus_timed_pop_filtered" gst_bus_timed_pop_filtered :: 
+    Ptr Bus ->                              -- _obj : TInterface "Gst" "Bus"
+    Word64 ->                               -- timeout : TBasicType TUInt64
+    CUInt ->                                -- types : TInterface "Gst" "MessageType"
+    IO (Ptr Message)
+
+
+busTimedPopFiltered ::
+    (MonadIO m, BusK a) =>
+    a                                       -- _obj
+    -> Word64                               -- timeout
+    -> [MessageType]                        -- types
+    -> m Message                            -- result
+busTimedPopFiltered _obj timeout types = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let types' = gflagsToWord types
+    result <- gst_bus_timed_pop_filtered _obj' timeout types'
+    checkUnexpectedReturnNULL "gst_bus_timed_pop_filtered" result
+    result' <- (wrapBoxed Message) result
+    touchManagedPtr _obj
+    return result'
+
+data BusTimedPopFilteredMethodInfo
+instance (signature ~ (Word64 -> [MessageType] -> m Message), MonadIO m, BusK a) => MethodInfo BusTimedPopFilteredMethodInfo a signature where
+    overloadedMethod _ = busTimedPopFiltered
+
+
diff --git a/GI/Gst/Objects/Bus.hs-boot b/GI/Gst/Objects/Bus.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Objects/Bus.hs-boot
@@ -0,0 +1,36 @@
+module GI.Gst.Objects.Bus where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+newtype Bus = Bus (ForeignPtr Bus)
+instance GObject Bus where
+class GObject o => BusK o
+instance (GObject o, IsDescendantOf Bus o) => BusK o
+data BusEnableAsyncPropertyInfo
+data BusMessageSignalInfo
+data BusSyncMessageSignalInfo
+data BusAddSignalWatchMethodInfo
+data BusAddSignalWatchFullMethodInfo
+data BusAddWatchMethodInfo
+data BusAsyncSignalFuncMethodInfo
+data BusCreateWatchMethodInfo
+data BusDisableSyncMessageEmissionMethodInfo
+data BusEnableSyncMessageEmissionMethodInfo
+data BusHavePendingMethodInfo
+data BusPeekMethodInfo
+data BusPollMethodInfo
+data BusPopMethodInfo
+data BusPopFilteredMethodInfo
+data BusPostMethodInfo
+data BusRemoveSignalWatchMethodInfo
+data BusRemoveWatchMethodInfo
+data BusSetFlushingMethodInfo
+data BusSetSyncHandlerMethodInfo
+data BusSyncSignalHandlerMethodInfo
+data BusTimedPopMethodInfo
+data BusTimedPopFilteredMethodInfo
diff --git a/GI/Gst/Objects/Clock.hs b/GI/Gst/Objects/Clock.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Objects/Clock.hs
@@ -0,0 +1,1305 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+-}
+
+module GI.Gst.Objects.Clock
+    ( 
+
+-- * Exported types
+    Clock(..)                               ,
+    ClockK                                  ,
+    toClock                                 ,
+    noClock                                 ,
+
+
+ -- * Methods
+-- ** clockAddObservation
+    ClockAddObservationMethodInfo           ,
+    clockAddObservation                     ,
+
+
+-- ** clockAddObservationUnapplied
+    ClockAddObservationUnappliedMethodInfo  ,
+    clockAddObservationUnapplied            ,
+
+
+-- ** clockAdjustUnlocked
+    ClockAdjustUnlockedMethodInfo           ,
+    clockAdjustUnlocked                     ,
+
+
+-- ** clockAdjustWithCalibration
+    ClockAdjustWithCalibrationMethodInfo    ,
+    clockAdjustWithCalibration              ,
+
+
+-- ** clockGetCalibration
+    ClockGetCalibrationMethodInfo           ,
+    clockGetCalibration                     ,
+
+
+-- ** clockGetInternalTime
+    ClockGetInternalTimeMethodInfo          ,
+    clockGetInternalTime                    ,
+
+
+-- ** clockGetMaster
+    ClockGetMasterMethodInfo                ,
+    clockGetMaster                          ,
+
+
+-- ** clockGetResolution
+    ClockGetResolutionMethodInfo            ,
+    clockGetResolution                      ,
+
+
+-- ** clockGetTime
+    ClockGetTimeMethodInfo                  ,
+    clockGetTime                            ,
+
+
+-- ** clockGetTimeout
+    ClockGetTimeoutMethodInfo               ,
+    clockGetTimeout                         ,
+
+
+-- ** clockIdCompareFunc
+    clockIdCompareFunc                      ,
+
+
+-- ** clockIdGetTime
+    clockIdGetTime                          ,
+
+
+-- ** clockIdRef
+    clockIdRef                              ,
+
+
+-- ** clockIdUnref
+    clockIdUnref                            ,
+
+
+-- ** clockIdUnschedule
+    clockIdUnschedule                       ,
+
+
+-- ** clockIdWait
+    clockIdWait                             ,
+
+
+-- ** clockIdWaitAsync
+    clockIdWaitAsync                        ,
+
+
+-- ** clockIsSynced
+    ClockIsSyncedMethodInfo                 ,
+    clockIsSynced                           ,
+
+
+-- ** clockNewPeriodicId
+    ClockNewPeriodicIdMethodInfo            ,
+    clockNewPeriodicId                      ,
+
+
+-- ** clockNewSingleShotId
+    ClockNewSingleShotIdMethodInfo          ,
+    clockNewSingleShotId                    ,
+
+
+-- ** clockPeriodicIdReinit
+    ClockPeriodicIdReinitMethodInfo         ,
+    clockPeriodicIdReinit                   ,
+
+
+-- ** clockSetCalibration
+    ClockSetCalibrationMethodInfo           ,
+    clockSetCalibration                     ,
+
+
+-- ** clockSetMaster
+    ClockSetMasterMethodInfo                ,
+    clockSetMaster                          ,
+
+
+-- ** clockSetResolution
+    ClockSetResolutionMethodInfo            ,
+    clockSetResolution                      ,
+
+
+-- ** clockSetSynced
+    ClockSetSyncedMethodInfo                ,
+    clockSetSynced                          ,
+
+
+-- ** clockSetTimeout
+    ClockSetTimeoutMethodInfo               ,
+    clockSetTimeout                         ,
+
+
+-- ** clockSingleShotIdReinit
+    ClockSingleShotIdReinitMethodInfo       ,
+    clockSingleShotIdReinit                 ,
+
+
+-- ** clockUnadjustUnlocked
+    ClockUnadjustUnlockedMethodInfo         ,
+    clockUnadjustUnlocked                   ,
+
+
+-- ** clockWaitForSync
+    ClockWaitForSyncMethodInfo              ,
+    clockWaitForSync                        ,
+
+
+
+
+ -- * Properties
+-- ** Timeout
+    ClockTimeoutPropertyInfo                ,
+    constructClockTimeout                   ,
+    getClockTimeout                         ,
+    setClockTimeout                         ,
+
+
+-- ** WindowSize
+    ClockWindowSizePropertyInfo             ,
+    constructClockWindowSize                ,
+    getClockWindowSize                      ,
+    setClockWindowSize                      ,
+
+
+-- ** WindowThreshold
+    ClockWindowThresholdPropertyInfo        ,
+    constructClockWindowThreshold           ,
+    getClockWindowThreshold                 ,
+    setClockWindowThreshold                 ,
+
+
+
+
+ -- * Signals
+-- ** Synced
+    ClockSyncedCallback                     ,
+    ClockSyncedCallbackC                    ,
+    ClockSyncedSignalInfo                   ,
+    afterClockSynced                        ,
+    clockSyncedCallbackWrapper              ,
+    clockSyncedClosure                      ,
+    mkClockSyncedCallback                   ,
+    noClockSyncedCallback                   ,
+    onClockSynced                           ,
+
+
+
+
+    ) where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+import GI.Gst.Callbacks
+import qualified GI.GLib as GLib
+import qualified GI.GObject as GObject
+
+newtype Clock = Clock (ForeignPtr Clock)
+foreign import ccall "gst_clock_get_type"
+    c_gst_clock_get_type :: IO GType
+
+type instance ParentTypes Clock = ClockParentTypes
+type ClockParentTypes = '[Object, GObject.Object]
+
+instance GObject Clock where
+    gobjectIsInitiallyUnowned _ = True
+    gobjectType _ = c_gst_clock_get_type
+    
+
+class GObject o => ClockK o
+instance (GObject o, IsDescendantOf Clock o) => ClockK o
+
+toClock :: ClockK o => o -> IO Clock
+toClock = unsafeCastTo Clock
+
+noClock :: Maybe Clock
+noClock = Nothing
+
+type family ResolveClockMethod (t :: Symbol) (o :: *) :: * where
+    ResolveClockMethod "addControlBinding" o = ObjectAddControlBindingMethodInfo
+    ResolveClockMethod "addObservation" o = ClockAddObservationMethodInfo
+    ResolveClockMethod "addObservationUnapplied" o = ClockAddObservationUnappliedMethodInfo
+    ResolveClockMethod "adjustUnlocked" o = ClockAdjustUnlockedMethodInfo
+    ResolveClockMethod "adjustWithCalibration" o = ClockAdjustWithCalibrationMethodInfo
+    ResolveClockMethod "bindProperty" o = GObject.ObjectBindPropertyMethodInfo
+    ResolveClockMethod "bindPropertyFull" o = GObject.ObjectBindPropertyFullMethodInfo
+    ResolveClockMethod "defaultError" o = ObjectDefaultErrorMethodInfo
+    ResolveClockMethod "forceFloating" o = GObject.ObjectForceFloatingMethodInfo
+    ResolveClockMethod "freezeNotify" o = GObject.ObjectFreezeNotifyMethodInfo
+    ResolveClockMethod "hasActiveControlBindings" o = ObjectHasActiveControlBindingsMethodInfo
+    ResolveClockMethod "hasAncestor" o = ObjectHasAncestorMethodInfo
+    ResolveClockMethod "hasAsAncestor" o = ObjectHasAsAncestorMethodInfo
+    ResolveClockMethod "hasAsParent" o = ObjectHasAsParentMethodInfo
+    ResolveClockMethod "isFloating" o = GObject.ObjectIsFloatingMethodInfo
+    ResolveClockMethod "isSynced" o = ClockIsSyncedMethodInfo
+    ResolveClockMethod "newPeriodicId" o = ClockNewPeriodicIdMethodInfo
+    ResolveClockMethod "newSingleShotId" o = ClockNewSingleShotIdMethodInfo
+    ResolveClockMethod "notify" o = GObject.ObjectNotifyMethodInfo
+    ResolveClockMethod "notifyByPspec" o = GObject.ObjectNotifyByPspecMethodInfo
+    ResolveClockMethod "periodicIdReinit" o = ClockPeriodicIdReinitMethodInfo
+    ResolveClockMethod "refSink" o = GObject.ObjectRefSinkMethodInfo
+    ResolveClockMethod "removeControlBinding" o = ObjectRemoveControlBindingMethodInfo
+    ResolveClockMethod "replaceData" o = GObject.ObjectReplaceDataMethodInfo
+    ResolveClockMethod "replaceQdata" o = GObject.ObjectReplaceQdataMethodInfo
+    ResolveClockMethod "runDispose" o = GObject.ObjectRunDisposeMethodInfo
+    ResolveClockMethod "singleShotIdReinit" o = ClockSingleShotIdReinitMethodInfo
+    ResolveClockMethod "stealData" o = GObject.ObjectStealDataMethodInfo
+    ResolveClockMethod "stealQdata" o = GObject.ObjectStealQdataMethodInfo
+    ResolveClockMethod "suggestNextSync" o = ObjectSuggestNextSyncMethodInfo
+    ResolveClockMethod "syncValues" o = ObjectSyncValuesMethodInfo
+    ResolveClockMethod "thawNotify" o = GObject.ObjectThawNotifyMethodInfo
+    ResolveClockMethod "unadjustUnlocked" o = ClockUnadjustUnlockedMethodInfo
+    ResolveClockMethod "unparent" o = ObjectUnparentMethodInfo
+    ResolveClockMethod "waitForSync" o = ClockWaitForSyncMethodInfo
+    ResolveClockMethod "watchClosure" o = GObject.ObjectWatchClosureMethodInfo
+    ResolveClockMethod "getCalibration" o = ClockGetCalibrationMethodInfo
+    ResolveClockMethod "getControlBinding" o = ObjectGetControlBindingMethodInfo
+    ResolveClockMethod "getControlRate" o = ObjectGetControlRateMethodInfo
+    ResolveClockMethod "getData" o = GObject.ObjectGetDataMethodInfo
+    ResolveClockMethod "getGValueArray" o = ObjectGetGValueArrayMethodInfo
+    ResolveClockMethod "getInternalTime" o = ClockGetInternalTimeMethodInfo
+    ResolveClockMethod "getMaster" o = ClockGetMasterMethodInfo
+    ResolveClockMethod "getName" o = ObjectGetNameMethodInfo
+    ResolveClockMethod "getParent" o = ObjectGetParentMethodInfo
+    ResolveClockMethod "getPathString" o = ObjectGetPathStringMethodInfo
+    ResolveClockMethod "getProperty" o = GObject.ObjectGetPropertyMethodInfo
+    ResolveClockMethod "getQdata" o = GObject.ObjectGetQdataMethodInfo
+    ResolveClockMethod "getResolution" o = ClockGetResolutionMethodInfo
+    ResolveClockMethod "getTime" o = ClockGetTimeMethodInfo
+    ResolveClockMethod "getTimeout" o = ClockGetTimeoutMethodInfo
+    ResolveClockMethod "getValue" o = ObjectGetValueMethodInfo
+    ResolveClockMethod "getValueArray" o = ObjectGetValueArrayMethodInfo
+    ResolveClockMethod "setCalibration" o = ClockSetCalibrationMethodInfo
+    ResolveClockMethod "setControlBindingDisabled" o = ObjectSetControlBindingDisabledMethodInfo
+    ResolveClockMethod "setControlBindingsDisabled" o = ObjectSetControlBindingsDisabledMethodInfo
+    ResolveClockMethod "setControlRate" o = ObjectSetControlRateMethodInfo
+    ResolveClockMethod "setData" o = GObject.ObjectSetDataMethodInfo
+    ResolveClockMethod "setMaster" o = ClockSetMasterMethodInfo
+    ResolveClockMethod "setName" o = ObjectSetNameMethodInfo
+    ResolveClockMethod "setParent" o = ObjectSetParentMethodInfo
+    ResolveClockMethod "setProperty" o = GObject.ObjectSetPropertyMethodInfo
+    ResolveClockMethod "setResolution" o = ClockSetResolutionMethodInfo
+    ResolveClockMethod "setSynced" o = ClockSetSyncedMethodInfo
+    ResolveClockMethod "setTimeout" o = ClockSetTimeoutMethodInfo
+    ResolveClockMethod l o = MethodResolutionFailed l o
+
+instance (info ~ ResolveClockMethod t Clock, MethodInfo info Clock p) => IsLabelProxy t (Clock -> p) where
+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)
+
+#if MIN_VERSION_base(4,9,0)
+instance (info ~ ResolveClockMethod t Clock, MethodInfo info Clock p) => IsLabel t (Clock -> p) where
+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)
+#endif
+
+-- signal Clock::synced
+type ClockSyncedCallback =
+    Bool ->
+    IO ()
+
+noClockSyncedCallback :: Maybe ClockSyncedCallback
+noClockSyncedCallback = Nothing
+
+type ClockSyncedCallbackC =
+    Ptr () ->                               -- object
+    CInt ->
+    Ptr () ->                               -- user_data
+    IO ()
+
+foreign import ccall "wrapper"
+    mkClockSyncedCallback :: ClockSyncedCallbackC -> IO (FunPtr ClockSyncedCallbackC)
+
+clockSyncedClosure :: ClockSyncedCallback -> IO Closure
+clockSyncedClosure cb = newCClosure =<< mkClockSyncedCallback wrapped
+    where wrapped = clockSyncedCallbackWrapper cb
+
+clockSyncedCallbackWrapper ::
+    ClockSyncedCallback ->
+    Ptr () ->
+    CInt ->
+    Ptr () ->
+    IO ()
+clockSyncedCallbackWrapper _cb _ synced _ = do
+    let synced' = (/= 0) synced
+    _cb  synced'
+
+onClockSynced :: (GObject a, MonadIO m) => a -> ClockSyncedCallback -> m SignalHandlerId
+onClockSynced obj cb = liftIO $ connectClockSynced obj cb SignalConnectBefore
+afterClockSynced :: (GObject a, MonadIO m) => a -> ClockSyncedCallback -> m SignalHandlerId
+afterClockSynced obj cb = connectClockSynced obj cb SignalConnectAfter
+
+connectClockSynced :: (GObject a, MonadIO m) =>
+                      a -> ClockSyncedCallback -> SignalConnectMode -> m SignalHandlerId
+connectClockSynced obj cb after = liftIO $ do
+    cb' <- mkClockSyncedCallback (clockSyncedCallbackWrapper cb)
+    connectSignalFunPtr obj "synced" cb' after
+
+-- VVV Prop "timeout"
+   -- Type: TBasicType TUInt64
+   -- Flags: [PropertyReadable,PropertyWritable]
+
+getClockTimeout :: (MonadIO m, ClockK o) => o -> m Word64
+getClockTimeout obj = liftIO $ getObjectPropertyUInt64 obj "timeout"
+
+setClockTimeout :: (MonadIO m, ClockK o) => o -> Word64 -> m ()
+setClockTimeout obj val = liftIO $ setObjectPropertyUInt64 obj "timeout" val
+
+constructClockTimeout :: Word64 -> IO ([Char], GValue)
+constructClockTimeout val = constructObjectPropertyUInt64 "timeout" val
+
+data ClockTimeoutPropertyInfo
+instance AttrInfo ClockTimeoutPropertyInfo where
+    type AttrAllowedOps ClockTimeoutPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
+    type AttrSetTypeConstraint ClockTimeoutPropertyInfo = (~) Word64
+    type AttrBaseTypeConstraint ClockTimeoutPropertyInfo = ClockK
+    type AttrGetType ClockTimeoutPropertyInfo = Word64
+    type AttrLabel ClockTimeoutPropertyInfo = "timeout"
+    attrGet _ = getClockTimeout
+    attrSet _ = setClockTimeout
+    attrConstruct _ = constructClockTimeout
+
+-- VVV Prop "window-size"
+   -- Type: TBasicType TInt32
+   -- Flags: [PropertyReadable,PropertyWritable]
+
+getClockWindowSize :: (MonadIO m, ClockK o) => o -> m Int32
+getClockWindowSize obj = liftIO $ getObjectPropertyCInt obj "window-size"
+
+setClockWindowSize :: (MonadIO m, ClockK o) => o -> Int32 -> m ()
+setClockWindowSize obj val = liftIO $ setObjectPropertyCInt obj "window-size" val
+
+constructClockWindowSize :: Int32 -> IO ([Char], GValue)
+constructClockWindowSize val = constructObjectPropertyCInt "window-size" val
+
+data ClockWindowSizePropertyInfo
+instance AttrInfo ClockWindowSizePropertyInfo where
+    type AttrAllowedOps ClockWindowSizePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
+    type AttrSetTypeConstraint ClockWindowSizePropertyInfo = (~) Int32
+    type AttrBaseTypeConstraint ClockWindowSizePropertyInfo = ClockK
+    type AttrGetType ClockWindowSizePropertyInfo = Int32
+    type AttrLabel ClockWindowSizePropertyInfo = "window-size"
+    attrGet _ = getClockWindowSize
+    attrSet _ = setClockWindowSize
+    attrConstruct _ = constructClockWindowSize
+
+-- VVV Prop "window-threshold"
+   -- Type: TBasicType TInt32
+   -- Flags: [PropertyReadable,PropertyWritable]
+
+getClockWindowThreshold :: (MonadIO m, ClockK o) => o -> m Int32
+getClockWindowThreshold obj = liftIO $ getObjectPropertyCInt obj "window-threshold"
+
+setClockWindowThreshold :: (MonadIO m, ClockK o) => o -> Int32 -> m ()
+setClockWindowThreshold obj val = liftIO $ setObjectPropertyCInt obj "window-threshold" val
+
+constructClockWindowThreshold :: Int32 -> IO ([Char], GValue)
+constructClockWindowThreshold val = constructObjectPropertyCInt "window-threshold" val
+
+data ClockWindowThresholdPropertyInfo
+instance AttrInfo ClockWindowThresholdPropertyInfo where
+    type AttrAllowedOps ClockWindowThresholdPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
+    type AttrSetTypeConstraint ClockWindowThresholdPropertyInfo = (~) Int32
+    type AttrBaseTypeConstraint ClockWindowThresholdPropertyInfo = ClockK
+    type AttrGetType ClockWindowThresholdPropertyInfo = Int32
+    type AttrLabel ClockWindowThresholdPropertyInfo = "window-threshold"
+    attrGet _ = getClockWindowThreshold
+    attrSet _ = setClockWindowThreshold
+    attrConstruct _ = constructClockWindowThreshold
+
+type instance AttributeList Clock = ClockAttributeList
+type ClockAttributeList = ('[ '("name", ObjectNamePropertyInfo), '("parent", ObjectParentPropertyInfo), '("timeout", ClockTimeoutPropertyInfo), '("windowSize", ClockWindowSizePropertyInfo), '("windowThreshold", ClockWindowThresholdPropertyInfo)] :: [(Symbol, *)])
+
+data ClockSyncedSignalInfo
+instance SignalInfo ClockSyncedSignalInfo where
+    type HaskellCallbackType ClockSyncedSignalInfo = ClockSyncedCallback
+    connectSignal _ = connectClockSynced
+
+type instance SignalList Clock = ClockSignalList
+type ClockSignalList = ('[ '("deepNotify", ObjectDeepNotifySignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("synced", ClockSyncedSignalInfo)] :: [(Symbol, *)])
+
+-- method Clock::add_observation
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Clock", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "slave", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "master", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "r_squared", argType = TBasicType TDouble, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_clock_add_observation" gst_clock_add_observation :: 
+    Ptr Clock ->                            -- _obj : TInterface "Gst" "Clock"
+    Word64 ->                               -- slave : TBasicType TUInt64
+    Word64 ->                               -- master : TBasicType TUInt64
+    Ptr CDouble ->                          -- r_squared : TBasicType TDouble
+    IO CInt
+
+
+clockAddObservation ::
+    (MonadIO m, ClockK a) =>
+    a                                       -- _obj
+    -> Word64                               -- slave
+    -> Word64                               -- master
+    -> m (Bool,Double)                      -- result
+clockAddObservation _obj slave master = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    rSquared <- allocMem :: IO (Ptr CDouble)
+    result <- gst_clock_add_observation _obj' slave master rSquared
+    let result' = (/= 0) result
+    rSquared' <- peek rSquared
+    let rSquared'' = realToFrac rSquared'
+    touchManagedPtr _obj
+    freeMem rSquared
+    return (result', rSquared'')
+
+data ClockAddObservationMethodInfo
+instance (signature ~ (Word64 -> Word64 -> m (Bool,Double)), MonadIO m, ClockK a) => MethodInfo ClockAddObservationMethodInfo a signature where
+    overloadedMethod _ = clockAddObservation
+
+-- method Clock::add_observation_unapplied
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Clock", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "slave", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "master", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "r_squared", argType = TBasicType TDouble, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "internal", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "external", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "rate_num", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "rate_denom", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_clock_add_observation_unapplied" gst_clock_add_observation_unapplied :: 
+    Ptr Clock ->                            -- _obj : TInterface "Gst" "Clock"
+    Word64 ->                               -- slave : TBasicType TUInt64
+    Word64 ->                               -- master : TBasicType TUInt64
+    Ptr CDouble ->                          -- r_squared : TBasicType TDouble
+    Ptr Word64 ->                           -- internal : TBasicType TUInt64
+    Ptr Word64 ->                           -- external : TBasicType TUInt64
+    Ptr Word64 ->                           -- rate_num : TBasicType TUInt64
+    Ptr Word64 ->                           -- rate_denom : TBasicType TUInt64
+    IO CInt
+
+
+clockAddObservationUnapplied ::
+    (MonadIO m, ClockK a) =>
+    a                                       -- _obj
+    -> Word64                               -- slave
+    -> Word64                               -- master
+    -> m (Bool,Double,Word64,Word64,Word64,Word64)-- result
+clockAddObservationUnapplied _obj slave master = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    rSquared <- allocMem :: IO (Ptr CDouble)
+    internal <- allocMem :: IO (Ptr Word64)
+    external <- allocMem :: IO (Ptr Word64)
+    rateNum <- allocMem :: IO (Ptr Word64)
+    rateDenom <- allocMem :: IO (Ptr Word64)
+    result <- gst_clock_add_observation_unapplied _obj' slave master rSquared internal external rateNum rateDenom
+    let result' = (/= 0) result
+    rSquared' <- peek rSquared
+    let rSquared'' = realToFrac rSquared'
+    internal' <- peek internal
+    external' <- peek external
+    rateNum' <- peek rateNum
+    rateDenom' <- peek rateDenom
+    touchManagedPtr _obj
+    freeMem rSquared
+    freeMem internal
+    freeMem external
+    freeMem rateNum
+    freeMem rateDenom
+    return (result', rSquared'', internal', external', rateNum', rateDenom')
+
+data ClockAddObservationUnappliedMethodInfo
+instance (signature ~ (Word64 -> Word64 -> m (Bool,Double,Word64,Word64,Word64,Word64)), MonadIO m, ClockK a) => MethodInfo ClockAddObservationUnappliedMethodInfo a signature where
+    overloadedMethod _ = clockAddObservationUnapplied
+
+-- method Clock::adjust_unlocked
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Clock", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "internal", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUInt64
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_clock_adjust_unlocked" gst_clock_adjust_unlocked :: 
+    Ptr Clock ->                            -- _obj : TInterface "Gst" "Clock"
+    Word64 ->                               -- internal : TBasicType TUInt64
+    IO Word64
+
+
+clockAdjustUnlocked ::
+    (MonadIO m, ClockK a) =>
+    a                                       -- _obj
+    -> Word64                               -- internal
+    -> m Word64                             -- result
+clockAdjustUnlocked _obj internal = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_clock_adjust_unlocked _obj' internal
+    touchManagedPtr _obj
+    return result
+
+data ClockAdjustUnlockedMethodInfo
+instance (signature ~ (Word64 -> m Word64), MonadIO m, ClockK a) => MethodInfo ClockAdjustUnlockedMethodInfo a signature where
+    overloadedMethod _ = clockAdjustUnlocked
+
+-- method Clock::adjust_with_calibration
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Clock", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "internal_target", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cinternal", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cexternal", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cnum", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cdenom", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUInt64
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_clock_adjust_with_calibration" gst_clock_adjust_with_calibration :: 
+    Ptr Clock ->                            -- _obj : TInterface "Gst" "Clock"
+    Word64 ->                               -- internal_target : TBasicType TUInt64
+    Word64 ->                               -- cinternal : TBasicType TUInt64
+    Word64 ->                               -- cexternal : TBasicType TUInt64
+    Word64 ->                               -- cnum : TBasicType TUInt64
+    Word64 ->                               -- cdenom : TBasicType TUInt64
+    IO Word64
+
+
+clockAdjustWithCalibration ::
+    (MonadIO m, ClockK a) =>
+    a                                       -- _obj
+    -> Word64                               -- internalTarget
+    -> Word64                               -- cinternal
+    -> Word64                               -- cexternal
+    -> Word64                               -- cnum
+    -> Word64                               -- cdenom
+    -> m Word64                             -- result
+clockAdjustWithCalibration _obj internalTarget cinternal cexternal cnum cdenom = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_clock_adjust_with_calibration _obj' internalTarget cinternal cexternal cnum cdenom
+    touchManagedPtr _obj
+    return result
+
+data ClockAdjustWithCalibrationMethodInfo
+instance (signature ~ (Word64 -> Word64 -> Word64 -> Word64 -> Word64 -> m Word64), MonadIO m, ClockK a) => MethodInfo ClockAdjustWithCalibrationMethodInfo a signature where
+    overloadedMethod _ = clockAdjustWithCalibration
+
+-- method Clock::get_calibration
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Clock", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "internal", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "external", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "rate_num", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "rate_denom", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_clock_get_calibration" gst_clock_get_calibration :: 
+    Ptr Clock ->                            -- _obj : TInterface "Gst" "Clock"
+    Ptr Word64 ->                           -- internal : TBasicType TUInt64
+    Ptr Word64 ->                           -- external : TBasicType TUInt64
+    Ptr Word64 ->                           -- rate_num : TBasicType TUInt64
+    Ptr Word64 ->                           -- rate_denom : TBasicType TUInt64
+    IO ()
+
+
+clockGetCalibration ::
+    (MonadIO m, ClockK a) =>
+    a                                       -- _obj
+    -> m (Word64,Word64,Word64,Word64)      -- result
+clockGetCalibration _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    internal <- allocMem :: IO (Ptr Word64)
+    external <- allocMem :: IO (Ptr Word64)
+    rateNum <- allocMem :: IO (Ptr Word64)
+    rateDenom <- allocMem :: IO (Ptr Word64)
+    gst_clock_get_calibration _obj' internal external rateNum rateDenom
+    internal' <- peek internal
+    external' <- peek external
+    rateNum' <- peek rateNum
+    rateDenom' <- peek rateDenom
+    touchManagedPtr _obj
+    freeMem internal
+    freeMem external
+    freeMem rateNum
+    freeMem rateDenom
+    return (internal', external', rateNum', rateDenom')
+
+data ClockGetCalibrationMethodInfo
+instance (signature ~ (m (Word64,Word64,Word64,Word64)), MonadIO m, ClockK a) => MethodInfo ClockGetCalibrationMethodInfo a signature where
+    overloadedMethod _ = clockGetCalibration
+
+-- method Clock::get_internal_time
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Clock", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUInt64
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_clock_get_internal_time" gst_clock_get_internal_time :: 
+    Ptr Clock ->                            -- _obj : TInterface "Gst" "Clock"
+    IO Word64
+
+
+clockGetInternalTime ::
+    (MonadIO m, ClockK a) =>
+    a                                       -- _obj
+    -> m Word64                             -- result
+clockGetInternalTime _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_clock_get_internal_time _obj'
+    touchManagedPtr _obj
+    return result
+
+data ClockGetInternalTimeMethodInfo
+instance (signature ~ (m Word64), MonadIO m, ClockK a) => MethodInfo ClockGetInternalTimeMethodInfo a signature where
+    overloadedMethod _ = clockGetInternalTime
+
+-- method Clock::get_master
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Clock", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Clock"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_clock_get_master" gst_clock_get_master :: 
+    Ptr Clock ->                            -- _obj : TInterface "Gst" "Clock"
+    IO (Ptr Clock)
+
+
+clockGetMaster ::
+    (MonadIO m, ClockK a) =>
+    a                                       -- _obj
+    -> m Clock                              -- result
+clockGetMaster _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_clock_get_master _obj'
+    checkUnexpectedReturnNULL "gst_clock_get_master" result
+    result' <- (wrapObject Clock) result
+    touchManagedPtr _obj
+    return result'
+
+data ClockGetMasterMethodInfo
+instance (signature ~ (m Clock), MonadIO m, ClockK a) => MethodInfo ClockGetMasterMethodInfo a signature where
+    overloadedMethod _ = clockGetMaster
+
+-- method Clock::get_resolution
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Clock", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUInt64
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_clock_get_resolution" gst_clock_get_resolution :: 
+    Ptr Clock ->                            -- _obj : TInterface "Gst" "Clock"
+    IO Word64
+
+
+clockGetResolution ::
+    (MonadIO m, ClockK a) =>
+    a                                       -- _obj
+    -> m Word64                             -- result
+clockGetResolution _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_clock_get_resolution _obj'
+    touchManagedPtr _obj
+    return result
+
+data ClockGetResolutionMethodInfo
+instance (signature ~ (m Word64), MonadIO m, ClockK a) => MethodInfo ClockGetResolutionMethodInfo a signature where
+    overloadedMethod _ = clockGetResolution
+
+-- method Clock::get_time
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Clock", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUInt64
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_clock_get_time" gst_clock_get_time :: 
+    Ptr Clock ->                            -- _obj : TInterface "Gst" "Clock"
+    IO Word64
+
+
+clockGetTime ::
+    (MonadIO m, ClockK a) =>
+    a                                       -- _obj
+    -> m Word64                             -- result
+clockGetTime _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_clock_get_time _obj'
+    touchManagedPtr _obj
+    return result
+
+data ClockGetTimeMethodInfo
+instance (signature ~ (m Word64), MonadIO m, ClockK a) => MethodInfo ClockGetTimeMethodInfo a signature where
+    overloadedMethod _ = clockGetTime
+
+-- method Clock::get_timeout
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Clock", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUInt64
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_clock_get_timeout" gst_clock_get_timeout :: 
+    Ptr Clock ->                            -- _obj : TInterface "Gst" "Clock"
+    IO Word64
+
+
+clockGetTimeout ::
+    (MonadIO m, ClockK a) =>
+    a                                       -- _obj
+    -> m Word64                             -- result
+clockGetTimeout _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_clock_get_timeout _obj'
+    touchManagedPtr _obj
+    return result
+
+data ClockGetTimeoutMethodInfo
+instance (signature ~ (m Word64), MonadIO m, ClockK a) => MethodInfo ClockGetTimeoutMethodInfo a signature where
+    overloadedMethod _ = clockGetTimeout
+
+-- method Clock::is_synced
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Clock", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_clock_is_synced" gst_clock_is_synced :: 
+    Ptr Clock ->                            -- _obj : TInterface "Gst" "Clock"
+    IO CInt
+
+
+clockIsSynced ::
+    (MonadIO m, ClockK a) =>
+    a                                       -- _obj
+    -> m Bool                               -- result
+clockIsSynced _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_clock_is_synced _obj'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data ClockIsSyncedMethodInfo
+instance (signature ~ (m Bool), MonadIO m, ClockK a) => MethodInfo ClockIsSyncedMethodInfo a signature where
+    overloadedMethod _ = clockIsSynced
+
+-- method Clock::new_periodic_id
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Clock", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start_time", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "interval", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_clock_new_periodic_id" gst_clock_new_periodic_id :: 
+    Ptr Clock ->                            -- _obj : TInterface "Gst" "Clock"
+    Word64 ->                               -- start_time : TBasicType TUInt64
+    Word64 ->                               -- interval : TBasicType TUInt64
+    IO ()
+
+
+clockNewPeriodicId ::
+    (MonadIO m, ClockK a) =>
+    a                                       -- _obj
+    -> Word64                               -- startTime
+    -> Word64                               -- interval
+    -> m ()                                 -- result
+clockNewPeriodicId _obj startTime interval = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    gst_clock_new_periodic_id _obj' startTime interval
+    touchManagedPtr _obj
+    return ()
+
+data ClockNewPeriodicIdMethodInfo
+instance (signature ~ (Word64 -> Word64 -> m ()), MonadIO m, ClockK a) => MethodInfo ClockNewPeriodicIdMethodInfo a signature where
+    overloadedMethod _ = clockNewPeriodicId
+
+-- method Clock::new_single_shot_id
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Clock", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "time", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_clock_new_single_shot_id" gst_clock_new_single_shot_id :: 
+    Ptr Clock ->                            -- _obj : TInterface "Gst" "Clock"
+    Word64 ->                               -- time : TBasicType TUInt64
+    IO ()
+
+
+clockNewSingleShotId ::
+    (MonadIO m, ClockK a) =>
+    a                                       -- _obj
+    -> Word64                               -- time
+    -> m ()                                 -- result
+clockNewSingleShotId _obj time = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    gst_clock_new_single_shot_id _obj' time
+    touchManagedPtr _obj
+    return ()
+
+data ClockNewSingleShotIdMethodInfo
+instance (signature ~ (Word64 -> m ()), MonadIO m, ClockK a) => MethodInfo ClockNewSingleShotIdMethodInfo a signature where
+    overloadedMethod _ = clockNewSingleShotId
+
+-- method Clock::periodic_id_reinit
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Clock", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "id", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start_time", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "interval", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_clock_periodic_id_reinit" gst_clock_periodic_id_reinit :: 
+    Ptr Clock ->                            -- _obj : TInterface "Gst" "Clock"
+    Ptr () ->                               -- id : TBasicType TVoid
+    Word64 ->                               -- start_time : TBasicType TUInt64
+    Word64 ->                               -- interval : TBasicType TUInt64
+    IO CInt
+
+
+clockPeriodicIdReinit ::
+    (MonadIO m, ClockK a) =>
+    a                                       -- _obj
+    -> Ptr ()                               -- id
+    -> Word64                               -- startTime
+    -> Word64                               -- interval
+    -> m Bool                               -- result
+clockPeriodicIdReinit _obj id startTime interval = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_clock_periodic_id_reinit _obj' id startTime interval
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data ClockPeriodicIdReinitMethodInfo
+instance (signature ~ (Ptr () -> Word64 -> Word64 -> m Bool), MonadIO m, ClockK a) => MethodInfo ClockPeriodicIdReinitMethodInfo a signature where
+    overloadedMethod _ = clockPeriodicIdReinit
+
+-- method Clock::set_calibration
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Clock", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "internal", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "external", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "rate_num", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "rate_denom", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_clock_set_calibration" gst_clock_set_calibration :: 
+    Ptr Clock ->                            -- _obj : TInterface "Gst" "Clock"
+    Word64 ->                               -- internal : TBasicType TUInt64
+    Word64 ->                               -- external : TBasicType TUInt64
+    Word64 ->                               -- rate_num : TBasicType TUInt64
+    Word64 ->                               -- rate_denom : TBasicType TUInt64
+    IO ()
+
+
+clockSetCalibration ::
+    (MonadIO m, ClockK a) =>
+    a                                       -- _obj
+    -> Word64                               -- internal
+    -> Word64                               -- external
+    -> Word64                               -- rateNum
+    -> Word64                               -- rateDenom
+    -> m ()                                 -- result
+clockSetCalibration _obj internal external rateNum rateDenom = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    gst_clock_set_calibration _obj' internal external rateNum rateDenom
+    touchManagedPtr _obj
+    return ()
+
+data ClockSetCalibrationMethodInfo
+instance (signature ~ (Word64 -> Word64 -> Word64 -> Word64 -> m ()), MonadIO m, ClockK a) => MethodInfo ClockSetCalibrationMethodInfo a signature where
+    overloadedMethod _ = clockSetCalibration
+
+-- method Clock::set_master
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Clock", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "master", argType = TInterface "Gst" "Clock", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_clock_set_master" gst_clock_set_master :: 
+    Ptr Clock ->                            -- _obj : TInterface "Gst" "Clock"
+    Ptr Clock ->                            -- master : TInterface "Gst" "Clock"
+    IO CInt
+
+
+clockSetMaster ::
+    (MonadIO m, ClockK a, ClockK b) =>
+    a                                       -- _obj
+    -> Maybe (b)                            -- master
+    -> m Bool                               -- result
+clockSetMaster _obj master = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    maybeMaster <- case master of
+        Nothing -> return nullPtr
+        Just jMaster -> do
+            let jMaster' = unsafeManagedPtrCastPtr jMaster
+            return jMaster'
+    result <- gst_clock_set_master _obj' maybeMaster
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    whenJust master touchManagedPtr
+    return result'
+
+data ClockSetMasterMethodInfo
+instance (signature ~ (Maybe (b) -> m Bool), MonadIO m, ClockK a, ClockK b) => MethodInfo ClockSetMasterMethodInfo a signature where
+    overloadedMethod _ = clockSetMaster
+
+-- method Clock::set_resolution
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Clock", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "resolution", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUInt64
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_clock_set_resolution" gst_clock_set_resolution :: 
+    Ptr Clock ->                            -- _obj : TInterface "Gst" "Clock"
+    Word64 ->                               -- resolution : TBasicType TUInt64
+    IO Word64
+
+
+clockSetResolution ::
+    (MonadIO m, ClockK a) =>
+    a                                       -- _obj
+    -> Word64                               -- resolution
+    -> m Word64                             -- result
+clockSetResolution _obj resolution = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_clock_set_resolution _obj' resolution
+    touchManagedPtr _obj
+    return result
+
+data ClockSetResolutionMethodInfo
+instance (signature ~ (Word64 -> m Word64), MonadIO m, ClockK a) => MethodInfo ClockSetResolutionMethodInfo a signature where
+    overloadedMethod _ = clockSetResolution
+
+-- method Clock::set_synced
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Clock", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "synced", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_clock_set_synced" gst_clock_set_synced :: 
+    Ptr Clock ->                            -- _obj : TInterface "Gst" "Clock"
+    CInt ->                                 -- synced : TBasicType TBoolean
+    IO ()
+
+
+clockSetSynced ::
+    (MonadIO m, ClockK a) =>
+    a                                       -- _obj
+    -> Bool                                 -- synced
+    -> m ()                                 -- result
+clockSetSynced _obj synced = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let synced' = (fromIntegral . fromEnum) synced
+    gst_clock_set_synced _obj' synced'
+    touchManagedPtr _obj
+    return ()
+
+data ClockSetSyncedMethodInfo
+instance (signature ~ (Bool -> m ()), MonadIO m, ClockK a) => MethodInfo ClockSetSyncedMethodInfo a signature where
+    overloadedMethod _ = clockSetSynced
+
+-- method Clock::set_timeout
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Clock", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "timeout", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_clock_set_timeout" gst_clock_set_timeout :: 
+    Ptr Clock ->                            -- _obj : TInterface "Gst" "Clock"
+    Word64 ->                               -- timeout : TBasicType TUInt64
+    IO ()
+
+
+clockSetTimeout ::
+    (MonadIO m, ClockK a) =>
+    a                                       -- _obj
+    -> Word64                               -- timeout
+    -> m ()                                 -- result
+clockSetTimeout _obj timeout = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    gst_clock_set_timeout _obj' timeout
+    touchManagedPtr _obj
+    return ()
+
+data ClockSetTimeoutMethodInfo
+instance (signature ~ (Word64 -> m ()), MonadIO m, ClockK a) => MethodInfo ClockSetTimeoutMethodInfo a signature where
+    overloadedMethod _ = clockSetTimeout
+
+-- method Clock::single_shot_id_reinit
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Clock", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "id", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "time", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_clock_single_shot_id_reinit" gst_clock_single_shot_id_reinit :: 
+    Ptr Clock ->                            -- _obj : TInterface "Gst" "Clock"
+    Ptr () ->                               -- id : TBasicType TVoid
+    Word64 ->                               -- time : TBasicType TUInt64
+    IO CInt
+
+
+clockSingleShotIdReinit ::
+    (MonadIO m, ClockK a) =>
+    a                                       -- _obj
+    -> Ptr ()                               -- id
+    -> Word64                               -- time
+    -> m Bool                               -- result
+clockSingleShotIdReinit _obj id time = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_clock_single_shot_id_reinit _obj' id time
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data ClockSingleShotIdReinitMethodInfo
+instance (signature ~ (Ptr () -> Word64 -> m Bool), MonadIO m, ClockK a) => MethodInfo ClockSingleShotIdReinitMethodInfo a signature where
+    overloadedMethod _ = clockSingleShotIdReinit
+
+-- method Clock::unadjust_unlocked
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Clock", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "external", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUInt64
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_clock_unadjust_unlocked" gst_clock_unadjust_unlocked :: 
+    Ptr Clock ->                            -- _obj : TInterface "Gst" "Clock"
+    Word64 ->                               -- external : TBasicType TUInt64
+    IO Word64
+
+
+clockUnadjustUnlocked ::
+    (MonadIO m, ClockK a) =>
+    a                                       -- _obj
+    -> Word64                               -- external
+    -> m Word64                             -- result
+clockUnadjustUnlocked _obj external = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_clock_unadjust_unlocked _obj' external
+    touchManagedPtr _obj
+    return result
+
+data ClockUnadjustUnlockedMethodInfo
+instance (signature ~ (Word64 -> m Word64), MonadIO m, ClockK a) => MethodInfo ClockUnadjustUnlockedMethodInfo a signature where
+    overloadedMethod _ = clockUnadjustUnlocked
+
+-- method Clock::wait_for_sync
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Clock", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "timeout", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_clock_wait_for_sync" gst_clock_wait_for_sync :: 
+    Ptr Clock ->                            -- _obj : TInterface "Gst" "Clock"
+    Word64 ->                               -- timeout : TBasicType TUInt64
+    IO CInt
+
+
+clockWaitForSync ::
+    (MonadIO m, ClockK a) =>
+    a                                       -- _obj
+    -> Word64                               -- timeout
+    -> m Bool                               -- result
+clockWaitForSync _obj timeout = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_clock_wait_for_sync _obj' timeout
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data ClockWaitForSyncMethodInfo
+instance (signature ~ (Word64 -> m Bool), MonadIO m, ClockK a) => MethodInfo ClockWaitForSyncMethodInfo a signature where
+    overloadedMethod _ = clockWaitForSync
+
+-- method Clock::id_compare_func
+-- method type : MemberFunction
+-- Args : [Arg {argCName = "id1", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "id2", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TInt32
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_clock_id_compare_func" gst_clock_id_compare_func :: 
+    Ptr () ->                               -- id1 : TBasicType TVoid
+    Ptr () ->                               -- id2 : TBasicType TVoid
+    IO Int32
+
+
+clockIdCompareFunc ::
+    (MonadIO m) =>
+    Ptr ()                                  -- id1
+    -> Ptr ()                               -- id2
+    -> m Int32                              -- result
+clockIdCompareFunc id1 id2 = liftIO $ do
+    result <- gst_clock_id_compare_func id1 id2
+    return result
+
+-- method Clock::id_get_time
+-- method type : MemberFunction
+-- Args : [Arg {argCName = "id", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUInt64
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_clock_id_get_time" gst_clock_id_get_time :: 
+    Ptr () ->                               -- id : TBasicType TVoid
+    IO Word64
+
+
+clockIdGetTime ::
+    (MonadIO m) =>
+    Ptr ()                                  -- id
+    -> m Word64                             -- result
+clockIdGetTime id = liftIO $ do
+    result <- gst_clock_id_get_time id
+    return result
+
+-- method Clock::id_ref
+-- method type : MemberFunction
+-- Args : [Arg {argCName = "id", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_clock_id_ref" gst_clock_id_ref :: 
+    Ptr () ->                               -- id : TBasicType TVoid
+    IO ()
+
+
+clockIdRef ::
+    (MonadIO m) =>
+    Ptr ()                                  -- id
+    -> m ()                                 -- result
+clockIdRef id = liftIO $ do
+    gst_clock_id_ref id
+    return ()
+
+-- method Clock::id_unref
+-- method type : MemberFunction
+-- Args : [Arg {argCName = "id", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_clock_id_unref" gst_clock_id_unref :: 
+    Ptr () ->                               -- id : TBasicType TVoid
+    IO ()
+
+
+clockIdUnref ::
+    (MonadIO m) =>
+    Ptr ()                                  -- id
+    -> m ()                                 -- result
+clockIdUnref id = liftIO $ do
+    gst_clock_id_unref id
+    return ()
+
+-- method Clock::id_unschedule
+-- method type : MemberFunction
+-- Args : [Arg {argCName = "id", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_clock_id_unschedule" gst_clock_id_unschedule :: 
+    Ptr () ->                               -- id : TBasicType TVoid
+    IO ()
+
+
+clockIdUnschedule ::
+    (MonadIO m) =>
+    Ptr ()                                  -- id
+    -> m ()                                 -- result
+clockIdUnschedule id = liftIO $ do
+    gst_clock_id_unschedule id
+    return ()
+
+-- method Clock::id_wait
+-- method type : MemberFunction
+-- Args : [Arg {argCName = "id", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "jitter", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "ClockReturn"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_clock_id_wait" gst_clock_id_wait :: 
+    Ptr () ->                               -- id : TBasicType TVoid
+    Ptr Int64 ->                            -- jitter : TBasicType TInt64
+    IO CUInt
+
+
+clockIdWait ::
+    (MonadIO m) =>
+    Ptr ()                                  -- id
+    -> m (ClockReturn,Int64)                -- result
+clockIdWait id = liftIO $ do
+    jitter <- allocMem :: IO (Ptr Int64)
+    result <- gst_clock_id_wait id jitter
+    let result' = (toEnum . fromIntegral) result
+    jitter' <- peek jitter
+    freeMem jitter
+    return (result', jitter')
+
+-- method Clock::id_wait_async
+-- method type : MemberFunction
+-- Args : [Arg {argCName = "id", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "func", argType = TInterface "Gst" "ClockCallback", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "destroy_data", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "ClockReturn"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_clock_id_wait_async" gst_clock_id_wait_async :: 
+    Ptr () ->                               -- id : TBasicType TVoid
+    FunPtr ClockCallbackC ->                -- func : TInterface "Gst" "ClockCallback"
+    Ptr () ->                               -- user_data : TBasicType TVoid
+    FunPtr GLib.DestroyNotifyC ->           -- destroy_data : TInterface "GLib" "DestroyNotify"
+    IO CUInt
+
+
+clockIdWaitAsync ::
+    (MonadIO m) =>
+    Ptr ()                                  -- id
+    -> ClockCallback                        -- func
+    -> m ClockReturn                        -- result
+clockIdWaitAsync id func = liftIO $ do
+    func' <- mkClockCallback (clockCallbackWrapper Nothing func)
+    let userData = castFunPtrToPtr func'
+    let destroyData = safeFreeFunPtrPtr
+    result <- gst_clock_id_wait_async id func' userData destroyData
+    let result' = (toEnum . fromIntegral) result
+    return result'
+
+
diff --git a/GI/Gst/Objects/Clock.hs-boot b/GI/Gst/Objects/Clock.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Objects/Clock.hs-boot
@@ -0,0 +1,39 @@
+module GI.Gst.Objects.Clock where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+newtype Clock = Clock (ForeignPtr Clock)
+instance GObject Clock where
+class GObject o => ClockK o
+instance (GObject o, IsDescendantOf Clock o) => ClockK o
+data ClockTimeoutPropertyInfo
+data ClockWindowSizePropertyInfo
+data ClockWindowThresholdPropertyInfo
+data ClockSyncedSignalInfo
+data ClockAddObservationMethodInfo
+data ClockAddObservationUnappliedMethodInfo
+data ClockAdjustUnlockedMethodInfo
+data ClockAdjustWithCalibrationMethodInfo
+data ClockGetCalibrationMethodInfo
+data ClockGetInternalTimeMethodInfo
+data ClockGetMasterMethodInfo
+data ClockGetResolutionMethodInfo
+data ClockGetTimeMethodInfo
+data ClockGetTimeoutMethodInfo
+data ClockIsSyncedMethodInfo
+data ClockNewPeriodicIdMethodInfo
+data ClockNewSingleShotIdMethodInfo
+data ClockPeriodicIdReinitMethodInfo
+data ClockSetCalibrationMethodInfo
+data ClockSetMasterMethodInfo
+data ClockSetResolutionMethodInfo
+data ClockSetSyncedMethodInfo
+data ClockSetTimeoutMethodInfo
+data ClockSingleShotIdReinitMethodInfo
+data ClockUnadjustUnlockedMethodInfo
+data ClockWaitForSyncMethodInfo
diff --git a/GI/Gst/Objects/ControlBinding.hs b/GI/Gst/Objects/ControlBinding.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Objects/ControlBinding.hs
@@ -0,0 +1,365 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+-}
+
+module GI.Gst.Objects.ControlBinding
+    ( 
+
+-- * Exported types
+    ControlBinding(..)                      ,
+    ControlBindingK                         ,
+    toControlBinding                        ,
+    noControlBinding                        ,
+
+
+ -- * Methods
+-- ** controlBindingGetGValueArray
+    ControlBindingGetGValueArrayMethodInfo  ,
+    controlBindingGetGValueArray            ,
+
+
+-- ** controlBindingGetValue
+    ControlBindingGetValueMethodInfo        ,
+    controlBindingGetValue                  ,
+
+
+-- ** controlBindingIsDisabled
+    ControlBindingIsDisabledMethodInfo      ,
+    controlBindingIsDisabled                ,
+
+
+-- ** controlBindingSetDisabled
+    ControlBindingSetDisabledMethodInfo     ,
+    controlBindingSetDisabled               ,
+
+
+-- ** controlBindingSyncValues
+    ControlBindingSyncValuesMethodInfo      ,
+    controlBindingSyncValues                ,
+
+
+
+
+ -- * Properties
+-- ** Name
+    ControlBindingNamePropertyInfo          ,
+    constructControlBindingName             ,
+    getControlBindingName                   ,
+
+
+-- ** Object
+    ControlBindingObjectPropertyInfo        ,
+    constructControlBindingObject           ,
+    getControlBindingObject                 ,
+
+
+
+
+    ) where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+import GI.Gst.Callbacks
+import qualified GI.GObject as GObject
+
+newtype ControlBinding = ControlBinding (ForeignPtr ControlBinding)
+foreign import ccall "gst_control_binding_get_type"
+    c_gst_control_binding_get_type :: IO GType
+
+type instance ParentTypes ControlBinding = ControlBindingParentTypes
+type ControlBindingParentTypes = '[Object, GObject.Object]
+
+instance GObject ControlBinding where
+    gobjectIsInitiallyUnowned _ = True
+    gobjectType _ = c_gst_control_binding_get_type
+    
+
+class GObject o => ControlBindingK o
+instance (GObject o, IsDescendantOf ControlBinding o) => ControlBindingK o
+
+toControlBinding :: ControlBindingK o => o -> IO ControlBinding
+toControlBinding = unsafeCastTo ControlBinding
+
+noControlBinding :: Maybe ControlBinding
+noControlBinding = Nothing
+
+type family ResolveControlBindingMethod (t :: Symbol) (o :: *) :: * where
+    ResolveControlBindingMethod "addControlBinding" o = ObjectAddControlBindingMethodInfo
+    ResolveControlBindingMethod "bindProperty" o = GObject.ObjectBindPropertyMethodInfo
+    ResolveControlBindingMethod "bindPropertyFull" o = GObject.ObjectBindPropertyFullMethodInfo
+    ResolveControlBindingMethod "defaultError" o = ObjectDefaultErrorMethodInfo
+    ResolveControlBindingMethod "forceFloating" o = GObject.ObjectForceFloatingMethodInfo
+    ResolveControlBindingMethod "freezeNotify" o = GObject.ObjectFreezeNotifyMethodInfo
+    ResolveControlBindingMethod "hasActiveControlBindings" o = ObjectHasActiveControlBindingsMethodInfo
+    ResolveControlBindingMethod "hasAncestor" o = ObjectHasAncestorMethodInfo
+    ResolveControlBindingMethod "hasAsAncestor" o = ObjectHasAsAncestorMethodInfo
+    ResolveControlBindingMethod "hasAsParent" o = ObjectHasAsParentMethodInfo
+    ResolveControlBindingMethod "isDisabled" o = ControlBindingIsDisabledMethodInfo
+    ResolveControlBindingMethod "isFloating" o = GObject.ObjectIsFloatingMethodInfo
+    ResolveControlBindingMethod "notify" o = GObject.ObjectNotifyMethodInfo
+    ResolveControlBindingMethod "notifyByPspec" o = GObject.ObjectNotifyByPspecMethodInfo
+    ResolveControlBindingMethod "refSink" o = GObject.ObjectRefSinkMethodInfo
+    ResolveControlBindingMethod "removeControlBinding" o = ObjectRemoveControlBindingMethodInfo
+    ResolveControlBindingMethod "replaceData" o = GObject.ObjectReplaceDataMethodInfo
+    ResolveControlBindingMethod "replaceQdata" o = GObject.ObjectReplaceQdataMethodInfo
+    ResolveControlBindingMethod "runDispose" o = GObject.ObjectRunDisposeMethodInfo
+    ResolveControlBindingMethod "stealData" o = GObject.ObjectStealDataMethodInfo
+    ResolveControlBindingMethod "stealQdata" o = GObject.ObjectStealQdataMethodInfo
+    ResolveControlBindingMethod "suggestNextSync" o = ObjectSuggestNextSyncMethodInfo
+    ResolveControlBindingMethod "thawNotify" o = GObject.ObjectThawNotifyMethodInfo
+    ResolveControlBindingMethod "unparent" o = ObjectUnparentMethodInfo
+    ResolveControlBindingMethod "watchClosure" o = GObject.ObjectWatchClosureMethodInfo
+    ResolveControlBindingMethod "getControlBinding" o = ObjectGetControlBindingMethodInfo
+    ResolveControlBindingMethod "getControlRate" o = ObjectGetControlRateMethodInfo
+    ResolveControlBindingMethod "getData" o = GObject.ObjectGetDataMethodInfo
+    ResolveControlBindingMethod "getName" o = ObjectGetNameMethodInfo
+    ResolveControlBindingMethod "getParent" o = ObjectGetParentMethodInfo
+    ResolveControlBindingMethod "getPathString" o = ObjectGetPathStringMethodInfo
+    ResolveControlBindingMethod "getProperty" o = GObject.ObjectGetPropertyMethodInfo
+    ResolveControlBindingMethod "getQdata" o = GObject.ObjectGetQdataMethodInfo
+    ResolveControlBindingMethod "getValueArray" o = ObjectGetValueArrayMethodInfo
+    ResolveControlBindingMethod "setControlBindingDisabled" o = ObjectSetControlBindingDisabledMethodInfo
+    ResolveControlBindingMethod "setControlBindingsDisabled" o = ObjectSetControlBindingsDisabledMethodInfo
+    ResolveControlBindingMethod "setControlRate" o = ObjectSetControlRateMethodInfo
+    ResolveControlBindingMethod "setData" o = GObject.ObjectSetDataMethodInfo
+    ResolveControlBindingMethod "setDisabled" o = ControlBindingSetDisabledMethodInfo
+    ResolveControlBindingMethod "setName" o = ObjectSetNameMethodInfo
+    ResolveControlBindingMethod "setParent" o = ObjectSetParentMethodInfo
+    ResolveControlBindingMethod "setProperty" o = GObject.ObjectSetPropertyMethodInfo
+    ResolveControlBindingMethod l o = MethodResolutionFailed l o
+
+instance (info ~ ResolveControlBindingMethod t ControlBinding, MethodInfo info ControlBinding p) => IsLabelProxy t (ControlBinding -> p) where
+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)
+
+#if MIN_VERSION_base(4,9,0)
+instance (info ~ ResolveControlBindingMethod t ControlBinding, MethodInfo info ControlBinding p) => IsLabel t (ControlBinding -> p) where
+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)
+#endif
+
+--- XXX Duplicated object with different types:
+  --- Name {namespace = "Gst", name = "ControlBinding"} -> Property {propName = "name", propType = TBasicType TUTF8, propFlags = [PropertyReadable,PropertyWritable,PropertyConstructOnly], propTransfer = TransferNothing, propDeprecated = Nothing}
+  --- Name {namespace = "Gst", name = "Object"} -> Property {propName = "name", propType = TBasicType TUTF8, propFlags = [PropertyReadable,PropertyWritable,PropertyConstruct], propTransfer = TransferNothing, propDeprecated = Nothing}
+-- VVV Prop "name"
+   -- Type: TBasicType TUTF8
+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
+
+getControlBindingName :: (MonadIO m, ControlBindingK o) => o -> m T.Text
+getControlBindingName obj = liftIO $ getObjectPropertyString obj "name"
+
+constructControlBindingName :: T.Text -> IO ([Char], GValue)
+constructControlBindingName val = constructObjectPropertyString "name" val
+
+data ControlBindingNamePropertyInfo
+instance AttrInfo ControlBindingNamePropertyInfo where
+    type AttrAllowedOps ControlBindingNamePropertyInfo = '[ 'AttrConstruct, 'AttrGet]
+    type AttrSetTypeConstraint ControlBindingNamePropertyInfo = (~) T.Text
+    type AttrBaseTypeConstraint ControlBindingNamePropertyInfo = ControlBindingK
+    type AttrGetType ControlBindingNamePropertyInfo = T.Text
+    type AttrLabel ControlBindingNamePropertyInfo = "name"
+    attrGet _ = getControlBindingName
+    attrSet _ = undefined
+    attrConstruct _ = constructControlBindingName
+
+-- VVV Prop "object"
+   -- Type: TInterface "Gst" "Object"
+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
+
+getControlBindingObject :: (MonadIO m, ControlBindingK o) => o -> m Object
+getControlBindingObject obj = liftIO $ getObjectPropertyObject obj "object" Object
+
+constructControlBindingObject :: (ObjectK a) => a -> IO ([Char], GValue)
+constructControlBindingObject val = constructObjectPropertyObject "object" val
+
+data ControlBindingObjectPropertyInfo
+instance AttrInfo ControlBindingObjectPropertyInfo where
+    type AttrAllowedOps ControlBindingObjectPropertyInfo = '[ 'AttrConstruct, 'AttrGet]
+    type AttrSetTypeConstraint ControlBindingObjectPropertyInfo = ObjectK
+    type AttrBaseTypeConstraint ControlBindingObjectPropertyInfo = ControlBindingK
+    type AttrGetType ControlBindingObjectPropertyInfo = Object
+    type AttrLabel ControlBindingObjectPropertyInfo = "object"
+    attrGet _ = getControlBindingObject
+    attrSet _ = undefined
+    attrConstruct _ = constructControlBindingObject
+
+type instance AttributeList ControlBinding = ControlBindingAttributeList
+type ControlBindingAttributeList = ('[ '("object", ControlBindingObjectPropertyInfo), '("parent", ObjectParentPropertyInfo)] :: [(Symbol, *)])
+
+type instance SignalList ControlBinding = ControlBindingSignalList
+type ControlBindingSignalList = ('[ '("deepNotify", ObjectDeepNotifySignalInfo), '("notify", GObject.ObjectNotifySignalInfo)] :: [(Symbol, *)])
+
+-- method ControlBinding::get_g_value_array
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "ControlBinding", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "timestamp", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "interval", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_values", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "values", argType = TCArray False (-1) 3 (TInterface "GObject" "Value"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : [Arg {argCName = "n_values", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_control_binding_get_g_value_array" gst_control_binding_get_g_value_array :: 
+    Ptr ControlBinding ->                   -- _obj : TInterface "Gst" "ControlBinding"
+    Word64 ->                               -- timestamp : TBasicType TUInt64
+    Word64 ->                               -- interval : TBasicType TUInt64
+    Word32 ->                               -- n_values : TBasicType TUInt32
+    Ptr GValue ->                           -- values : TCArray False (-1) 3 (TInterface "GObject" "Value")
+    IO CInt
+
+
+controlBindingGetGValueArray ::
+    (MonadIO m, ControlBindingK a) =>
+    a                                       -- _obj
+    -> Word64                               -- timestamp
+    -> Word64                               -- interval
+    -> [GValue]                             -- values
+    -> m Bool                               -- result
+controlBindingGetGValueArray _obj timestamp interval values = liftIO $ do
+    let nValues = fromIntegral $ length values
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let values' = map unsafeManagedPtrGetPtr values
+    values'' <- packBlockArray 24 values'
+    result <- gst_control_binding_get_g_value_array _obj' timestamp interval nValues values''
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    mapM_ touchManagedPtr values
+    freeMem values''
+    return result'
+
+data ControlBindingGetGValueArrayMethodInfo
+instance (signature ~ (Word64 -> Word64 -> [GValue] -> m Bool), MonadIO m, ControlBindingK a) => MethodInfo ControlBindingGetGValueArrayMethodInfo a signature where
+    overloadedMethod _ = controlBindingGetGValueArray
+
+-- method ControlBinding::get_value
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "ControlBinding", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "timestamp", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "GObject" "Value"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_control_binding_get_value" gst_control_binding_get_value :: 
+    Ptr ControlBinding ->                   -- _obj : TInterface "Gst" "ControlBinding"
+    Word64 ->                               -- timestamp : TBasicType TUInt64
+    IO (Ptr GValue)
+
+
+controlBindingGetValue ::
+    (MonadIO m, ControlBindingK a) =>
+    a                                       -- _obj
+    -> Word64                               -- timestamp
+    -> m GValue                             -- result
+controlBindingGetValue _obj timestamp = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_control_binding_get_value _obj' timestamp
+    checkUnexpectedReturnNULL "gst_control_binding_get_value" result
+    result' <- (wrapBoxed GValue) result
+    touchManagedPtr _obj
+    return result'
+
+data ControlBindingGetValueMethodInfo
+instance (signature ~ (Word64 -> m GValue), MonadIO m, ControlBindingK a) => MethodInfo ControlBindingGetValueMethodInfo a signature where
+    overloadedMethod _ = controlBindingGetValue
+
+-- method ControlBinding::is_disabled
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "ControlBinding", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_control_binding_is_disabled" gst_control_binding_is_disabled :: 
+    Ptr ControlBinding ->                   -- _obj : TInterface "Gst" "ControlBinding"
+    IO CInt
+
+
+controlBindingIsDisabled ::
+    (MonadIO m, ControlBindingK a) =>
+    a                                       -- _obj
+    -> m Bool                               -- result
+controlBindingIsDisabled _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_control_binding_is_disabled _obj'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data ControlBindingIsDisabledMethodInfo
+instance (signature ~ (m Bool), MonadIO m, ControlBindingK a) => MethodInfo ControlBindingIsDisabledMethodInfo a signature where
+    overloadedMethod _ = controlBindingIsDisabled
+
+-- method ControlBinding::set_disabled
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "ControlBinding", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "disabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_control_binding_set_disabled" gst_control_binding_set_disabled :: 
+    Ptr ControlBinding ->                   -- _obj : TInterface "Gst" "ControlBinding"
+    CInt ->                                 -- disabled : TBasicType TBoolean
+    IO ()
+
+
+controlBindingSetDisabled ::
+    (MonadIO m, ControlBindingK a) =>
+    a                                       -- _obj
+    -> Bool                                 -- disabled
+    -> m ()                                 -- result
+controlBindingSetDisabled _obj disabled = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let disabled' = (fromIntegral . fromEnum) disabled
+    gst_control_binding_set_disabled _obj' disabled'
+    touchManagedPtr _obj
+    return ()
+
+data ControlBindingSetDisabledMethodInfo
+instance (signature ~ (Bool -> m ()), MonadIO m, ControlBindingK a) => MethodInfo ControlBindingSetDisabledMethodInfo a signature where
+    overloadedMethod _ = controlBindingSetDisabled
+
+-- method ControlBinding::sync_values
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "ControlBinding", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "object", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "timestamp", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "last_sync", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_control_binding_sync_values" gst_control_binding_sync_values :: 
+    Ptr ControlBinding ->                   -- _obj : TInterface "Gst" "ControlBinding"
+    Ptr Object ->                           -- object : TInterface "Gst" "Object"
+    Word64 ->                               -- timestamp : TBasicType TUInt64
+    Word64 ->                               -- last_sync : TBasicType TUInt64
+    IO CInt
+
+
+controlBindingSyncValues ::
+    (MonadIO m, ControlBindingK a, ObjectK b) =>
+    a                                       -- _obj
+    -> b                                    -- object
+    -> Word64                               -- timestamp
+    -> Word64                               -- lastSync
+    -> m Bool                               -- result
+controlBindingSyncValues _obj object timestamp lastSync = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let object' = unsafeManagedPtrCastPtr object
+    result <- gst_control_binding_sync_values _obj' object' timestamp lastSync
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    touchManagedPtr object
+    return result'
+
+data ControlBindingSyncValuesMethodInfo
+instance (signature ~ (b -> Word64 -> Word64 -> m Bool), MonadIO m, ControlBindingK a, ObjectK b) => MethodInfo ControlBindingSyncValuesMethodInfo a signature where
+    overloadedMethod _ = controlBindingSyncValues
+
+
diff --git a/GI/Gst/Objects/ControlBinding.hs-boot b/GI/Gst/Objects/ControlBinding.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Objects/ControlBinding.hs-boot
@@ -0,0 +1,20 @@
+module GI.Gst.Objects.ControlBinding where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+newtype ControlBinding = ControlBinding (ForeignPtr ControlBinding)
+instance GObject ControlBinding where
+class GObject o => ControlBindingK o
+instance (GObject o, IsDescendantOf ControlBinding o) => ControlBindingK o
+data ControlBindingNamePropertyInfo
+data ControlBindingObjectPropertyInfo
+data ControlBindingGetGValueArrayMethodInfo
+data ControlBindingGetValueMethodInfo
+data ControlBindingIsDisabledMethodInfo
+data ControlBindingSetDisabledMethodInfo
+data ControlBindingSyncValuesMethodInfo
diff --git a/GI/Gst/Objects/ControlSource.hs b/GI/Gst/Objects/ControlSource.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Objects/ControlSource.hs
@@ -0,0 +1,199 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+-}
+
+module GI.Gst.Objects.ControlSource
+    ( 
+
+-- * Exported types
+    ControlSource(..)                       ,
+    ControlSourceK                          ,
+    toControlSource                         ,
+    noControlSource                         ,
+
+
+ -- * Methods
+-- ** controlSourceControlSourceGetValue
+    ControlSourceControlSourceGetValueMethodInfo,
+    controlSourceControlSourceGetValue      ,
+
+
+-- ** controlSourceControlSourceGetValueArray
+    ControlSourceControlSourceGetValueArrayMethodInfo,
+    controlSourceControlSourceGetValueArray ,
+
+
+
+
+    ) where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+import GI.Gst.Callbacks
+import qualified GI.GObject as GObject
+
+newtype ControlSource = ControlSource (ForeignPtr ControlSource)
+foreign import ccall "gst_control_source_get_type"
+    c_gst_control_source_get_type :: IO GType
+
+type instance ParentTypes ControlSource = ControlSourceParentTypes
+type ControlSourceParentTypes = '[Object, GObject.Object]
+
+instance GObject ControlSource where
+    gobjectIsInitiallyUnowned _ = True
+    gobjectType _ = c_gst_control_source_get_type
+    
+
+class GObject o => ControlSourceK o
+instance (GObject o, IsDescendantOf ControlSource o) => ControlSourceK o
+
+toControlSource :: ControlSourceK o => o -> IO ControlSource
+toControlSource = unsafeCastTo ControlSource
+
+noControlSource :: Maybe ControlSource
+noControlSource = Nothing
+
+type family ResolveControlSourceMethod (t :: Symbol) (o :: *) :: * where
+    ResolveControlSourceMethod "addControlBinding" o = ObjectAddControlBindingMethodInfo
+    ResolveControlSourceMethod "bindProperty" o = GObject.ObjectBindPropertyMethodInfo
+    ResolveControlSourceMethod "bindPropertyFull" o = GObject.ObjectBindPropertyFullMethodInfo
+    ResolveControlSourceMethod "controlSourceGetValue" o = ControlSourceControlSourceGetValueMethodInfo
+    ResolveControlSourceMethod "controlSourceGetValueArray" o = ControlSourceControlSourceGetValueArrayMethodInfo
+    ResolveControlSourceMethod "defaultError" o = ObjectDefaultErrorMethodInfo
+    ResolveControlSourceMethod "forceFloating" o = GObject.ObjectForceFloatingMethodInfo
+    ResolveControlSourceMethod "freezeNotify" o = GObject.ObjectFreezeNotifyMethodInfo
+    ResolveControlSourceMethod "hasActiveControlBindings" o = ObjectHasActiveControlBindingsMethodInfo
+    ResolveControlSourceMethod "hasAncestor" o = ObjectHasAncestorMethodInfo
+    ResolveControlSourceMethod "hasAsAncestor" o = ObjectHasAsAncestorMethodInfo
+    ResolveControlSourceMethod "hasAsParent" o = ObjectHasAsParentMethodInfo
+    ResolveControlSourceMethod "isFloating" o = GObject.ObjectIsFloatingMethodInfo
+    ResolveControlSourceMethod "notify" o = GObject.ObjectNotifyMethodInfo
+    ResolveControlSourceMethod "notifyByPspec" o = GObject.ObjectNotifyByPspecMethodInfo
+    ResolveControlSourceMethod "refSink" o = GObject.ObjectRefSinkMethodInfo
+    ResolveControlSourceMethod "removeControlBinding" o = ObjectRemoveControlBindingMethodInfo
+    ResolveControlSourceMethod "replaceData" o = GObject.ObjectReplaceDataMethodInfo
+    ResolveControlSourceMethod "replaceQdata" o = GObject.ObjectReplaceQdataMethodInfo
+    ResolveControlSourceMethod "runDispose" o = GObject.ObjectRunDisposeMethodInfo
+    ResolveControlSourceMethod "stealData" o = GObject.ObjectStealDataMethodInfo
+    ResolveControlSourceMethod "stealQdata" o = GObject.ObjectStealQdataMethodInfo
+    ResolveControlSourceMethod "suggestNextSync" o = ObjectSuggestNextSyncMethodInfo
+    ResolveControlSourceMethod "syncValues" o = ObjectSyncValuesMethodInfo
+    ResolveControlSourceMethod "thawNotify" o = GObject.ObjectThawNotifyMethodInfo
+    ResolveControlSourceMethod "unparent" o = ObjectUnparentMethodInfo
+    ResolveControlSourceMethod "watchClosure" o = GObject.ObjectWatchClosureMethodInfo
+    ResolveControlSourceMethod "getControlBinding" o = ObjectGetControlBindingMethodInfo
+    ResolveControlSourceMethod "getControlRate" o = ObjectGetControlRateMethodInfo
+    ResolveControlSourceMethod "getData" o = GObject.ObjectGetDataMethodInfo
+    ResolveControlSourceMethod "getGValueArray" o = ObjectGetGValueArrayMethodInfo
+    ResolveControlSourceMethod "getName" o = ObjectGetNameMethodInfo
+    ResolveControlSourceMethod "getParent" o = ObjectGetParentMethodInfo
+    ResolveControlSourceMethod "getPathString" o = ObjectGetPathStringMethodInfo
+    ResolveControlSourceMethod "getProperty" o = GObject.ObjectGetPropertyMethodInfo
+    ResolveControlSourceMethod "getQdata" o = GObject.ObjectGetQdataMethodInfo
+    ResolveControlSourceMethod "getValue" o = ObjectGetValueMethodInfo
+    ResolveControlSourceMethod "getValueArray" o = ObjectGetValueArrayMethodInfo
+    ResolveControlSourceMethod "setControlBindingDisabled" o = ObjectSetControlBindingDisabledMethodInfo
+    ResolveControlSourceMethod "setControlBindingsDisabled" o = ObjectSetControlBindingsDisabledMethodInfo
+    ResolveControlSourceMethod "setControlRate" o = ObjectSetControlRateMethodInfo
+    ResolveControlSourceMethod "setData" o = GObject.ObjectSetDataMethodInfo
+    ResolveControlSourceMethod "setName" o = ObjectSetNameMethodInfo
+    ResolveControlSourceMethod "setParent" o = ObjectSetParentMethodInfo
+    ResolveControlSourceMethod "setProperty" o = GObject.ObjectSetPropertyMethodInfo
+    ResolveControlSourceMethod l o = MethodResolutionFailed l o
+
+instance (info ~ ResolveControlSourceMethod t ControlSource, MethodInfo info ControlSource p) => IsLabelProxy t (ControlSource -> p) where
+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)
+
+#if MIN_VERSION_base(4,9,0)
+instance (info ~ ResolveControlSourceMethod t ControlSource, MethodInfo info ControlSource p) => IsLabel t (ControlSource -> p) where
+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)
+#endif
+
+type instance AttributeList ControlSource = ControlSourceAttributeList
+type ControlSourceAttributeList = ('[ '("name", ObjectNamePropertyInfo), '("parent", ObjectParentPropertyInfo)] :: [(Symbol, *)])
+
+type instance SignalList ControlSource = ControlSourceSignalList
+type ControlSourceSignalList = ('[ '("deepNotify", ObjectDeepNotifySignalInfo), '("notify", GObject.ObjectNotifySignalInfo)] :: [(Symbol, *)])
+
+-- method ControlSource::control_source_get_value
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "ControlSource", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "timestamp", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_control_source_get_value" gst_control_source_get_value :: 
+    Ptr ControlSource ->                    -- _obj : TInterface "Gst" "ControlSource"
+    Word64 ->                               -- timestamp : TBasicType TUInt64
+    CDouble ->                              -- value : TBasicType TDouble
+    IO CInt
+
+
+controlSourceControlSourceGetValue ::
+    (MonadIO m, ControlSourceK a) =>
+    a                                       -- _obj
+    -> Word64                               -- timestamp
+    -> Double                               -- value
+    -> m Bool                               -- result
+controlSourceControlSourceGetValue _obj timestamp value = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let value' = realToFrac value
+    result <- gst_control_source_get_value _obj' timestamp value'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data ControlSourceControlSourceGetValueMethodInfo
+instance (signature ~ (Word64 -> Double -> m Bool), MonadIO m, ControlSourceK a) => MethodInfo ControlSourceControlSourceGetValueMethodInfo a signature where
+    overloadedMethod _ = controlSourceControlSourceGetValue
+
+-- method ControlSource::control_source_get_value_array
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "ControlSource", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "timestamp", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "interval", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_values", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "values", argType = TCArray False (-1) 3 (TBasicType TDouble), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : [Arg {argCName = "n_values", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_control_source_get_value_array" gst_control_source_get_value_array :: 
+    Ptr ControlSource ->                    -- _obj : TInterface "Gst" "ControlSource"
+    Word64 ->                               -- timestamp : TBasicType TUInt64
+    Word64 ->                               -- interval : TBasicType TUInt64
+    Word32 ->                               -- n_values : TBasicType TUInt32
+    Ptr CDouble ->                          -- values : TCArray False (-1) 3 (TBasicType TDouble)
+    IO CInt
+
+
+controlSourceControlSourceGetValueArray ::
+    (MonadIO m, ControlSourceK a) =>
+    a                                       -- _obj
+    -> Word64                               -- timestamp
+    -> Word64                               -- interval
+    -> [Double]                             -- values
+    -> m Bool                               -- result
+controlSourceControlSourceGetValueArray _obj timestamp interval values = liftIO $ do
+    let nValues = fromIntegral $ length values
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    values' <- (packMapStorableArray realToFrac) values
+    result <- gst_control_source_get_value_array _obj' timestamp interval nValues values'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    freeMem values'
+    return result'
+
+data ControlSourceControlSourceGetValueArrayMethodInfo
+instance (signature ~ (Word64 -> Word64 -> [Double] -> m Bool), MonadIO m, ControlSourceK a) => MethodInfo ControlSourceControlSourceGetValueArrayMethodInfo a signature where
+    overloadedMethod _ = controlSourceControlSourceGetValueArray
+
+
diff --git a/GI/Gst/Objects/ControlSource.hs-boot b/GI/Gst/Objects/ControlSource.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Objects/ControlSource.hs-boot
@@ -0,0 +1,15 @@
+module GI.Gst.Objects.ControlSource where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+newtype ControlSource = ControlSource (ForeignPtr ControlSource)
+instance GObject ControlSource where
+class GObject o => ControlSourceK o
+instance (GObject o, IsDescendantOf ControlSource o) => ControlSourceK o
+data ControlSourceControlSourceGetValueMethodInfo
+data ControlSourceControlSourceGetValueArrayMethodInfo
diff --git a/GI/Gst/Objects/Device.hs b/GI/Gst/Objects/Device.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Objects/Device.hs
@@ -0,0 +1,585 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+-}
+
+module GI.Gst.Objects.Device
+    ( 
+
+-- * Exported types
+    Device(..)                              ,
+    DeviceK                                 ,
+    toDevice                                ,
+    noDevice                                ,
+
+
+ -- * Methods
+-- ** deviceCreateElement
+    DeviceCreateElementMethodInfo           ,
+    deviceCreateElement                     ,
+
+
+-- ** deviceGetCaps
+    DeviceGetCapsMethodInfo                 ,
+    deviceGetCaps                           ,
+
+
+-- ** deviceGetDeviceClass
+    DeviceGetDeviceClassMethodInfo          ,
+    deviceGetDeviceClass                    ,
+
+
+-- ** deviceGetDisplayName
+    DeviceGetDisplayNameMethodInfo          ,
+    deviceGetDisplayName                    ,
+
+
+-- ** deviceGetProperties
+    DeviceGetPropertiesMethodInfo           ,
+    deviceGetProperties                     ,
+
+
+-- ** deviceHasClasses
+    DeviceHasClassesMethodInfo              ,
+    deviceHasClasses                        ,
+
+
+-- ** deviceHasClassesv
+    DeviceHasClassesvMethodInfo             ,
+    deviceHasClassesv                       ,
+
+
+-- ** deviceReconfigureElement
+    DeviceReconfigureElementMethodInfo      ,
+    deviceReconfigureElement                ,
+
+
+
+
+ -- * Properties
+-- ** Caps
+    DeviceCapsPropertyInfo                  ,
+    constructDeviceCaps                     ,
+    getDeviceCaps                           ,
+
+
+-- ** DeviceClass
+    DeviceDeviceClassPropertyInfo           ,
+    constructDeviceDeviceClass              ,
+    getDeviceDeviceClass                    ,
+
+
+-- ** DisplayName
+    DeviceDisplayNamePropertyInfo           ,
+    constructDeviceDisplayName              ,
+    getDeviceDisplayName                    ,
+
+
+-- ** Properties
+    DevicePropertiesPropertyInfo            ,
+    constructDeviceProperties               ,
+    getDeviceProperties                     ,
+
+
+
+
+ -- * Signals
+-- ** Removed
+    DeviceRemovedCallback                   ,
+    DeviceRemovedCallbackC                  ,
+    DeviceRemovedSignalInfo                 ,
+    afterDeviceRemoved                      ,
+    deviceRemovedCallbackWrapper            ,
+    deviceRemovedClosure                    ,
+    mkDeviceRemovedCallback                 ,
+    noDeviceRemovedCallback                 ,
+    onDeviceRemoved                         ,
+
+
+
+
+    ) where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+import GI.Gst.Callbacks
+import qualified GI.GObject as GObject
+
+newtype Device = Device (ForeignPtr Device)
+foreign import ccall "gst_device_get_type"
+    c_gst_device_get_type :: IO GType
+
+type instance ParentTypes Device = DeviceParentTypes
+type DeviceParentTypes = '[Object, GObject.Object]
+
+instance GObject Device where
+    gobjectIsInitiallyUnowned _ = True
+    gobjectType _ = c_gst_device_get_type
+    
+
+class GObject o => DeviceK o
+instance (GObject o, IsDescendantOf Device o) => DeviceK o
+
+toDevice :: DeviceK o => o -> IO Device
+toDevice = unsafeCastTo Device
+
+noDevice :: Maybe Device
+noDevice = Nothing
+
+type family ResolveDeviceMethod (t :: Symbol) (o :: *) :: * where
+    ResolveDeviceMethod "addControlBinding" o = ObjectAddControlBindingMethodInfo
+    ResolveDeviceMethod "bindProperty" o = GObject.ObjectBindPropertyMethodInfo
+    ResolveDeviceMethod "bindPropertyFull" o = GObject.ObjectBindPropertyFullMethodInfo
+    ResolveDeviceMethod "createElement" o = DeviceCreateElementMethodInfo
+    ResolveDeviceMethod "defaultError" o = ObjectDefaultErrorMethodInfo
+    ResolveDeviceMethod "forceFloating" o = GObject.ObjectForceFloatingMethodInfo
+    ResolveDeviceMethod "freezeNotify" o = GObject.ObjectFreezeNotifyMethodInfo
+    ResolveDeviceMethod "hasActiveControlBindings" o = ObjectHasActiveControlBindingsMethodInfo
+    ResolveDeviceMethod "hasAncestor" o = ObjectHasAncestorMethodInfo
+    ResolveDeviceMethod "hasAsAncestor" o = ObjectHasAsAncestorMethodInfo
+    ResolveDeviceMethod "hasAsParent" o = ObjectHasAsParentMethodInfo
+    ResolveDeviceMethod "hasClasses" o = DeviceHasClassesMethodInfo
+    ResolveDeviceMethod "hasClassesv" o = DeviceHasClassesvMethodInfo
+    ResolveDeviceMethod "isFloating" o = GObject.ObjectIsFloatingMethodInfo
+    ResolveDeviceMethod "notify" o = GObject.ObjectNotifyMethodInfo
+    ResolveDeviceMethod "notifyByPspec" o = GObject.ObjectNotifyByPspecMethodInfo
+    ResolveDeviceMethod "reconfigureElement" o = DeviceReconfigureElementMethodInfo
+    ResolveDeviceMethod "refSink" o = GObject.ObjectRefSinkMethodInfo
+    ResolveDeviceMethod "removeControlBinding" o = ObjectRemoveControlBindingMethodInfo
+    ResolveDeviceMethod "replaceData" o = GObject.ObjectReplaceDataMethodInfo
+    ResolveDeviceMethod "replaceQdata" o = GObject.ObjectReplaceQdataMethodInfo
+    ResolveDeviceMethod "runDispose" o = GObject.ObjectRunDisposeMethodInfo
+    ResolveDeviceMethod "stealData" o = GObject.ObjectStealDataMethodInfo
+    ResolveDeviceMethod "stealQdata" o = GObject.ObjectStealQdataMethodInfo
+    ResolveDeviceMethod "suggestNextSync" o = ObjectSuggestNextSyncMethodInfo
+    ResolveDeviceMethod "syncValues" o = ObjectSyncValuesMethodInfo
+    ResolveDeviceMethod "thawNotify" o = GObject.ObjectThawNotifyMethodInfo
+    ResolveDeviceMethod "unparent" o = ObjectUnparentMethodInfo
+    ResolveDeviceMethod "watchClosure" o = GObject.ObjectWatchClosureMethodInfo
+    ResolveDeviceMethod "getCaps" o = DeviceGetCapsMethodInfo
+    ResolveDeviceMethod "getControlBinding" o = ObjectGetControlBindingMethodInfo
+    ResolveDeviceMethod "getControlRate" o = ObjectGetControlRateMethodInfo
+    ResolveDeviceMethod "getData" o = GObject.ObjectGetDataMethodInfo
+    ResolveDeviceMethod "getDeviceClass" o = DeviceGetDeviceClassMethodInfo
+    ResolveDeviceMethod "getDisplayName" o = DeviceGetDisplayNameMethodInfo
+    ResolveDeviceMethod "getGValueArray" o = ObjectGetGValueArrayMethodInfo
+    ResolveDeviceMethod "getName" o = ObjectGetNameMethodInfo
+    ResolveDeviceMethod "getParent" o = ObjectGetParentMethodInfo
+    ResolveDeviceMethod "getPathString" o = ObjectGetPathStringMethodInfo
+    ResolveDeviceMethod "getProperties" o = DeviceGetPropertiesMethodInfo
+    ResolveDeviceMethod "getProperty" o = GObject.ObjectGetPropertyMethodInfo
+    ResolveDeviceMethod "getQdata" o = GObject.ObjectGetQdataMethodInfo
+    ResolveDeviceMethod "getValue" o = ObjectGetValueMethodInfo
+    ResolveDeviceMethod "getValueArray" o = ObjectGetValueArrayMethodInfo
+    ResolveDeviceMethod "setControlBindingDisabled" o = ObjectSetControlBindingDisabledMethodInfo
+    ResolveDeviceMethod "setControlBindingsDisabled" o = ObjectSetControlBindingsDisabledMethodInfo
+    ResolveDeviceMethod "setControlRate" o = ObjectSetControlRateMethodInfo
+    ResolveDeviceMethod "setData" o = GObject.ObjectSetDataMethodInfo
+    ResolveDeviceMethod "setName" o = ObjectSetNameMethodInfo
+    ResolveDeviceMethod "setParent" o = ObjectSetParentMethodInfo
+    ResolveDeviceMethod "setProperty" o = GObject.ObjectSetPropertyMethodInfo
+    ResolveDeviceMethod l o = MethodResolutionFailed l o
+
+instance (info ~ ResolveDeviceMethod t Device, MethodInfo info Device p) => IsLabelProxy t (Device -> p) where
+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)
+
+#if MIN_VERSION_base(4,9,0)
+instance (info ~ ResolveDeviceMethod t Device, MethodInfo info Device p) => IsLabel t (Device -> p) where
+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)
+#endif
+
+-- signal Device::removed
+type DeviceRemovedCallback =
+    IO ()
+
+noDeviceRemovedCallback :: Maybe DeviceRemovedCallback
+noDeviceRemovedCallback = Nothing
+
+type DeviceRemovedCallbackC =
+    Ptr () ->                               -- object
+    Ptr () ->                               -- user_data
+    IO ()
+
+foreign import ccall "wrapper"
+    mkDeviceRemovedCallback :: DeviceRemovedCallbackC -> IO (FunPtr DeviceRemovedCallbackC)
+
+deviceRemovedClosure :: DeviceRemovedCallback -> IO Closure
+deviceRemovedClosure cb = newCClosure =<< mkDeviceRemovedCallback wrapped
+    where wrapped = deviceRemovedCallbackWrapper cb
+
+deviceRemovedCallbackWrapper ::
+    DeviceRemovedCallback ->
+    Ptr () ->
+    Ptr () ->
+    IO ()
+deviceRemovedCallbackWrapper _cb _ _ = do
+    _cb 
+
+onDeviceRemoved :: (GObject a, MonadIO m) => a -> DeviceRemovedCallback -> m SignalHandlerId
+onDeviceRemoved obj cb = liftIO $ connectDeviceRemoved obj cb SignalConnectBefore
+afterDeviceRemoved :: (GObject a, MonadIO m) => a -> DeviceRemovedCallback -> m SignalHandlerId
+afterDeviceRemoved obj cb = connectDeviceRemoved obj cb SignalConnectAfter
+
+connectDeviceRemoved :: (GObject a, MonadIO m) =>
+                        a -> DeviceRemovedCallback -> SignalConnectMode -> m SignalHandlerId
+connectDeviceRemoved obj cb after = liftIO $ do
+    cb' <- mkDeviceRemovedCallback (deviceRemovedCallbackWrapper cb)
+    connectSignalFunPtr obj "removed" cb' after
+
+-- VVV Prop "caps"
+   -- Type: TInterface "Gst" "Caps"
+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
+
+getDeviceCaps :: (MonadIO m, DeviceK o) => o -> m Caps
+getDeviceCaps obj = liftIO $ getObjectPropertyBoxed obj "caps" Caps
+
+constructDeviceCaps :: Caps -> IO ([Char], GValue)
+constructDeviceCaps val = constructObjectPropertyBoxed "caps" val
+
+data DeviceCapsPropertyInfo
+instance AttrInfo DeviceCapsPropertyInfo where
+    type AttrAllowedOps DeviceCapsPropertyInfo = '[ 'AttrConstruct, 'AttrGet]
+    type AttrSetTypeConstraint DeviceCapsPropertyInfo = (~) Caps
+    type AttrBaseTypeConstraint DeviceCapsPropertyInfo = DeviceK
+    type AttrGetType DeviceCapsPropertyInfo = Caps
+    type AttrLabel DeviceCapsPropertyInfo = "caps"
+    attrGet _ = getDeviceCaps
+    attrSet _ = undefined
+    attrConstruct _ = constructDeviceCaps
+
+-- VVV Prop "device-class"
+   -- Type: TBasicType TUTF8
+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
+
+getDeviceDeviceClass :: (MonadIO m, DeviceK o) => o -> m T.Text
+getDeviceDeviceClass obj = liftIO $ getObjectPropertyString obj "device-class"
+
+constructDeviceDeviceClass :: T.Text -> IO ([Char], GValue)
+constructDeviceDeviceClass val = constructObjectPropertyString "device-class" val
+
+data DeviceDeviceClassPropertyInfo
+instance AttrInfo DeviceDeviceClassPropertyInfo where
+    type AttrAllowedOps DeviceDeviceClassPropertyInfo = '[ 'AttrConstruct, 'AttrGet]
+    type AttrSetTypeConstraint DeviceDeviceClassPropertyInfo = (~) T.Text
+    type AttrBaseTypeConstraint DeviceDeviceClassPropertyInfo = DeviceK
+    type AttrGetType DeviceDeviceClassPropertyInfo = T.Text
+    type AttrLabel DeviceDeviceClassPropertyInfo = "device-class"
+    attrGet _ = getDeviceDeviceClass
+    attrSet _ = undefined
+    attrConstruct _ = constructDeviceDeviceClass
+
+-- VVV Prop "display-name"
+   -- Type: TBasicType TUTF8
+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
+
+getDeviceDisplayName :: (MonadIO m, DeviceK o) => o -> m T.Text
+getDeviceDisplayName obj = liftIO $ getObjectPropertyString obj "display-name"
+
+constructDeviceDisplayName :: T.Text -> IO ([Char], GValue)
+constructDeviceDisplayName val = constructObjectPropertyString "display-name" val
+
+data DeviceDisplayNamePropertyInfo
+instance AttrInfo DeviceDisplayNamePropertyInfo where
+    type AttrAllowedOps DeviceDisplayNamePropertyInfo = '[ 'AttrConstruct, 'AttrGet]
+    type AttrSetTypeConstraint DeviceDisplayNamePropertyInfo = (~) T.Text
+    type AttrBaseTypeConstraint DeviceDisplayNamePropertyInfo = DeviceK
+    type AttrGetType DeviceDisplayNamePropertyInfo = T.Text
+    type AttrLabel DeviceDisplayNamePropertyInfo = "display-name"
+    attrGet _ = getDeviceDisplayName
+    attrSet _ = undefined
+    attrConstruct _ = constructDeviceDisplayName
+
+-- VVV Prop "properties"
+   -- Type: TInterface "Gst" "Structure"
+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
+
+getDeviceProperties :: (MonadIO m, DeviceK o) => o -> m Structure
+getDeviceProperties obj = liftIO $ getObjectPropertyBoxed obj "properties" Structure
+
+constructDeviceProperties :: Structure -> IO ([Char], GValue)
+constructDeviceProperties val = constructObjectPropertyBoxed "properties" val
+
+data DevicePropertiesPropertyInfo
+instance AttrInfo DevicePropertiesPropertyInfo where
+    type AttrAllowedOps DevicePropertiesPropertyInfo = '[ 'AttrConstruct, 'AttrGet]
+    type AttrSetTypeConstraint DevicePropertiesPropertyInfo = (~) Structure
+    type AttrBaseTypeConstraint DevicePropertiesPropertyInfo = DeviceK
+    type AttrGetType DevicePropertiesPropertyInfo = Structure
+    type AttrLabel DevicePropertiesPropertyInfo = "properties"
+    attrGet _ = getDeviceProperties
+    attrSet _ = undefined
+    attrConstruct _ = constructDeviceProperties
+
+type instance AttributeList Device = DeviceAttributeList
+type DeviceAttributeList = ('[ '("caps", DeviceCapsPropertyInfo), '("deviceClass", DeviceDeviceClassPropertyInfo), '("displayName", DeviceDisplayNamePropertyInfo), '("name", ObjectNamePropertyInfo), '("parent", ObjectParentPropertyInfo), '("properties", DevicePropertiesPropertyInfo)] :: [(Symbol, *)])
+
+data DeviceRemovedSignalInfo
+instance SignalInfo DeviceRemovedSignalInfo where
+    type HaskellCallbackType DeviceRemovedSignalInfo = DeviceRemovedCallback
+    connectSignal _ = connectDeviceRemoved
+
+type instance SignalList Device = DeviceSignalList
+type DeviceSignalList = ('[ '("deepNotify", ObjectDeepNotifySignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("removed", DeviceRemovedSignalInfo)] :: [(Symbol, *)])
+
+-- method Device::create_element
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Device", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Element"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_device_create_element" gst_device_create_element :: 
+    Ptr Device ->                           -- _obj : TInterface "Gst" "Device"
+    CString ->                              -- name : TBasicType TUTF8
+    IO (Ptr Element)
+
+
+deviceCreateElement ::
+    (MonadIO m, DeviceK a) =>
+    a                                       -- _obj
+    -> Maybe (T.Text)                       -- name
+    -> m Element                            -- result
+deviceCreateElement _obj name = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    maybeName <- case name of
+        Nothing -> return nullPtr
+        Just jName -> do
+            jName' <- textToCString jName
+            return jName'
+    result <- gst_device_create_element _obj' maybeName
+    checkUnexpectedReturnNULL "gst_device_create_element" result
+    result' <- (wrapObject Element) result
+    touchManagedPtr _obj
+    freeMem maybeName
+    return result'
+
+data DeviceCreateElementMethodInfo
+instance (signature ~ (Maybe (T.Text) -> m Element), MonadIO m, DeviceK a) => MethodInfo DeviceCreateElementMethodInfo a signature where
+    overloadedMethod _ = deviceCreateElement
+
+-- method Device::get_caps
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Device", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Caps"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_device_get_caps" gst_device_get_caps :: 
+    Ptr Device ->                           -- _obj : TInterface "Gst" "Device"
+    IO (Ptr Caps)
+
+
+deviceGetCaps ::
+    (MonadIO m, DeviceK a) =>
+    a                                       -- _obj
+    -> m Caps                               -- result
+deviceGetCaps _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_device_get_caps _obj'
+    checkUnexpectedReturnNULL "gst_device_get_caps" result
+    result' <- (wrapBoxed Caps) result
+    touchManagedPtr _obj
+    return result'
+
+data DeviceGetCapsMethodInfo
+instance (signature ~ (m Caps), MonadIO m, DeviceK a) => MethodInfo DeviceGetCapsMethodInfo a signature where
+    overloadedMethod _ = deviceGetCaps
+
+-- method Device::get_device_class
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Device", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUTF8
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_device_get_device_class" gst_device_get_device_class :: 
+    Ptr Device ->                           -- _obj : TInterface "Gst" "Device"
+    IO CString
+
+
+deviceGetDeviceClass ::
+    (MonadIO m, DeviceK a) =>
+    a                                       -- _obj
+    -> m T.Text                             -- result
+deviceGetDeviceClass _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_device_get_device_class _obj'
+    checkUnexpectedReturnNULL "gst_device_get_device_class" result
+    result' <- cstringToText result
+    freeMem result
+    touchManagedPtr _obj
+    return result'
+
+data DeviceGetDeviceClassMethodInfo
+instance (signature ~ (m T.Text), MonadIO m, DeviceK a) => MethodInfo DeviceGetDeviceClassMethodInfo a signature where
+    overloadedMethod _ = deviceGetDeviceClass
+
+-- method Device::get_display_name
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Device", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUTF8
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_device_get_display_name" gst_device_get_display_name :: 
+    Ptr Device ->                           -- _obj : TInterface "Gst" "Device"
+    IO CString
+
+
+deviceGetDisplayName ::
+    (MonadIO m, DeviceK a) =>
+    a                                       -- _obj
+    -> m T.Text                             -- result
+deviceGetDisplayName _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_device_get_display_name _obj'
+    checkUnexpectedReturnNULL "gst_device_get_display_name" result
+    result' <- cstringToText result
+    freeMem result
+    touchManagedPtr _obj
+    return result'
+
+data DeviceGetDisplayNameMethodInfo
+instance (signature ~ (m T.Text), MonadIO m, DeviceK a) => MethodInfo DeviceGetDisplayNameMethodInfo a signature where
+    overloadedMethod _ = deviceGetDisplayName
+
+-- method Device::get_properties
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Device", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Structure"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_device_get_properties" gst_device_get_properties :: 
+    Ptr Device ->                           -- _obj : TInterface "Gst" "Device"
+    IO (Ptr Structure)
+
+
+deviceGetProperties ::
+    (MonadIO m, DeviceK a) =>
+    a                                       -- _obj
+    -> m Structure                          -- result
+deviceGetProperties _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_device_get_properties _obj'
+    checkUnexpectedReturnNULL "gst_device_get_properties" result
+    result' <- (wrapBoxed Structure) result
+    touchManagedPtr _obj
+    return result'
+
+data DeviceGetPropertiesMethodInfo
+instance (signature ~ (m Structure), MonadIO m, DeviceK a) => MethodInfo DeviceGetPropertiesMethodInfo a signature where
+    overloadedMethod _ = deviceGetProperties
+
+-- method Device::has_classes
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Device", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "classes", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_device_has_classes" gst_device_has_classes :: 
+    Ptr Device ->                           -- _obj : TInterface "Gst" "Device"
+    CString ->                              -- classes : TBasicType TUTF8
+    IO CInt
+
+
+deviceHasClasses ::
+    (MonadIO m, DeviceK a) =>
+    a                                       -- _obj
+    -> T.Text                               -- classes
+    -> m Bool                               -- result
+deviceHasClasses _obj classes = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    classes' <- textToCString classes
+    result <- gst_device_has_classes _obj' classes'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    freeMem classes'
+    return result'
+
+data DeviceHasClassesMethodInfo
+instance (signature ~ (T.Text -> m Bool), MonadIO m, DeviceK a) => MethodInfo DeviceHasClassesMethodInfo a signature where
+    overloadedMethod _ = deviceHasClasses
+
+-- method Device::has_classesv
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Device", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "classes", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_device_has_classesv" gst_device_has_classesv :: 
+    Ptr Device ->                           -- _obj : TInterface "Gst" "Device"
+    Ptr CString ->                          -- classes : TCArray True (-1) (-1) (TBasicType TUTF8)
+    IO CInt
+
+
+deviceHasClassesv ::
+    (MonadIO m, DeviceK a) =>
+    a                                       -- _obj
+    -> [T.Text]                             -- classes
+    -> m Bool                               -- result
+deviceHasClassesv _obj classes = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    classes' <- packZeroTerminatedUTF8CArray classes
+    result <- gst_device_has_classesv _obj' classes'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    mapZeroTerminatedCArray freeMem classes'
+    freeMem classes'
+    return result'
+
+data DeviceHasClassesvMethodInfo
+instance (signature ~ ([T.Text] -> m Bool), MonadIO m, DeviceK a) => MethodInfo DeviceHasClassesvMethodInfo a signature where
+    overloadedMethod _ = deviceHasClassesv
+
+-- method Device::reconfigure_element
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Device", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "element", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_device_reconfigure_element" gst_device_reconfigure_element :: 
+    Ptr Device ->                           -- _obj : TInterface "Gst" "Device"
+    Ptr Element ->                          -- element : TInterface "Gst" "Element"
+    IO CInt
+
+
+deviceReconfigureElement ::
+    (MonadIO m, DeviceK a, ElementK b) =>
+    a                                       -- _obj
+    -> b                                    -- element
+    -> m Bool                               -- result
+deviceReconfigureElement _obj element = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let element' = unsafeManagedPtrCastPtr element
+    result <- gst_device_reconfigure_element _obj' element'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    touchManagedPtr element
+    return result'
+
+data DeviceReconfigureElementMethodInfo
+instance (signature ~ (b -> m Bool), MonadIO m, DeviceK a, ElementK b) => MethodInfo DeviceReconfigureElementMethodInfo a signature where
+    overloadedMethod _ = deviceReconfigureElement
+
+
diff --git a/GI/Gst/Objects/Device.hs-boot b/GI/Gst/Objects/Device.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Objects/Device.hs-boot
@@ -0,0 +1,26 @@
+module GI.Gst.Objects.Device where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+newtype Device = Device (ForeignPtr Device)
+instance GObject Device where
+class GObject o => DeviceK o
+instance (GObject o, IsDescendantOf Device o) => DeviceK o
+data DeviceCapsPropertyInfo
+data DeviceDeviceClassPropertyInfo
+data DeviceDisplayNamePropertyInfo
+data DevicePropertiesPropertyInfo
+data DeviceRemovedSignalInfo
+data DeviceCreateElementMethodInfo
+data DeviceGetCapsMethodInfo
+data DeviceGetDeviceClassMethodInfo
+data DeviceGetDisplayNameMethodInfo
+data DeviceGetPropertiesMethodInfo
+data DeviceHasClassesMethodInfo
+data DeviceHasClassesvMethodInfo
+data DeviceReconfigureElementMethodInfo
diff --git a/GI/Gst/Objects/DeviceMonitor.hs b/GI/Gst/Objects/DeviceMonitor.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Objects/DeviceMonitor.hs
@@ -0,0 +1,506 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+-}
+
+module GI.Gst.Objects.DeviceMonitor
+    ( 
+
+-- * Exported types
+    DeviceMonitor(..)                       ,
+    DeviceMonitorK                          ,
+    toDeviceMonitor                         ,
+    noDeviceMonitor                         ,
+
+
+ -- * Methods
+-- ** deviceMonitorAddFilter
+    DeviceMonitorAddFilterMethodInfo        ,
+    deviceMonitorAddFilter                  ,
+
+
+-- ** deviceMonitorGetBus
+    DeviceMonitorGetBusMethodInfo           ,
+    deviceMonitorGetBus                     ,
+
+
+-- ** deviceMonitorGetDevices
+    DeviceMonitorGetDevicesMethodInfo       ,
+    deviceMonitorGetDevices                 ,
+
+
+-- ** deviceMonitorGetProviders
+    DeviceMonitorGetProvidersMethodInfo     ,
+    deviceMonitorGetProviders               ,
+
+
+-- ** deviceMonitorGetShowAllDevices
+    DeviceMonitorGetShowAllDevicesMethodInfo,
+    deviceMonitorGetShowAllDevices          ,
+
+
+-- ** deviceMonitorNew
+    deviceMonitorNew                        ,
+
+
+-- ** deviceMonitorRemoveFilter
+    DeviceMonitorRemoveFilterMethodInfo     ,
+    deviceMonitorRemoveFilter               ,
+
+
+-- ** deviceMonitorSetShowAllDevices
+    DeviceMonitorSetShowAllDevicesMethodInfo,
+    deviceMonitorSetShowAllDevices          ,
+
+
+-- ** deviceMonitorStart
+    DeviceMonitorStartMethodInfo            ,
+    deviceMonitorStart                      ,
+
+
+-- ** deviceMonitorStop
+    DeviceMonitorStopMethodInfo             ,
+    deviceMonitorStop                       ,
+
+
+
+
+ -- * Properties
+-- ** ShowAll
+    DeviceMonitorShowAllPropertyInfo        ,
+    constructDeviceMonitorShowAll           ,
+    getDeviceMonitorShowAll                 ,
+    setDeviceMonitorShowAll                 ,
+
+
+
+
+    ) where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+import GI.Gst.Callbacks
+import qualified GI.GObject as GObject
+
+newtype DeviceMonitor = DeviceMonitor (ForeignPtr DeviceMonitor)
+foreign import ccall "gst_device_monitor_get_type"
+    c_gst_device_monitor_get_type :: IO GType
+
+type instance ParentTypes DeviceMonitor = DeviceMonitorParentTypes
+type DeviceMonitorParentTypes = '[Object, GObject.Object]
+
+instance GObject DeviceMonitor where
+    gobjectIsInitiallyUnowned _ = True
+    gobjectType _ = c_gst_device_monitor_get_type
+    
+
+class GObject o => DeviceMonitorK o
+instance (GObject o, IsDescendantOf DeviceMonitor o) => DeviceMonitorK o
+
+toDeviceMonitor :: DeviceMonitorK o => o -> IO DeviceMonitor
+toDeviceMonitor = unsafeCastTo DeviceMonitor
+
+noDeviceMonitor :: Maybe DeviceMonitor
+noDeviceMonitor = Nothing
+
+type family ResolveDeviceMonitorMethod (t :: Symbol) (o :: *) :: * where
+    ResolveDeviceMonitorMethod "addControlBinding" o = ObjectAddControlBindingMethodInfo
+    ResolveDeviceMonitorMethod "addFilter" o = DeviceMonitorAddFilterMethodInfo
+    ResolveDeviceMonitorMethod "bindProperty" o = GObject.ObjectBindPropertyMethodInfo
+    ResolveDeviceMonitorMethod "bindPropertyFull" o = GObject.ObjectBindPropertyFullMethodInfo
+    ResolveDeviceMonitorMethod "defaultError" o = ObjectDefaultErrorMethodInfo
+    ResolveDeviceMonitorMethod "forceFloating" o = GObject.ObjectForceFloatingMethodInfo
+    ResolveDeviceMonitorMethod "freezeNotify" o = GObject.ObjectFreezeNotifyMethodInfo
+    ResolveDeviceMonitorMethod "hasActiveControlBindings" o = ObjectHasActiveControlBindingsMethodInfo
+    ResolveDeviceMonitorMethod "hasAncestor" o = ObjectHasAncestorMethodInfo
+    ResolveDeviceMonitorMethod "hasAsAncestor" o = ObjectHasAsAncestorMethodInfo
+    ResolveDeviceMonitorMethod "hasAsParent" o = ObjectHasAsParentMethodInfo
+    ResolveDeviceMonitorMethod "isFloating" o = GObject.ObjectIsFloatingMethodInfo
+    ResolveDeviceMonitorMethod "notify" o = GObject.ObjectNotifyMethodInfo
+    ResolveDeviceMonitorMethod "notifyByPspec" o = GObject.ObjectNotifyByPspecMethodInfo
+    ResolveDeviceMonitorMethod "refSink" o = GObject.ObjectRefSinkMethodInfo
+    ResolveDeviceMonitorMethod "removeControlBinding" o = ObjectRemoveControlBindingMethodInfo
+    ResolveDeviceMonitorMethod "removeFilter" o = DeviceMonitorRemoveFilterMethodInfo
+    ResolveDeviceMonitorMethod "replaceData" o = GObject.ObjectReplaceDataMethodInfo
+    ResolveDeviceMonitorMethod "replaceQdata" o = GObject.ObjectReplaceQdataMethodInfo
+    ResolveDeviceMonitorMethod "runDispose" o = GObject.ObjectRunDisposeMethodInfo
+    ResolveDeviceMonitorMethod "start" o = DeviceMonitorStartMethodInfo
+    ResolveDeviceMonitorMethod "stealData" o = GObject.ObjectStealDataMethodInfo
+    ResolveDeviceMonitorMethod "stealQdata" o = GObject.ObjectStealQdataMethodInfo
+    ResolveDeviceMonitorMethod "stop" o = DeviceMonitorStopMethodInfo
+    ResolveDeviceMonitorMethod "suggestNextSync" o = ObjectSuggestNextSyncMethodInfo
+    ResolveDeviceMonitorMethod "syncValues" o = ObjectSyncValuesMethodInfo
+    ResolveDeviceMonitorMethod "thawNotify" o = GObject.ObjectThawNotifyMethodInfo
+    ResolveDeviceMonitorMethod "unparent" o = ObjectUnparentMethodInfo
+    ResolveDeviceMonitorMethod "watchClosure" o = GObject.ObjectWatchClosureMethodInfo
+    ResolveDeviceMonitorMethod "getBus" o = DeviceMonitorGetBusMethodInfo
+    ResolveDeviceMonitorMethod "getControlBinding" o = ObjectGetControlBindingMethodInfo
+    ResolveDeviceMonitorMethod "getControlRate" o = ObjectGetControlRateMethodInfo
+    ResolveDeviceMonitorMethod "getData" o = GObject.ObjectGetDataMethodInfo
+    ResolveDeviceMonitorMethod "getDevices" o = DeviceMonitorGetDevicesMethodInfo
+    ResolveDeviceMonitorMethod "getGValueArray" o = ObjectGetGValueArrayMethodInfo
+    ResolveDeviceMonitorMethod "getName" o = ObjectGetNameMethodInfo
+    ResolveDeviceMonitorMethod "getParent" o = ObjectGetParentMethodInfo
+    ResolveDeviceMonitorMethod "getPathString" o = ObjectGetPathStringMethodInfo
+    ResolveDeviceMonitorMethod "getProperty" o = GObject.ObjectGetPropertyMethodInfo
+    ResolveDeviceMonitorMethod "getProviders" o = DeviceMonitorGetProvidersMethodInfo
+    ResolveDeviceMonitorMethod "getQdata" o = GObject.ObjectGetQdataMethodInfo
+    ResolveDeviceMonitorMethod "getShowAllDevices" o = DeviceMonitorGetShowAllDevicesMethodInfo
+    ResolveDeviceMonitorMethod "getValue" o = ObjectGetValueMethodInfo
+    ResolveDeviceMonitorMethod "getValueArray" o = ObjectGetValueArrayMethodInfo
+    ResolveDeviceMonitorMethod "setControlBindingDisabled" o = ObjectSetControlBindingDisabledMethodInfo
+    ResolveDeviceMonitorMethod "setControlBindingsDisabled" o = ObjectSetControlBindingsDisabledMethodInfo
+    ResolveDeviceMonitorMethod "setControlRate" o = ObjectSetControlRateMethodInfo
+    ResolveDeviceMonitorMethod "setData" o = GObject.ObjectSetDataMethodInfo
+    ResolveDeviceMonitorMethod "setName" o = ObjectSetNameMethodInfo
+    ResolveDeviceMonitorMethod "setParent" o = ObjectSetParentMethodInfo
+    ResolveDeviceMonitorMethod "setProperty" o = GObject.ObjectSetPropertyMethodInfo
+    ResolveDeviceMonitorMethod "setShowAllDevices" o = DeviceMonitorSetShowAllDevicesMethodInfo
+    ResolveDeviceMonitorMethod l o = MethodResolutionFailed l o
+
+instance (info ~ ResolveDeviceMonitorMethod t DeviceMonitor, MethodInfo info DeviceMonitor p) => IsLabelProxy t (DeviceMonitor -> p) where
+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)
+
+#if MIN_VERSION_base(4,9,0)
+instance (info ~ ResolveDeviceMonitorMethod t DeviceMonitor, MethodInfo info DeviceMonitor p) => IsLabel t (DeviceMonitor -> p) where
+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)
+#endif
+
+-- VVV Prop "show-all"
+   -- Type: TBasicType TBoolean
+   -- Flags: [PropertyReadable,PropertyWritable]
+
+getDeviceMonitorShowAll :: (MonadIO m, DeviceMonitorK o) => o -> m Bool
+getDeviceMonitorShowAll obj = liftIO $ getObjectPropertyBool obj "show-all"
+
+setDeviceMonitorShowAll :: (MonadIO m, DeviceMonitorK o) => o -> Bool -> m ()
+setDeviceMonitorShowAll obj val = liftIO $ setObjectPropertyBool obj "show-all" val
+
+constructDeviceMonitorShowAll :: Bool -> IO ([Char], GValue)
+constructDeviceMonitorShowAll val = constructObjectPropertyBool "show-all" val
+
+data DeviceMonitorShowAllPropertyInfo
+instance AttrInfo DeviceMonitorShowAllPropertyInfo where
+    type AttrAllowedOps DeviceMonitorShowAllPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
+    type AttrSetTypeConstraint DeviceMonitorShowAllPropertyInfo = (~) Bool
+    type AttrBaseTypeConstraint DeviceMonitorShowAllPropertyInfo = DeviceMonitorK
+    type AttrGetType DeviceMonitorShowAllPropertyInfo = Bool
+    type AttrLabel DeviceMonitorShowAllPropertyInfo = "show-all"
+    attrGet _ = getDeviceMonitorShowAll
+    attrSet _ = setDeviceMonitorShowAll
+    attrConstruct _ = constructDeviceMonitorShowAll
+
+type instance AttributeList DeviceMonitor = DeviceMonitorAttributeList
+type DeviceMonitorAttributeList = ('[ '("name", ObjectNamePropertyInfo), '("parent", ObjectParentPropertyInfo), '("showAll", DeviceMonitorShowAllPropertyInfo)] :: [(Symbol, *)])
+
+type instance SignalList DeviceMonitor = DeviceMonitorSignalList
+type DeviceMonitorSignalList = ('[ '("deepNotify", ObjectDeepNotifySignalInfo), '("notify", GObject.ObjectNotifySignalInfo)] :: [(Symbol, *)])
+
+-- method DeviceMonitor::new
+-- method type : Constructor
+-- Args : []
+-- Lengths : []
+-- returnType : TInterface "Gst" "DeviceMonitor"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_device_monitor_new" gst_device_monitor_new :: 
+    IO (Ptr DeviceMonitor)
+
+
+deviceMonitorNew ::
+    (MonadIO m) =>
+    m DeviceMonitor                         -- result
+deviceMonitorNew  = liftIO $ do
+    result <- gst_device_monitor_new
+    checkUnexpectedReturnNULL "gst_device_monitor_new" result
+    result' <- (wrapObject DeviceMonitor) result
+    return result'
+
+-- method DeviceMonitor::add_filter
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DeviceMonitor", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "classes", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUInt32
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_device_monitor_add_filter" gst_device_monitor_add_filter :: 
+    Ptr DeviceMonitor ->                    -- _obj : TInterface "Gst" "DeviceMonitor"
+    CString ->                              -- classes : TBasicType TUTF8
+    Ptr Caps ->                             -- caps : TInterface "Gst" "Caps"
+    IO Word32
+
+
+deviceMonitorAddFilter ::
+    (MonadIO m, DeviceMonitorK a) =>
+    a                                       -- _obj
+    -> Maybe (T.Text)                       -- classes
+    -> Maybe (Caps)                         -- caps
+    -> m Word32                             -- result
+deviceMonitorAddFilter _obj classes caps = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    maybeClasses <- case classes of
+        Nothing -> return nullPtr
+        Just jClasses -> do
+            jClasses' <- textToCString jClasses
+            return jClasses'
+    maybeCaps <- case caps of
+        Nothing -> return nullPtr
+        Just jCaps -> do
+            let jCaps' = unsafeManagedPtrGetPtr jCaps
+            return jCaps'
+    result <- gst_device_monitor_add_filter _obj' maybeClasses maybeCaps
+    touchManagedPtr _obj
+    whenJust caps touchManagedPtr
+    freeMem maybeClasses
+    return result
+
+data DeviceMonitorAddFilterMethodInfo
+instance (signature ~ (Maybe (T.Text) -> Maybe (Caps) -> m Word32), MonadIO m, DeviceMonitorK a) => MethodInfo DeviceMonitorAddFilterMethodInfo a signature where
+    overloadedMethod _ = deviceMonitorAddFilter
+
+-- method DeviceMonitor::get_bus
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DeviceMonitor", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Bus"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_device_monitor_get_bus" gst_device_monitor_get_bus :: 
+    Ptr DeviceMonitor ->                    -- _obj : TInterface "Gst" "DeviceMonitor"
+    IO (Ptr Bus)
+
+
+deviceMonitorGetBus ::
+    (MonadIO m, DeviceMonitorK a) =>
+    a                                       -- _obj
+    -> m Bus                                -- result
+deviceMonitorGetBus _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_device_monitor_get_bus _obj'
+    checkUnexpectedReturnNULL "gst_device_monitor_get_bus" result
+    result' <- (wrapObject Bus) result
+    touchManagedPtr _obj
+    return result'
+
+data DeviceMonitorGetBusMethodInfo
+instance (signature ~ (m Bus), MonadIO m, DeviceMonitorK a) => MethodInfo DeviceMonitorGetBusMethodInfo a signature where
+    overloadedMethod _ = deviceMonitorGetBus
+
+-- method DeviceMonitor::get_devices
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DeviceMonitor", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TGList (TInterface "Gst" "Device")
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_device_monitor_get_devices" gst_device_monitor_get_devices :: 
+    Ptr DeviceMonitor ->                    -- _obj : TInterface "Gst" "DeviceMonitor"
+    IO (Ptr (GList (Ptr Device)))
+
+
+deviceMonitorGetDevices ::
+    (MonadIO m, DeviceMonitorK a) =>
+    a                                       -- _obj
+    -> m [Device]                           -- result
+deviceMonitorGetDevices _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_device_monitor_get_devices _obj'
+    checkUnexpectedReturnNULL "gst_device_monitor_get_devices" result
+    result' <- unpackGList result
+    result'' <- mapM (wrapObject Device) result'
+    g_list_free result
+    touchManagedPtr _obj
+    return result''
+
+data DeviceMonitorGetDevicesMethodInfo
+instance (signature ~ (m [Device]), MonadIO m, DeviceMonitorK a) => MethodInfo DeviceMonitorGetDevicesMethodInfo a signature where
+    overloadedMethod _ = deviceMonitorGetDevices
+
+-- method DeviceMonitor::get_providers
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DeviceMonitor", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TCArray True (-1) (-1) (TBasicType TUTF8)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_device_monitor_get_providers" gst_device_monitor_get_providers :: 
+    Ptr DeviceMonitor ->                    -- _obj : TInterface "Gst" "DeviceMonitor"
+    IO (Ptr CString)
+
+
+deviceMonitorGetProviders ::
+    (MonadIO m, DeviceMonitorK a) =>
+    a                                       -- _obj
+    -> m [T.Text]                           -- result
+deviceMonitorGetProviders _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_device_monitor_get_providers _obj'
+    checkUnexpectedReturnNULL "gst_device_monitor_get_providers" result
+    result' <- unpackZeroTerminatedUTF8CArray result
+    mapZeroTerminatedCArray freeMem result
+    freeMem result
+    touchManagedPtr _obj
+    return result'
+
+data DeviceMonitorGetProvidersMethodInfo
+instance (signature ~ (m [T.Text]), MonadIO m, DeviceMonitorK a) => MethodInfo DeviceMonitorGetProvidersMethodInfo a signature where
+    overloadedMethod _ = deviceMonitorGetProviders
+
+-- method DeviceMonitor::get_show_all_devices
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DeviceMonitor", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_device_monitor_get_show_all_devices" gst_device_monitor_get_show_all_devices :: 
+    Ptr DeviceMonitor ->                    -- _obj : TInterface "Gst" "DeviceMonitor"
+    IO CInt
+
+
+deviceMonitorGetShowAllDevices ::
+    (MonadIO m, DeviceMonitorK a) =>
+    a                                       -- _obj
+    -> m Bool                               -- result
+deviceMonitorGetShowAllDevices _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_device_monitor_get_show_all_devices _obj'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data DeviceMonitorGetShowAllDevicesMethodInfo
+instance (signature ~ (m Bool), MonadIO m, DeviceMonitorK a) => MethodInfo DeviceMonitorGetShowAllDevicesMethodInfo a signature where
+    overloadedMethod _ = deviceMonitorGetShowAllDevices
+
+-- method DeviceMonitor::remove_filter
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DeviceMonitor", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "filter_id", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_device_monitor_remove_filter" gst_device_monitor_remove_filter :: 
+    Ptr DeviceMonitor ->                    -- _obj : TInterface "Gst" "DeviceMonitor"
+    Word32 ->                               -- filter_id : TBasicType TUInt32
+    IO CInt
+
+
+deviceMonitorRemoveFilter ::
+    (MonadIO m, DeviceMonitorK a) =>
+    a                                       -- _obj
+    -> Word32                               -- filterId
+    -> m Bool                               -- result
+deviceMonitorRemoveFilter _obj filterId = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_device_monitor_remove_filter _obj' filterId
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data DeviceMonitorRemoveFilterMethodInfo
+instance (signature ~ (Word32 -> m Bool), MonadIO m, DeviceMonitorK a) => MethodInfo DeviceMonitorRemoveFilterMethodInfo a signature where
+    overloadedMethod _ = deviceMonitorRemoveFilter
+
+-- method DeviceMonitor::set_show_all_devices
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DeviceMonitor", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "show_all", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_device_monitor_set_show_all_devices" gst_device_monitor_set_show_all_devices :: 
+    Ptr DeviceMonitor ->                    -- _obj : TInterface "Gst" "DeviceMonitor"
+    CInt ->                                 -- show_all : TBasicType TBoolean
+    IO ()
+
+
+deviceMonitorSetShowAllDevices ::
+    (MonadIO m, DeviceMonitorK a) =>
+    a                                       -- _obj
+    -> Bool                                 -- showAll
+    -> m ()                                 -- result
+deviceMonitorSetShowAllDevices _obj showAll = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let showAll' = (fromIntegral . fromEnum) showAll
+    gst_device_monitor_set_show_all_devices _obj' showAll'
+    touchManagedPtr _obj
+    return ()
+
+data DeviceMonitorSetShowAllDevicesMethodInfo
+instance (signature ~ (Bool -> m ()), MonadIO m, DeviceMonitorK a) => MethodInfo DeviceMonitorSetShowAllDevicesMethodInfo a signature where
+    overloadedMethod _ = deviceMonitorSetShowAllDevices
+
+-- method DeviceMonitor::start
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DeviceMonitor", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_device_monitor_start" gst_device_monitor_start :: 
+    Ptr DeviceMonitor ->                    -- _obj : TInterface "Gst" "DeviceMonitor"
+    IO CInt
+
+
+deviceMonitorStart ::
+    (MonadIO m, DeviceMonitorK a) =>
+    a                                       -- _obj
+    -> m Bool                               -- result
+deviceMonitorStart _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_device_monitor_start _obj'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data DeviceMonitorStartMethodInfo
+instance (signature ~ (m Bool), MonadIO m, DeviceMonitorK a) => MethodInfo DeviceMonitorStartMethodInfo a signature where
+    overloadedMethod _ = deviceMonitorStart
+
+-- method DeviceMonitor::stop
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DeviceMonitor", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_device_monitor_stop" gst_device_monitor_stop :: 
+    Ptr DeviceMonitor ->                    -- _obj : TInterface "Gst" "DeviceMonitor"
+    IO ()
+
+
+deviceMonitorStop ::
+    (MonadIO m, DeviceMonitorK a) =>
+    a                                       -- _obj
+    -> m ()                                 -- result
+deviceMonitorStop _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    gst_device_monitor_stop _obj'
+    touchManagedPtr _obj
+    return ()
+
+data DeviceMonitorStopMethodInfo
+instance (signature ~ (m ()), MonadIO m, DeviceMonitorK a) => MethodInfo DeviceMonitorStopMethodInfo a signature where
+    overloadedMethod _ = deviceMonitorStop
+
+
diff --git a/GI/Gst/Objects/DeviceMonitor.hs-boot b/GI/Gst/Objects/DeviceMonitor.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Objects/DeviceMonitor.hs-boot
@@ -0,0 +1,23 @@
+module GI.Gst.Objects.DeviceMonitor where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+newtype DeviceMonitor = DeviceMonitor (ForeignPtr DeviceMonitor)
+instance GObject DeviceMonitor where
+class GObject o => DeviceMonitorK o
+instance (GObject o, IsDescendantOf DeviceMonitor o) => DeviceMonitorK o
+data DeviceMonitorShowAllPropertyInfo
+data DeviceMonitorAddFilterMethodInfo
+data DeviceMonitorGetBusMethodInfo
+data DeviceMonitorGetDevicesMethodInfo
+data DeviceMonitorGetProvidersMethodInfo
+data DeviceMonitorGetShowAllDevicesMethodInfo
+data DeviceMonitorRemoveFilterMethodInfo
+data DeviceMonitorSetShowAllDevicesMethodInfo
+data DeviceMonitorStartMethodInfo
+data DeviceMonitorStopMethodInfo
diff --git a/GI/Gst/Objects/DeviceProvider.hs b/GI/Gst/Objects/DeviceProvider.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Objects/DeviceProvider.hs
@@ -0,0 +1,671 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+-}
+
+module GI.Gst.Objects.DeviceProvider
+    ( 
+
+-- * Exported types
+    DeviceProvider(..)                      ,
+    DeviceProviderK                         ,
+    toDeviceProvider                        ,
+    noDeviceProvider                        ,
+
+
+ -- * Methods
+-- ** deviceProviderCanMonitor
+    DeviceProviderCanMonitorMethodInfo      ,
+    deviceProviderCanMonitor                ,
+
+
+-- ** deviceProviderDeviceAdd
+    DeviceProviderDeviceAddMethodInfo       ,
+    deviceProviderDeviceAdd                 ,
+
+
+-- ** deviceProviderDeviceRemove
+    DeviceProviderDeviceRemoveMethodInfo    ,
+    deviceProviderDeviceRemove              ,
+
+
+-- ** deviceProviderGetBus
+    DeviceProviderGetBusMethodInfo          ,
+    deviceProviderGetBus                    ,
+
+
+-- ** deviceProviderGetDevices
+    DeviceProviderGetDevicesMethodInfo      ,
+    deviceProviderGetDevices                ,
+
+
+-- ** deviceProviderGetFactory
+    DeviceProviderGetFactoryMethodInfo      ,
+    deviceProviderGetFactory                ,
+
+
+-- ** deviceProviderGetHiddenProviders
+    DeviceProviderGetHiddenProvidersMethodInfo,
+    deviceProviderGetHiddenProviders        ,
+
+
+-- ** deviceProviderHideProvider
+    DeviceProviderHideProviderMethodInfo    ,
+    deviceProviderHideProvider              ,
+
+
+-- ** deviceProviderRegister
+    deviceProviderRegister                  ,
+
+
+-- ** deviceProviderStart
+    DeviceProviderStartMethodInfo           ,
+    deviceProviderStart                     ,
+
+
+-- ** deviceProviderStop
+    DeviceProviderStopMethodInfo            ,
+    deviceProviderStop                      ,
+
+
+-- ** deviceProviderUnhideProvider
+    DeviceProviderUnhideProviderMethodInfo  ,
+    deviceProviderUnhideProvider            ,
+
+
+
+
+ -- * Signals
+-- ** ProviderHidden
+    DeviceProviderProviderHiddenCallback    ,
+    DeviceProviderProviderHiddenCallbackC   ,
+    DeviceProviderProviderHiddenSignalInfo  ,
+    afterDeviceProviderProviderHidden       ,
+    deviceProviderProviderHiddenCallbackWrapper,
+    deviceProviderProviderHiddenClosure     ,
+    mkDeviceProviderProviderHiddenCallback  ,
+    noDeviceProviderProviderHiddenCallback  ,
+    onDeviceProviderProviderHidden          ,
+
+
+-- ** ProviderUnhidden
+    DeviceProviderProviderUnhiddenCallback  ,
+    DeviceProviderProviderUnhiddenCallbackC ,
+    DeviceProviderProviderUnhiddenSignalInfo,
+    afterDeviceProviderProviderUnhidden     ,
+    deviceProviderProviderUnhiddenCallbackWrapper,
+    deviceProviderProviderUnhiddenClosure   ,
+    mkDeviceProviderProviderUnhiddenCallback,
+    noDeviceProviderProviderUnhiddenCallback,
+    onDeviceProviderProviderUnhidden        ,
+
+
+
+
+    ) where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+import GI.Gst.Callbacks
+import qualified GI.GObject as GObject
+
+newtype DeviceProvider = DeviceProvider (ForeignPtr DeviceProvider)
+foreign import ccall "gst_device_provider_get_type"
+    c_gst_device_provider_get_type :: IO GType
+
+type instance ParentTypes DeviceProvider = DeviceProviderParentTypes
+type DeviceProviderParentTypes = '[Object, GObject.Object]
+
+instance GObject DeviceProvider where
+    gobjectIsInitiallyUnowned _ = True
+    gobjectType _ = c_gst_device_provider_get_type
+    
+
+class GObject o => DeviceProviderK o
+instance (GObject o, IsDescendantOf DeviceProvider o) => DeviceProviderK o
+
+toDeviceProvider :: DeviceProviderK o => o -> IO DeviceProvider
+toDeviceProvider = unsafeCastTo DeviceProvider
+
+noDeviceProvider :: Maybe DeviceProvider
+noDeviceProvider = Nothing
+
+type family ResolveDeviceProviderMethod (t :: Symbol) (o :: *) :: * where
+    ResolveDeviceProviderMethod "addControlBinding" o = ObjectAddControlBindingMethodInfo
+    ResolveDeviceProviderMethod "bindProperty" o = GObject.ObjectBindPropertyMethodInfo
+    ResolveDeviceProviderMethod "bindPropertyFull" o = GObject.ObjectBindPropertyFullMethodInfo
+    ResolveDeviceProviderMethod "canMonitor" o = DeviceProviderCanMonitorMethodInfo
+    ResolveDeviceProviderMethod "defaultError" o = ObjectDefaultErrorMethodInfo
+    ResolveDeviceProviderMethod "deviceAdd" o = DeviceProviderDeviceAddMethodInfo
+    ResolveDeviceProviderMethod "deviceRemove" o = DeviceProviderDeviceRemoveMethodInfo
+    ResolveDeviceProviderMethod "forceFloating" o = GObject.ObjectForceFloatingMethodInfo
+    ResolveDeviceProviderMethod "freezeNotify" o = GObject.ObjectFreezeNotifyMethodInfo
+    ResolveDeviceProviderMethod "hasActiveControlBindings" o = ObjectHasActiveControlBindingsMethodInfo
+    ResolveDeviceProviderMethod "hasAncestor" o = ObjectHasAncestorMethodInfo
+    ResolveDeviceProviderMethod "hasAsAncestor" o = ObjectHasAsAncestorMethodInfo
+    ResolveDeviceProviderMethod "hasAsParent" o = ObjectHasAsParentMethodInfo
+    ResolveDeviceProviderMethod "hideProvider" o = DeviceProviderHideProviderMethodInfo
+    ResolveDeviceProviderMethod "isFloating" o = GObject.ObjectIsFloatingMethodInfo
+    ResolveDeviceProviderMethod "notify" o = GObject.ObjectNotifyMethodInfo
+    ResolveDeviceProviderMethod "notifyByPspec" o = GObject.ObjectNotifyByPspecMethodInfo
+    ResolveDeviceProviderMethod "refSink" o = GObject.ObjectRefSinkMethodInfo
+    ResolveDeviceProviderMethod "removeControlBinding" o = ObjectRemoveControlBindingMethodInfo
+    ResolveDeviceProviderMethod "replaceData" o = GObject.ObjectReplaceDataMethodInfo
+    ResolveDeviceProviderMethod "replaceQdata" o = GObject.ObjectReplaceQdataMethodInfo
+    ResolveDeviceProviderMethod "runDispose" o = GObject.ObjectRunDisposeMethodInfo
+    ResolveDeviceProviderMethod "start" o = DeviceProviderStartMethodInfo
+    ResolveDeviceProviderMethod "stealData" o = GObject.ObjectStealDataMethodInfo
+    ResolveDeviceProviderMethod "stealQdata" o = GObject.ObjectStealQdataMethodInfo
+    ResolveDeviceProviderMethod "stop" o = DeviceProviderStopMethodInfo
+    ResolveDeviceProviderMethod "suggestNextSync" o = ObjectSuggestNextSyncMethodInfo
+    ResolveDeviceProviderMethod "syncValues" o = ObjectSyncValuesMethodInfo
+    ResolveDeviceProviderMethod "thawNotify" o = GObject.ObjectThawNotifyMethodInfo
+    ResolveDeviceProviderMethod "unhideProvider" o = DeviceProviderUnhideProviderMethodInfo
+    ResolveDeviceProviderMethod "unparent" o = ObjectUnparentMethodInfo
+    ResolveDeviceProviderMethod "watchClosure" o = GObject.ObjectWatchClosureMethodInfo
+    ResolveDeviceProviderMethod "getBus" o = DeviceProviderGetBusMethodInfo
+    ResolveDeviceProviderMethod "getControlBinding" o = ObjectGetControlBindingMethodInfo
+    ResolveDeviceProviderMethod "getControlRate" o = ObjectGetControlRateMethodInfo
+    ResolveDeviceProviderMethod "getData" o = GObject.ObjectGetDataMethodInfo
+    ResolveDeviceProviderMethod "getDevices" o = DeviceProviderGetDevicesMethodInfo
+    ResolveDeviceProviderMethod "getFactory" o = DeviceProviderGetFactoryMethodInfo
+    ResolveDeviceProviderMethod "getGValueArray" o = ObjectGetGValueArrayMethodInfo
+    ResolveDeviceProviderMethod "getHiddenProviders" o = DeviceProviderGetHiddenProvidersMethodInfo
+    ResolveDeviceProviderMethod "getName" o = ObjectGetNameMethodInfo
+    ResolveDeviceProviderMethod "getParent" o = ObjectGetParentMethodInfo
+    ResolveDeviceProviderMethod "getPathString" o = ObjectGetPathStringMethodInfo
+    ResolveDeviceProviderMethod "getProperty" o = GObject.ObjectGetPropertyMethodInfo
+    ResolveDeviceProviderMethod "getQdata" o = GObject.ObjectGetQdataMethodInfo
+    ResolveDeviceProviderMethod "getValue" o = ObjectGetValueMethodInfo
+    ResolveDeviceProviderMethod "getValueArray" o = ObjectGetValueArrayMethodInfo
+    ResolveDeviceProviderMethod "setControlBindingDisabled" o = ObjectSetControlBindingDisabledMethodInfo
+    ResolveDeviceProviderMethod "setControlBindingsDisabled" o = ObjectSetControlBindingsDisabledMethodInfo
+    ResolveDeviceProviderMethod "setControlRate" o = ObjectSetControlRateMethodInfo
+    ResolveDeviceProviderMethod "setData" o = GObject.ObjectSetDataMethodInfo
+    ResolveDeviceProviderMethod "setName" o = ObjectSetNameMethodInfo
+    ResolveDeviceProviderMethod "setParent" o = ObjectSetParentMethodInfo
+    ResolveDeviceProviderMethod "setProperty" o = GObject.ObjectSetPropertyMethodInfo
+    ResolveDeviceProviderMethod l o = MethodResolutionFailed l o
+
+instance (info ~ ResolveDeviceProviderMethod t DeviceProvider, MethodInfo info DeviceProvider p) => IsLabelProxy t (DeviceProvider -> p) where
+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)
+
+#if MIN_VERSION_base(4,9,0)
+instance (info ~ ResolveDeviceProviderMethod t DeviceProvider, MethodInfo info DeviceProvider p) => IsLabel t (DeviceProvider -> p) where
+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)
+#endif
+
+-- signal DeviceProvider::provider-hidden
+type DeviceProviderProviderHiddenCallback =
+    T.Text ->
+    IO ()
+
+noDeviceProviderProviderHiddenCallback :: Maybe DeviceProviderProviderHiddenCallback
+noDeviceProviderProviderHiddenCallback = Nothing
+
+type DeviceProviderProviderHiddenCallbackC =
+    Ptr () ->                               -- object
+    CString ->
+    Ptr () ->                               -- user_data
+    IO ()
+
+foreign import ccall "wrapper"
+    mkDeviceProviderProviderHiddenCallback :: DeviceProviderProviderHiddenCallbackC -> IO (FunPtr DeviceProviderProviderHiddenCallbackC)
+
+deviceProviderProviderHiddenClosure :: DeviceProviderProviderHiddenCallback -> IO Closure
+deviceProviderProviderHiddenClosure cb = newCClosure =<< mkDeviceProviderProviderHiddenCallback wrapped
+    where wrapped = deviceProviderProviderHiddenCallbackWrapper cb
+
+deviceProviderProviderHiddenCallbackWrapper ::
+    DeviceProviderProviderHiddenCallback ->
+    Ptr () ->
+    CString ->
+    Ptr () ->
+    IO ()
+deviceProviderProviderHiddenCallbackWrapper _cb _ object _ = do
+    object' <- cstringToText object
+    _cb  object'
+
+onDeviceProviderProviderHidden :: (GObject a, MonadIO m) => a -> DeviceProviderProviderHiddenCallback -> m SignalHandlerId
+onDeviceProviderProviderHidden obj cb = liftIO $ connectDeviceProviderProviderHidden obj cb SignalConnectBefore
+afterDeviceProviderProviderHidden :: (GObject a, MonadIO m) => a -> DeviceProviderProviderHiddenCallback -> m SignalHandlerId
+afterDeviceProviderProviderHidden obj cb = connectDeviceProviderProviderHidden obj cb SignalConnectAfter
+
+connectDeviceProviderProviderHidden :: (GObject a, MonadIO m) =>
+                                       a -> DeviceProviderProviderHiddenCallback -> SignalConnectMode -> m SignalHandlerId
+connectDeviceProviderProviderHidden obj cb after = liftIO $ do
+    cb' <- mkDeviceProviderProviderHiddenCallback (deviceProviderProviderHiddenCallbackWrapper cb)
+    connectSignalFunPtr obj "provider-hidden" cb' after
+
+-- signal DeviceProvider::provider-unhidden
+type DeviceProviderProviderUnhiddenCallback =
+    T.Text ->
+    IO ()
+
+noDeviceProviderProviderUnhiddenCallback :: Maybe DeviceProviderProviderUnhiddenCallback
+noDeviceProviderProviderUnhiddenCallback = Nothing
+
+type DeviceProviderProviderUnhiddenCallbackC =
+    Ptr () ->                               -- object
+    CString ->
+    Ptr () ->                               -- user_data
+    IO ()
+
+foreign import ccall "wrapper"
+    mkDeviceProviderProviderUnhiddenCallback :: DeviceProviderProviderUnhiddenCallbackC -> IO (FunPtr DeviceProviderProviderUnhiddenCallbackC)
+
+deviceProviderProviderUnhiddenClosure :: DeviceProviderProviderUnhiddenCallback -> IO Closure
+deviceProviderProviderUnhiddenClosure cb = newCClosure =<< mkDeviceProviderProviderUnhiddenCallback wrapped
+    where wrapped = deviceProviderProviderUnhiddenCallbackWrapper cb
+
+deviceProviderProviderUnhiddenCallbackWrapper ::
+    DeviceProviderProviderUnhiddenCallback ->
+    Ptr () ->
+    CString ->
+    Ptr () ->
+    IO ()
+deviceProviderProviderUnhiddenCallbackWrapper _cb _ object _ = do
+    object' <- cstringToText object
+    _cb  object'
+
+onDeviceProviderProviderUnhidden :: (GObject a, MonadIO m) => a -> DeviceProviderProviderUnhiddenCallback -> m SignalHandlerId
+onDeviceProviderProviderUnhidden obj cb = liftIO $ connectDeviceProviderProviderUnhidden obj cb SignalConnectBefore
+afterDeviceProviderProviderUnhidden :: (GObject a, MonadIO m) => a -> DeviceProviderProviderUnhiddenCallback -> m SignalHandlerId
+afterDeviceProviderProviderUnhidden obj cb = connectDeviceProviderProviderUnhidden obj cb SignalConnectAfter
+
+connectDeviceProviderProviderUnhidden :: (GObject a, MonadIO m) =>
+                                         a -> DeviceProviderProviderUnhiddenCallback -> SignalConnectMode -> m SignalHandlerId
+connectDeviceProviderProviderUnhidden obj cb after = liftIO $ do
+    cb' <- mkDeviceProviderProviderUnhiddenCallback (deviceProviderProviderUnhiddenCallbackWrapper cb)
+    connectSignalFunPtr obj "provider-unhidden" cb' after
+
+type instance AttributeList DeviceProvider = DeviceProviderAttributeList
+type DeviceProviderAttributeList = ('[ '("name", ObjectNamePropertyInfo), '("parent", ObjectParentPropertyInfo)] :: [(Symbol, *)])
+
+data DeviceProviderProviderHiddenSignalInfo
+instance SignalInfo DeviceProviderProviderHiddenSignalInfo where
+    type HaskellCallbackType DeviceProviderProviderHiddenSignalInfo = DeviceProviderProviderHiddenCallback
+    connectSignal _ = connectDeviceProviderProviderHidden
+
+data DeviceProviderProviderUnhiddenSignalInfo
+instance SignalInfo DeviceProviderProviderUnhiddenSignalInfo where
+    type HaskellCallbackType DeviceProviderProviderUnhiddenSignalInfo = DeviceProviderProviderUnhiddenCallback
+    connectSignal _ = connectDeviceProviderProviderUnhidden
+
+type instance SignalList DeviceProvider = DeviceProviderSignalList
+type DeviceProviderSignalList = ('[ '("deepNotify", ObjectDeepNotifySignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("providerHidden", DeviceProviderProviderHiddenSignalInfo), '("providerUnhidden", DeviceProviderProviderUnhiddenSignalInfo)] :: [(Symbol, *)])
+
+-- method DeviceProvider::can_monitor
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DeviceProvider", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_device_provider_can_monitor" gst_device_provider_can_monitor :: 
+    Ptr DeviceProvider ->                   -- _obj : TInterface "Gst" "DeviceProvider"
+    IO CInt
+
+
+deviceProviderCanMonitor ::
+    (MonadIO m, DeviceProviderK a) =>
+    a                                       -- _obj
+    -> m Bool                               -- result
+deviceProviderCanMonitor _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_device_provider_can_monitor _obj'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data DeviceProviderCanMonitorMethodInfo
+instance (signature ~ (m Bool), MonadIO m, DeviceProviderK a) => MethodInfo DeviceProviderCanMonitorMethodInfo a signature where
+    overloadedMethod _ = deviceProviderCanMonitor
+
+-- method DeviceProvider::device_add
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DeviceProvider", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "device", argType = TInterface "Gst" "Device", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_device_provider_device_add" gst_device_provider_device_add :: 
+    Ptr DeviceProvider ->                   -- _obj : TInterface "Gst" "DeviceProvider"
+    Ptr Device ->                           -- device : TInterface "Gst" "Device"
+    IO ()
+
+
+deviceProviderDeviceAdd ::
+    (MonadIO m, DeviceProviderK a, DeviceK b) =>
+    a                                       -- _obj
+    -> b                                    -- device
+    -> m ()                                 -- result
+deviceProviderDeviceAdd _obj device = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    device' <- refObject device
+    gst_device_provider_device_add _obj' device'
+    touchManagedPtr _obj
+    touchManagedPtr device
+    return ()
+
+data DeviceProviderDeviceAddMethodInfo
+instance (signature ~ (b -> m ()), MonadIO m, DeviceProviderK a, DeviceK b) => MethodInfo DeviceProviderDeviceAddMethodInfo a signature where
+    overloadedMethod _ = deviceProviderDeviceAdd
+
+-- method DeviceProvider::device_remove
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DeviceProvider", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "device", argType = TInterface "Gst" "Device", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_device_provider_device_remove" gst_device_provider_device_remove :: 
+    Ptr DeviceProvider ->                   -- _obj : TInterface "Gst" "DeviceProvider"
+    Ptr Device ->                           -- device : TInterface "Gst" "Device"
+    IO ()
+
+
+deviceProviderDeviceRemove ::
+    (MonadIO m, DeviceProviderK a, DeviceK b) =>
+    a                                       -- _obj
+    -> b                                    -- device
+    -> m ()                                 -- result
+deviceProviderDeviceRemove _obj device = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let device' = unsafeManagedPtrCastPtr device
+    gst_device_provider_device_remove _obj' device'
+    touchManagedPtr _obj
+    touchManagedPtr device
+    return ()
+
+data DeviceProviderDeviceRemoveMethodInfo
+instance (signature ~ (b -> m ()), MonadIO m, DeviceProviderK a, DeviceK b) => MethodInfo DeviceProviderDeviceRemoveMethodInfo a signature where
+    overloadedMethod _ = deviceProviderDeviceRemove
+
+-- method DeviceProvider::get_bus
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DeviceProvider", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Bus"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_device_provider_get_bus" gst_device_provider_get_bus :: 
+    Ptr DeviceProvider ->                   -- _obj : TInterface "Gst" "DeviceProvider"
+    IO (Ptr Bus)
+
+
+deviceProviderGetBus ::
+    (MonadIO m, DeviceProviderK a) =>
+    a                                       -- _obj
+    -> m Bus                                -- result
+deviceProviderGetBus _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_device_provider_get_bus _obj'
+    checkUnexpectedReturnNULL "gst_device_provider_get_bus" result
+    result' <- (wrapObject Bus) result
+    touchManagedPtr _obj
+    return result'
+
+data DeviceProviderGetBusMethodInfo
+instance (signature ~ (m Bus), MonadIO m, DeviceProviderK a) => MethodInfo DeviceProviderGetBusMethodInfo a signature where
+    overloadedMethod _ = deviceProviderGetBus
+
+-- method DeviceProvider::get_devices
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DeviceProvider", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TGList (TInterface "Gst" "Device")
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_device_provider_get_devices" gst_device_provider_get_devices :: 
+    Ptr DeviceProvider ->                   -- _obj : TInterface "Gst" "DeviceProvider"
+    IO (Ptr (GList (Ptr Device)))
+
+
+deviceProviderGetDevices ::
+    (MonadIO m, DeviceProviderK a) =>
+    a                                       -- _obj
+    -> m [Device]                           -- result
+deviceProviderGetDevices _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_device_provider_get_devices _obj'
+    checkUnexpectedReturnNULL "gst_device_provider_get_devices" result
+    result' <- unpackGList result
+    result'' <- mapM (wrapObject Device) result'
+    g_list_free result
+    touchManagedPtr _obj
+    return result''
+
+data DeviceProviderGetDevicesMethodInfo
+instance (signature ~ (m [Device]), MonadIO m, DeviceProviderK a) => MethodInfo DeviceProviderGetDevicesMethodInfo a signature where
+    overloadedMethod _ = deviceProviderGetDevices
+
+-- method DeviceProvider::get_factory
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DeviceProvider", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "DeviceProviderFactory"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_device_provider_get_factory" gst_device_provider_get_factory :: 
+    Ptr DeviceProvider ->                   -- _obj : TInterface "Gst" "DeviceProvider"
+    IO (Ptr DeviceProviderFactory)
+
+
+deviceProviderGetFactory ::
+    (MonadIO m, DeviceProviderK a) =>
+    a                                       -- _obj
+    -> m DeviceProviderFactory              -- result
+deviceProviderGetFactory _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_device_provider_get_factory _obj'
+    checkUnexpectedReturnNULL "gst_device_provider_get_factory" result
+    result' <- (newObject DeviceProviderFactory) result
+    touchManagedPtr _obj
+    return result'
+
+data DeviceProviderGetFactoryMethodInfo
+instance (signature ~ (m DeviceProviderFactory), MonadIO m, DeviceProviderK a) => MethodInfo DeviceProviderGetFactoryMethodInfo a signature where
+    overloadedMethod _ = deviceProviderGetFactory
+
+-- method DeviceProvider::get_hidden_providers
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DeviceProvider", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TCArray True (-1) (-1) (TBasicType TUTF8)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_device_provider_get_hidden_providers" gst_device_provider_get_hidden_providers :: 
+    Ptr DeviceProvider ->                   -- _obj : TInterface "Gst" "DeviceProvider"
+    IO (Ptr CString)
+
+
+deviceProviderGetHiddenProviders ::
+    (MonadIO m, DeviceProviderK a) =>
+    a                                       -- _obj
+    -> m [T.Text]                           -- result
+deviceProviderGetHiddenProviders _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_device_provider_get_hidden_providers _obj'
+    checkUnexpectedReturnNULL "gst_device_provider_get_hidden_providers" result
+    result' <- unpackZeroTerminatedUTF8CArray result
+    mapZeroTerminatedCArray freeMem result
+    freeMem result
+    touchManagedPtr _obj
+    return result'
+
+data DeviceProviderGetHiddenProvidersMethodInfo
+instance (signature ~ (m [T.Text]), MonadIO m, DeviceProviderK a) => MethodInfo DeviceProviderGetHiddenProvidersMethodInfo a signature where
+    overloadedMethod _ = deviceProviderGetHiddenProviders
+
+-- method DeviceProvider::hide_provider
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DeviceProvider", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_device_provider_hide_provider" gst_device_provider_hide_provider :: 
+    Ptr DeviceProvider ->                   -- _obj : TInterface "Gst" "DeviceProvider"
+    CString ->                              -- name : TBasicType TUTF8
+    IO ()
+
+
+deviceProviderHideProvider ::
+    (MonadIO m, DeviceProviderK a) =>
+    a                                       -- _obj
+    -> T.Text                               -- name
+    -> m ()                                 -- result
+deviceProviderHideProvider _obj name = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    name' <- textToCString name
+    gst_device_provider_hide_provider _obj' name'
+    touchManagedPtr _obj
+    freeMem name'
+    return ()
+
+data DeviceProviderHideProviderMethodInfo
+instance (signature ~ (T.Text -> m ()), MonadIO m, DeviceProviderK a) => MethodInfo DeviceProviderHideProviderMethodInfo a signature where
+    overloadedMethod _ = deviceProviderHideProvider
+
+-- method DeviceProvider::start
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DeviceProvider", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_device_provider_start" gst_device_provider_start :: 
+    Ptr DeviceProvider ->                   -- _obj : TInterface "Gst" "DeviceProvider"
+    IO CInt
+
+
+deviceProviderStart ::
+    (MonadIO m, DeviceProviderK a) =>
+    a                                       -- _obj
+    -> m Bool                               -- result
+deviceProviderStart _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_device_provider_start _obj'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data DeviceProviderStartMethodInfo
+instance (signature ~ (m Bool), MonadIO m, DeviceProviderK a) => MethodInfo DeviceProviderStartMethodInfo a signature where
+    overloadedMethod _ = deviceProviderStart
+
+-- method DeviceProvider::stop
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DeviceProvider", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_device_provider_stop" gst_device_provider_stop :: 
+    Ptr DeviceProvider ->                   -- _obj : TInterface "Gst" "DeviceProvider"
+    IO ()
+
+
+deviceProviderStop ::
+    (MonadIO m, DeviceProviderK a) =>
+    a                                       -- _obj
+    -> m ()                                 -- result
+deviceProviderStop _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    gst_device_provider_stop _obj'
+    touchManagedPtr _obj
+    return ()
+
+data DeviceProviderStopMethodInfo
+instance (signature ~ (m ()), MonadIO m, DeviceProviderK a) => MethodInfo DeviceProviderStopMethodInfo a signature where
+    overloadedMethod _ = deviceProviderStop
+
+-- method DeviceProvider::unhide_provider
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DeviceProvider", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_device_provider_unhide_provider" gst_device_provider_unhide_provider :: 
+    Ptr DeviceProvider ->                   -- _obj : TInterface "Gst" "DeviceProvider"
+    CString ->                              -- name : TBasicType TUTF8
+    IO ()
+
+
+deviceProviderUnhideProvider ::
+    (MonadIO m, DeviceProviderK a) =>
+    a                                       -- _obj
+    -> T.Text                               -- name
+    -> m ()                                 -- result
+deviceProviderUnhideProvider _obj name = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    name' <- textToCString name
+    gst_device_provider_unhide_provider _obj' name'
+    touchManagedPtr _obj
+    freeMem name'
+    return ()
+
+data DeviceProviderUnhideProviderMethodInfo
+instance (signature ~ (T.Text -> m ()), MonadIO m, DeviceProviderK a) => MethodInfo DeviceProviderUnhideProviderMethodInfo a signature where
+    overloadedMethod _ = deviceProviderUnhideProvider
+
+-- method DeviceProvider::register
+-- method type : MemberFunction
+-- Args : [Arg {argCName = "plugin", argType = TInterface "Gst" "Plugin", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "rank", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "type", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_device_provider_register" gst_device_provider_register :: 
+    Ptr Plugin ->                           -- plugin : TInterface "Gst" "Plugin"
+    CString ->                              -- name : TBasicType TUTF8
+    Word32 ->                               -- rank : TBasicType TUInt32
+    CGType ->                               -- type : TBasicType TGType
+    IO CInt
+
+
+deviceProviderRegister ::
+    (MonadIO m, PluginK a) =>
+    Maybe (a)                               -- plugin
+    -> T.Text                               -- name
+    -> Word32                               -- rank
+    -> GType                                -- type_
+    -> m Bool                               -- result
+deviceProviderRegister plugin name rank type_ = liftIO $ do
+    maybePlugin <- case plugin of
+        Nothing -> return nullPtr
+        Just jPlugin -> do
+            let jPlugin' = unsafeManagedPtrCastPtr jPlugin
+            return jPlugin'
+    name' <- textToCString name
+    let type_' = gtypeToCGType type_
+    result <- gst_device_provider_register maybePlugin name' rank type_'
+    let result' = (/= 0) result
+    whenJust plugin touchManagedPtr
+    freeMem name'
+    return result'
+
+
diff --git a/GI/Gst/Objects/DeviceProvider.hs-boot b/GI/Gst/Objects/DeviceProvider.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Objects/DeviceProvider.hs-boot
@@ -0,0 +1,26 @@
+module GI.Gst.Objects.DeviceProvider where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+newtype DeviceProvider = DeviceProvider (ForeignPtr DeviceProvider)
+instance GObject DeviceProvider where
+class GObject o => DeviceProviderK o
+instance (GObject o, IsDescendantOf DeviceProvider o) => DeviceProviderK o
+data DeviceProviderProviderHiddenSignalInfo
+data DeviceProviderProviderUnhiddenSignalInfo
+data DeviceProviderCanMonitorMethodInfo
+data DeviceProviderDeviceAddMethodInfo
+data DeviceProviderDeviceRemoveMethodInfo
+data DeviceProviderGetBusMethodInfo
+data DeviceProviderGetDevicesMethodInfo
+data DeviceProviderGetFactoryMethodInfo
+data DeviceProviderGetHiddenProvidersMethodInfo
+data DeviceProviderHideProviderMethodInfo
+data DeviceProviderStartMethodInfo
+data DeviceProviderStopMethodInfo
+data DeviceProviderUnhideProviderMethodInfo
diff --git a/GI/Gst/Objects/DeviceProviderFactory.hs b/GI/Gst/Objects/DeviceProviderFactory.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Objects/DeviceProviderFactory.hs
@@ -0,0 +1,440 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+-}
+
+module GI.Gst.Objects.DeviceProviderFactory
+    ( 
+
+-- * Exported types
+    DeviceProviderFactory(..)               ,
+    DeviceProviderFactoryK                  ,
+    toDeviceProviderFactory                 ,
+    noDeviceProviderFactory                 ,
+
+
+ -- * Methods
+-- ** deviceProviderFactoryFind
+    deviceProviderFactoryFind               ,
+
+
+-- ** deviceProviderFactoryGet
+    DeviceProviderFactoryGetMethodInfo      ,
+    deviceProviderFactoryGet                ,
+
+
+-- ** deviceProviderFactoryGetByName
+    deviceProviderFactoryGetByName          ,
+
+
+-- ** deviceProviderFactoryGetDeviceProviderType
+    DeviceProviderFactoryGetDeviceProviderTypeMethodInfo,
+    deviceProviderFactoryGetDeviceProviderType,
+
+
+-- ** deviceProviderFactoryGetMetadata
+    DeviceProviderFactoryGetMetadataMethodInfo,
+    deviceProviderFactoryGetMetadata        ,
+
+
+-- ** deviceProviderFactoryGetMetadataKeys
+    DeviceProviderFactoryGetMetadataKeysMethodInfo,
+    deviceProviderFactoryGetMetadataKeys    ,
+
+
+-- ** deviceProviderFactoryHasClasses
+    DeviceProviderFactoryHasClassesMethodInfo,
+    deviceProviderFactoryHasClasses         ,
+
+
+-- ** deviceProviderFactoryHasClassesv
+    DeviceProviderFactoryHasClassesvMethodInfo,
+    deviceProviderFactoryHasClassesv        ,
+
+
+-- ** deviceProviderFactoryListGetDeviceProviders
+    deviceProviderFactoryListGetDeviceProviders,
+
+
+
+
+    ) where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+import GI.Gst.Callbacks
+import qualified GI.GObject as GObject
+
+newtype DeviceProviderFactory = DeviceProviderFactory (ForeignPtr DeviceProviderFactory)
+foreign import ccall "gst_device_provider_factory_get_type"
+    c_gst_device_provider_factory_get_type :: IO GType
+
+type instance ParentTypes DeviceProviderFactory = DeviceProviderFactoryParentTypes
+type DeviceProviderFactoryParentTypes = '[PluginFeature, Object, GObject.Object]
+
+instance GObject DeviceProviderFactory where
+    gobjectIsInitiallyUnowned _ = True
+    gobjectType _ = c_gst_device_provider_factory_get_type
+    
+
+class GObject o => DeviceProviderFactoryK o
+instance (GObject o, IsDescendantOf DeviceProviderFactory o) => DeviceProviderFactoryK o
+
+toDeviceProviderFactory :: DeviceProviderFactoryK o => o -> IO DeviceProviderFactory
+toDeviceProviderFactory = unsafeCastTo DeviceProviderFactory
+
+noDeviceProviderFactory :: Maybe DeviceProviderFactory
+noDeviceProviderFactory = Nothing
+
+type family ResolveDeviceProviderFactoryMethod (t :: Symbol) (o :: *) :: * where
+    ResolveDeviceProviderFactoryMethod "addControlBinding" o = ObjectAddControlBindingMethodInfo
+    ResolveDeviceProviderFactoryMethod "bindProperty" o = GObject.ObjectBindPropertyMethodInfo
+    ResolveDeviceProviderFactoryMethod "bindPropertyFull" o = GObject.ObjectBindPropertyFullMethodInfo
+    ResolveDeviceProviderFactoryMethod "checkVersion" o = PluginFeatureCheckVersionMethodInfo
+    ResolveDeviceProviderFactoryMethod "defaultError" o = ObjectDefaultErrorMethodInfo
+    ResolveDeviceProviderFactoryMethod "forceFloating" o = GObject.ObjectForceFloatingMethodInfo
+    ResolveDeviceProviderFactoryMethod "freezeNotify" o = GObject.ObjectFreezeNotifyMethodInfo
+    ResolveDeviceProviderFactoryMethod "get" o = DeviceProviderFactoryGetMethodInfo
+    ResolveDeviceProviderFactoryMethod "hasActiveControlBindings" o = ObjectHasActiveControlBindingsMethodInfo
+    ResolveDeviceProviderFactoryMethod "hasAncestor" o = ObjectHasAncestorMethodInfo
+    ResolveDeviceProviderFactoryMethod "hasAsAncestor" o = ObjectHasAsAncestorMethodInfo
+    ResolveDeviceProviderFactoryMethod "hasAsParent" o = ObjectHasAsParentMethodInfo
+    ResolveDeviceProviderFactoryMethod "hasClasses" o = DeviceProviderFactoryHasClassesMethodInfo
+    ResolveDeviceProviderFactoryMethod "hasClassesv" o = DeviceProviderFactoryHasClassesvMethodInfo
+    ResolveDeviceProviderFactoryMethod "isFloating" o = GObject.ObjectIsFloatingMethodInfo
+    ResolveDeviceProviderFactoryMethod "load" o = PluginFeatureLoadMethodInfo
+    ResolveDeviceProviderFactoryMethod "notify" o = GObject.ObjectNotifyMethodInfo
+    ResolveDeviceProviderFactoryMethod "notifyByPspec" o = GObject.ObjectNotifyByPspecMethodInfo
+    ResolveDeviceProviderFactoryMethod "refSink" o = GObject.ObjectRefSinkMethodInfo
+    ResolveDeviceProviderFactoryMethod "removeControlBinding" o = ObjectRemoveControlBindingMethodInfo
+    ResolveDeviceProviderFactoryMethod "replaceData" o = GObject.ObjectReplaceDataMethodInfo
+    ResolveDeviceProviderFactoryMethod "replaceQdata" o = GObject.ObjectReplaceQdataMethodInfo
+    ResolveDeviceProviderFactoryMethod "runDispose" o = GObject.ObjectRunDisposeMethodInfo
+    ResolveDeviceProviderFactoryMethod "stealData" o = GObject.ObjectStealDataMethodInfo
+    ResolveDeviceProviderFactoryMethod "stealQdata" o = GObject.ObjectStealQdataMethodInfo
+    ResolveDeviceProviderFactoryMethod "suggestNextSync" o = ObjectSuggestNextSyncMethodInfo
+    ResolveDeviceProviderFactoryMethod "syncValues" o = ObjectSyncValuesMethodInfo
+    ResolveDeviceProviderFactoryMethod "thawNotify" o = GObject.ObjectThawNotifyMethodInfo
+    ResolveDeviceProviderFactoryMethod "unparent" o = ObjectUnparentMethodInfo
+    ResolveDeviceProviderFactoryMethod "watchClosure" o = GObject.ObjectWatchClosureMethodInfo
+    ResolveDeviceProviderFactoryMethod "getControlBinding" o = ObjectGetControlBindingMethodInfo
+    ResolveDeviceProviderFactoryMethod "getControlRate" o = ObjectGetControlRateMethodInfo
+    ResolveDeviceProviderFactoryMethod "getData" o = GObject.ObjectGetDataMethodInfo
+    ResolveDeviceProviderFactoryMethod "getDeviceProviderType" o = DeviceProviderFactoryGetDeviceProviderTypeMethodInfo
+    ResolveDeviceProviderFactoryMethod "getGValueArray" o = ObjectGetGValueArrayMethodInfo
+    ResolveDeviceProviderFactoryMethod "getMetadata" o = DeviceProviderFactoryGetMetadataMethodInfo
+    ResolveDeviceProviderFactoryMethod "getMetadataKeys" o = DeviceProviderFactoryGetMetadataKeysMethodInfo
+    ResolveDeviceProviderFactoryMethod "getName" o = ObjectGetNameMethodInfo
+    ResolveDeviceProviderFactoryMethod "getParent" o = ObjectGetParentMethodInfo
+    ResolveDeviceProviderFactoryMethod "getPathString" o = ObjectGetPathStringMethodInfo
+    ResolveDeviceProviderFactoryMethod "getPlugin" o = PluginFeatureGetPluginMethodInfo
+    ResolveDeviceProviderFactoryMethod "getPluginName" o = PluginFeatureGetPluginNameMethodInfo
+    ResolveDeviceProviderFactoryMethod "getProperty" o = GObject.ObjectGetPropertyMethodInfo
+    ResolveDeviceProviderFactoryMethod "getQdata" o = GObject.ObjectGetQdataMethodInfo
+    ResolveDeviceProviderFactoryMethod "getRank" o = PluginFeatureGetRankMethodInfo
+    ResolveDeviceProviderFactoryMethod "getValue" o = ObjectGetValueMethodInfo
+    ResolveDeviceProviderFactoryMethod "getValueArray" o = ObjectGetValueArrayMethodInfo
+    ResolveDeviceProviderFactoryMethod "setControlBindingDisabled" o = ObjectSetControlBindingDisabledMethodInfo
+    ResolveDeviceProviderFactoryMethod "setControlBindingsDisabled" o = ObjectSetControlBindingsDisabledMethodInfo
+    ResolveDeviceProviderFactoryMethod "setControlRate" o = ObjectSetControlRateMethodInfo
+    ResolveDeviceProviderFactoryMethod "setData" o = GObject.ObjectSetDataMethodInfo
+    ResolveDeviceProviderFactoryMethod "setName" o = ObjectSetNameMethodInfo
+    ResolveDeviceProviderFactoryMethod "setParent" o = ObjectSetParentMethodInfo
+    ResolveDeviceProviderFactoryMethod "setProperty" o = GObject.ObjectSetPropertyMethodInfo
+    ResolveDeviceProviderFactoryMethod "setRank" o = PluginFeatureSetRankMethodInfo
+    ResolveDeviceProviderFactoryMethod l o = MethodResolutionFailed l o
+
+instance (info ~ ResolveDeviceProviderFactoryMethod t DeviceProviderFactory, MethodInfo info DeviceProviderFactory p) => IsLabelProxy t (DeviceProviderFactory -> p) where
+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)
+
+#if MIN_VERSION_base(4,9,0)
+instance (info ~ ResolveDeviceProviderFactoryMethod t DeviceProviderFactory, MethodInfo info DeviceProviderFactory p) => IsLabel t (DeviceProviderFactory -> p) where
+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)
+#endif
+
+type instance AttributeList DeviceProviderFactory = DeviceProviderFactoryAttributeList
+type DeviceProviderFactoryAttributeList = ('[ '("name", ObjectNamePropertyInfo), '("parent", ObjectParentPropertyInfo)] :: [(Symbol, *)])
+
+type instance SignalList DeviceProviderFactory = DeviceProviderFactorySignalList
+type DeviceProviderFactorySignalList = ('[ '("deepNotify", ObjectDeepNotifySignalInfo), '("notify", GObject.ObjectNotifySignalInfo)] :: [(Symbol, *)])
+
+-- method DeviceProviderFactory::get
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DeviceProviderFactory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "DeviceProvider"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_device_provider_factory_get" gst_device_provider_factory_get :: 
+    Ptr DeviceProviderFactory ->            -- _obj : TInterface "Gst" "DeviceProviderFactory"
+    IO (Ptr DeviceProvider)
+
+
+deviceProviderFactoryGet ::
+    (MonadIO m, DeviceProviderFactoryK a) =>
+    a                                       -- _obj
+    -> m DeviceProvider                     -- result
+deviceProviderFactoryGet _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_device_provider_factory_get _obj'
+    checkUnexpectedReturnNULL "gst_device_provider_factory_get" result
+    result' <- (wrapObject DeviceProvider) result
+    touchManagedPtr _obj
+    return result'
+
+data DeviceProviderFactoryGetMethodInfo
+instance (signature ~ (m DeviceProvider), MonadIO m, DeviceProviderFactoryK a) => MethodInfo DeviceProviderFactoryGetMethodInfo a signature where
+    overloadedMethod _ = deviceProviderFactoryGet
+
+-- method DeviceProviderFactory::get_device_provider_type
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DeviceProviderFactory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TGType
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_device_provider_factory_get_device_provider_type" gst_device_provider_factory_get_device_provider_type :: 
+    Ptr DeviceProviderFactory ->            -- _obj : TInterface "Gst" "DeviceProviderFactory"
+    IO CGType
+
+
+deviceProviderFactoryGetDeviceProviderType ::
+    (MonadIO m, DeviceProviderFactoryK a) =>
+    a                                       -- _obj
+    -> m GType                              -- result
+deviceProviderFactoryGetDeviceProviderType _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_device_provider_factory_get_device_provider_type _obj'
+    let result' = GType result
+    touchManagedPtr _obj
+    return result'
+
+data DeviceProviderFactoryGetDeviceProviderTypeMethodInfo
+instance (signature ~ (m GType), MonadIO m, DeviceProviderFactoryK a) => MethodInfo DeviceProviderFactoryGetDeviceProviderTypeMethodInfo a signature where
+    overloadedMethod _ = deviceProviderFactoryGetDeviceProviderType
+
+-- method DeviceProviderFactory::get_metadata
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DeviceProviderFactory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUTF8
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_device_provider_factory_get_metadata" gst_device_provider_factory_get_metadata :: 
+    Ptr DeviceProviderFactory ->            -- _obj : TInterface "Gst" "DeviceProviderFactory"
+    CString ->                              -- key : TBasicType TUTF8
+    IO CString
+
+
+deviceProviderFactoryGetMetadata ::
+    (MonadIO m, DeviceProviderFactoryK a) =>
+    a                                       -- _obj
+    -> T.Text                               -- key
+    -> m T.Text                             -- result
+deviceProviderFactoryGetMetadata _obj key = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    key' <- textToCString key
+    result <- gst_device_provider_factory_get_metadata _obj' key'
+    checkUnexpectedReturnNULL "gst_device_provider_factory_get_metadata" result
+    result' <- cstringToText result
+    touchManagedPtr _obj
+    freeMem key'
+    return result'
+
+data DeviceProviderFactoryGetMetadataMethodInfo
+instance (signature ~ (T.Text -> m T.Text), MonadIO m, DeviceProviderFactoryK a) => MethodInfo DeviceProviderFactoryGetMetadataMethodInfo a signature where
+    overloadedMethod _ = deviceProviderFactoryGetMetadata
+
+-- method DeviceProviderFactory::get_metadata_keys
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DeviceProviderFactory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TCArray True (-1) (-1) (TBasicType TUTF8)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_device_provider_factory_get_metadata_keys" gst_device_provider_factory_get_metadata_keys :: 
+    Ptr DeviceProviderFactory ->            -- _obj : TInterface "Gst" "DeviceProviderFactory"
+    IO (Ptr CString)
+
+
+deviceProviderFactoryGetMetadataKeys ::
+    (MonadIO m, DeviceProviderFactoryK a) =>
+    a                                       -- _obj
+    -> m [T.Text]                           -- result
+deviceProviderFactoryGetMetadataKeys _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_device_provider_factory_get_metadata_keys _obj'
+    checkUnexpectedReturnNULL "gst_device_provider_factory_get_metadata_keys" result
+    result' <- unpackZeroTerminatedUTF8CArray result
+    mapZeroTerminatedCArray freeMem result
+    freeMem result
+    touchManagedPtr _obj
+    return result'
+
+data DeviceProviderFactoryGetMetadataKeysMethodInfo
+instance (signature ~ (m [T.Text]), MonadIO m, DeviceProviderFactoryK a) => MethodInfo DeviceProviderFactoryGetMetadataKeysMethodInfo a signature where
+    overloadedMethod _ = deviceProviderFactoryGetMetadataKeys
+
+-- method DeviceProviderFactory::has_classes
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DeviceProviderFactory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "classes", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_device_provider_factory_has_classes" gst_device_provider_factory_has_classes :: 
+    Ptr DeviceProviderFactory ->            -- _obj : TInterface "Gst" "DeviceProviderFactory"
+    CString ->                              -- classes : TBasicType TUTF8
+    IO CInt
+
+
+deviceProviderFactoryHasClasses ::
+    (MonadIO m, DeviceProviderFactoryK a) =>
+    a                                       -- _obj
+    -> Maybe (T.Text)                       -- classes
+    -> m Bool                               -- result
+deviceProviderFactoryHasClasses _obj classes = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    maybeClasses <- case classes of
+        Nothing -> return nullPtr
+        Just jClasses -> do
+            jClasses' <- textToCString jClasses
+            return jClasses'
+    result <- gst_device_provider_factory_has_classes _obj' maybeClasses
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    freeMem maybeClasses
+    return result'
+
+data DeviceProviderFactoryHasClassesMethodInfo
+instance (signature ~ (Maybe (T.Text) -> m Bool), MonadIO m, DeviceProviderFactoryK a) => MethodInfo DeviceProviderFactoryHasClassesMethodInfo a signature where
+    overloadedMethod _ = deviceProviderFactoryHasClasses
+
+-- method DeviceProviderFactory::has_classesv
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DeviceProviderFactory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "classes", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_device_provider_factory_has_classesv" gst_device_provider_factory_has_classesv :: 
+    Ptr DeviceProviderFactory ->            -- _obj : TInterface "Gst" "DeviceProviderFactory"
+    Ptr CString ->                          -- classes : TCArray True (-1) (-1) (TBasicType TUTF8)
+    IO CInt
+
+
+deviceProviderFactoryHasClassesv ::
+    (MonadIO m, DeviceProviderFactoryK a) =>
+    a                                       -- _obj
+    -> Maybe ([T.Text])                     -- classes
+    -> m Bool                               -- result
+deviceProviderFactoryHasClassesv _obj classes = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    maybeClasses <- case classes of
+        Nothing -> return nullPtr
+        Just jClasses -> do
+            jClasses' <- packZeroTerminatedUTF8CArray jClasses
+            return jClasses'
+    result <- gst_device_provider_factory_has_classesv _obj' maybeClasses
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    mapZeroTerminatedCArray freeMem maybeClasses
+    freeMem maybeClasses
+    return result'
+
+data DeviceProviderFactoryHasClassesvMethodInfo
+instance (signature ~ (Maybe ([T.Text]) -> m Bool), MonadIO m, DeviceProviderFactoryK a) => MethodInfo DeviceProviderFactoryHasClassesvMethodInfo a signature where
+    overloadedMethod _ = deviceProviderFactoryHasClassesv
+
+-- method DeviceProviderFactory::find
+-- method type : MemberFunction
+-- Args : [Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "DeviceProviderFactory"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_device_provider_factory_find" gst_device_provider_factory_find :: 
+    CString ->                              -- name : TBasicType TUTF8
+    IO (Ptr DeviceProviderFactory)
+
+
+deviceProviderFactoryFind ::
+    (MonadIO m) =>
+    T.Text                                  -- name
+    -> m DeviceProviderFactory              -- result
+deviceProviderFactoryFind name = liftIO $ do
+    name' <- textToCString name
+    result <- gst_device_provider_factory_find name'
+    checkUnexpectedReturnNULL "gst_device_provider_factory_find" result
+    result' <- (wrapObject DeviceProviderFactory) result
+    freeMem name'
+    return result'
+
+-- method DeviceProviderFactory::get_by_name
+-- method type : MemberFunction
+-- Args : [Arg {argCName = "factoryname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "DeviceProvider"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_device_provider_factory_get_by_name" gst_device_provider_factory_get_by_name :: 
+    CString ->                              -- factoryname : TBasicType TUTF8
+    IO (Ptr DeviceProvider)
+
+
+deviceProviderFactoryGetByName ::
+    (MonadIO m) =>
+    T.Text                                  -- factoryname
+    -> m DeviceProvider                     -- result
+deviceProviderFactoryGetByName factoryname = liftIO $ do
+    factoryname' <- textToCString factoryname
+    result <- gst_device_provider_factory_get_by_name factoryname'
+    checkUnexpectedReturnNULL "gst_device_provider_factory_get_by_name" result
+    result' <- (wrapObject DeviceProvider) result
+    freeMem factoryname'
+    return result'
+
+-- method DeviceProviderFactory::list_get_device_providers
+-- method type : MemberFunction
+-- Args : [Arg {argCName = "minrank", argType = TInterface "Gst" "Rank", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TGList (TInterface "Gst" "DeviceProviderFactory")
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_device_provider_factory_list_get_device_providers" gst_device_provider_factory_list_get_device_providers :: 
+    CUInt ->                                -- minrank : TInterface "Gst" "Rank"
+    IO (Ptr (GList (Ptr DeviceProviderFactory)))
+
+
+deviceProviderFactoryListGetDeviceProviders ::
+    (MonadIO m) =>
+    Rank                                    -- minrank
+    -> m [DeviceProviderFactory]            -- result
+deviceProviderFactoryListGetDeviceProviders minrank = liftIO $ do
+    let minrank' = (fromIntegral . fromEnum) minrank
+    result <- gst_device_provider_factory_list_get_device_providers minrank'
+    checkUnexpectedReturnNULL "gst_device_provider_factory_list_get_device_providers" result
+    result' <- unpackGList result
+    result'' <- mapM (wrapObject DeviceProviderFactory) result'
+    g_list_free result
+    return result''
+
+
diff --git a/GI/Gst/Objects/DeviceProviderFactory.hs-boot b/GI/Gst/Objects/DeviceProviderFactory.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Objects/DeviceProviderFactory.hs-boot
@@ -0,0 +1,19 @@
+module GI.Gst.Objects.DeviceProviderFactory where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+newtype DeviceProviderFactory = DeviceProviderFactory (ForeignPtr DeviceProviderFactory)
+instance GObject DeviceProviderFactory where
+class GObject o => DeviceProviderFactoryK o
+instance (GObject o, IsDescendantOf DeviceProviderFactory o) => DeviceProviderFactoryK o
+data DeviceProviderFactoryGetMethodInfo
+data DeviceProviderFactoryGetDeviceProviderTypeMethodInfo
+data DeviceProviderFactoryGetMetadataMethodInfo
+data DeviceProviderFactoryGetMetadataKeysMethodInfo
+data DeviceProviderFactoryHasClassesMethodInfo
+data DeviceProviderFactoryHasClassesvMethodInfo
diff --git a/GI/Gst/Objects/Element.hs b/GI/Gst/Objects/Element.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Objects/Element.hs
@@ -0,0 +1,2399 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+-}
+
+module GI.Gst.Objects.Element
+    ( 
+
+-- * Exported types
+    Element(..)                             ,
+    ElementK                                ,
+    toElement                               ,
+    noElement                               ,
+
+
+ -- * Methods
+-- ** elementAbortState
+    ElementAbortStateMethodInfo             ,
+    elementAbortState                       ,
+
+
+-- ** elementAddPad
+    ElementAddPadMethodInfo                 ,
+    elementAddPad                           ,
+
+
+-- ** elementChangeState
+    ElementChangeStateMethodInfo            ,
+    elementChangeState                      ,
+
+
+-- ** elementContinueState
+    ElementContinueStateMethodInfo          ,
+    elementContinueState                    ,
+
+
+-- ** elementCreateAllPads
+    ElementCreateAllPadsMethodInfo          ,
+    elementCreateAllPads                    ,
+
+
+-- ** elementGetBaseTime
+    ElementGetBaseTimeMethodInfo            ,
+    elementGetBaseTime                      ,
+
+
+-- ** elementGetBus
+    ElementGetBusMethodInfo                 ,
+    elementGetBus                           ,
+
+
+-- ** elementGetClock
+    ElementGetClockMethodInfo               ,
+    elementGetClock                         ,
+
+
+-- ** elementGetCompatiblePad
+    ElementGetCompatiblePadMethodInfo       ,
+    elementGetCompatiblePad                 ,
+
+
+-- ** elementGetCompatiblePadTemplate
+    ElementGetCompatiblePadTemplateMethodInfo,
+    elementGetCompatiblePadTemplate         ,
+
+
+-- ** elementGetFactory
+    ElementGetFactoryMethodInfo             ,
+    elementGetFactory                       ,
+
+
+-- ** elementGetRequestPad
+    ElementGetRequestPadMethodInfo          ,
+    elementGetRequestPad                    ,
+
+
+-- ** elementGetStartTime
+    ElementGetStartTimeMethodInfo           ,
+    elementGetStartTime                     ,
+
+
+-- ** elementGetState
+    ElementGetStateMethodInfo               ,
+    elementGetState                         ,
+
+
+-- ** elementGetStaticPad
+    ElementGetStaticPadMethodInfo           ,
+    elementGetStaticPad                     ,
+
+
+-- ** elementIsLockedState
+    ElementIsLockedStateMethodInfo          ,
+    elementIsLockedState                    ,
+
+
+-- ** elementIteratePads
+    ElementIteratePadsMethodInfo            ,
+    elementIteratePads                      ,
+
+
+-- ** elementIterateSinkPads
+    ElementIterateSinkPadsMethodInfo        ,
+    elementIterateSinkPads                  ,
+
+
+-- ** elementIterateSrcPads
+    ElementIterateSrcPadsMethodInfo         ,
+    elementIterateSrcPads                   ,
+
+
+-- ** elementLink
+    ElementLinkMethodInfo                   ,
+    elementLink                             ,
+
+
+-- ** elementLinkFiltered
+    ElementLinkFilteredMethodInfo           ,
+    elementLinkFiltered                     ,
+
+
+-- ** elementLinkPads
+    ElementLinkPadsMethodInfo               ,
+    elementLinkPads                         ,
+
+
+-- ** elementLinkPadsFiltered
+    ElementLinkPadsFilteredMethodInfo       ,
+    elementLinkPadsFiltered                 ,
+
+
+-- ** elementLinkPadsFull
+    ElementLinkPadsFullMethodInfo           ,
+    elementLinkPadsFull                     ,
+
+
+-- ** elementLostState
+    ElementLostStateMethodInfo              ,
+    elementLostState                        ,
+
+
+-- ** elementMakeFromUri
+    elementMakeFromUri                      ,
+
+
+-- ** elementMessageFull
+    ElementMessageFullMethodInfo            ,
+    elementMessageFull                      ,
+
+
+-- ** elementNoMorePads
+    ElementNoMorePadsMethodInfo             ,
+    elementNoMorePads                       ,
+
+
+-- ** elementPostMessage
+    ElementPostMessageMethodInfo            ,
+    elementPostMessage                      ,
+
+
+-- ** elementProvideClock
+    ElementProvideClockMethodInfo           ,
+    elementProvideClock                     ,
+
+
+-- ** elementQuery
+    ElementQueryMethodInfo                  ,
+    elementQuery                            ,
+
+
+-- ** elementQueryConvert
+    ElementQueryConvertMethodInfo           ,
+    elementQueryConvert                     ,
+
+
+-- ** elementQueryDuration
+    ElementQueryDurationMethodInfo          ,
+    elementQueryDuration                    ,
+
+
+-- ** elementQueryPosition
+    ElementQueryPositionMethodInfo          ,
+    elementQueryPosition                    ,
+
+
+-- ** elementRegister
+    elementRegister                         ,
+
+
+-- ** elementReleaseRequestPad
+    ElementReleaseRequestPadMethodInfo      ,
+    elementReleaseRequestPad                ,
+
+
+-- ** elementRemovePad
+    ElementRemovePadMethodInfo              ,
+    elementRemovePad                        ,
+
+
+-- ** elementRequestPad
+    ElementRequestPadMethodInfo             ,
+    elementRequestPad                       ,
+
+
+-- ** elementSeek
+    ElementSeekMethodInfo                   ,
+    elementSeek                             ,
+
+
+-- ** elementSeekSimple
+    ElementSeekSimpleMethodInfo             ,
+    elementSeekSimple                       ,
+
+
+-- ** elementSendEvent
+    ElementSendEventMethodInfo              ,
+    elementSendEvent                        ,
+
+
+-- ** elementSetBaseTime
+    ElementSetBaseTimeMethodInfo            ,
+    elementSetBaseTime                      ,
+
+
+-- ** elementSetBus
+    ElementSetBusMethodInfo                 ,
+    elementSetBus                           ,
+
+
+-- ** elementSetClock
+    ElementSetClockMethodInfo               ,
+    elementSetClock                         ,
+
+
+-- ** elementSetContext
+    ElementSetContextMethodInfo             ,
+    elementSetContext                       ,
+
+
+-- ** elementSetLockedState
+    ElementSetLockedStateMethodInfo         ,
+    elementSetLockedState                   ,
+
+
+-- ** elementSetStartTime
+    ElementSetStartTimeMethodInfo           ,
+    elementSetStartTime                     ,
+
+
+-- ** elementSetState
+    ElementSetStateMethodInfo               ,
+    elementSetState                         ,
+
+
+-- ** elementStateChangeReturnGetName
+    elementStateChangeReturnGetName         ,
+
+
+-- ** elementStateGetName
+    elementStateGetName                     ,
+
+
+-- ** elementSyncStateWithParent
+    ElementSyncStateWithParentMethodInfo    ,
+    elementSyncStateWithParent              ,
+
+
+-- ** elementUnlink
+    ElementUnlinkMethodInfo                 ,
+    elementUnlink                           ,
+
+
+-- ** elementUnlinkPads
+    ElementUnlinkPadsMethodInfo             ,
+    elementUnlinkPads                       ,
+
+
+
+
+ -- * Signals
+-- ** NoMorePads
+    ElementNoMorePadsCallback               ,
+    ElementNoMorePadsCallbackC              ,
+    ElementNoMorePadsSignalInfo             ,
+    afterElementNoMorePads                  ,
+    elementNoMorePadsCallbackWrapper        ,
+    elementNoMorePadsClosure                ,
+    mkElementNoMorePadsCallback             ,
+    noElementNoMorePadsCallback             ,
+    onElementNoMorePads                     ,
+
+
+-- ** PadAdded
+    ElementPadAddedCallback                 ,
+    ElementPadAddedCallbackC                ,
+    ElementPadAddedSignalInfo               ,
+    afterElementPadAdded                    ,
+    elementPadAddedCallbackWrapper          ,
+    elementPadAddedClosure                  ,
+    mkElementPadAddedCallback               ,
+    noElementPadAddedCallback               ,
+    onElementPadAdded                       ,
+
+
+-- ** PadRemoved
+    ElementPadRemovedCallback               ,
+    ElementPadRemovedCallbackC              ,
+    ElementPadRemovedSignalInfo             ,
+    afterElementPadRemoved                  ,
+    elementPadRemovedCallbackWrapper        ,
+    elementPadRemovedClosure                ,
+    mkElementPadRemovedCallback             ,
+    noElementPadRemovedCallback             ,
+    onElementPadRemoved                     ,
+
+
+
+
+    ) where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+import GI.Gst.Callbacks
+import qualified GI.GObject as GObject
+
+newtype Element = Element (ForeignPtr Element)
+foreign import ccall "gst_element_get_type"
+    c_gst_element_get_type :: IO GType
+
+type instance ParentTypes Element = ElementParentTypes
+type ElementParentTypes = '[Object, GObject.Object]
+
+instance GObject Element where
+    gobjectIsInitiallyUnowned _ = True
+    gobjectType _ = c_gst_element_get_type
+    
+
+class GObject o => ElementK o
+instance (GObject o, IsDescendantOf Element o) => ElementK o
+
+toElement :: ElementK o => o -> IO Element
+toElement = unsafeCastTo Element
+
+noElement :: Maybe Element
+noElement = Nothing
+
+type family ResolveElementMethod (t :: Symbol) (o :: *) :: * where
+    ResolveElementMethod "abortState" o = ElementAbortStateMethodInfo
+    ResolveElementMethod "addControlBinding" o = ObjectAddControlBindingMethodInfo
+    ResolveElementMethod "addPad" o = ElementAddPadMethodInfo
+    ResolveElementMethod "bindProperty" o = GObject.ObjectBindPropertyMethodInfo
+    ResolveElementMethod "bindPropertyFull" o = GObject.ObjectBindPropertyFullMethodInfo
+    ResolveElementMethod "changeState" o = ElementChangeStateMethodInfo
+    ResolveElementMethod "continueState" o = ElementContinueStateMethodInfo
+    ResolveElementMethod "createAllPads" o = ElementCreateAllPadsMethodInfo
+    ResolveElementMethod "defaultError" o = ObjectDefaultErrorMethodInfo
+    ResolveElementMethod "forceFloating" o = GObject.ObjectForceFloatingMethodInfo
+    ResolveElementMethod "freezeNotify" o = GObject.ObjectFreezeNotifyMethodInfo
+    ResolveElementMethod "hasActiveControlBindings" o = ObjectHasActiveControlBindingsMethodInfo
+    ResolveElementMethod "hasAncestor" o = ObjectHasAncestorMethodInfo
+    ResolveElementMethod "hasAsAncestor" o = ObjectHasAsAncestorMethodInfo
+    ResolveElementMethod "hasAsParent" o = ObjectHasAsParentMethodInfo
+    ResolveElementMethod "isFloating" o = GObject.ObjectIsFloatingMethodInfo
+    ResolveElementMethod "isLockedState" o = ElementIsLockedStateMethodInfo
+    ResolveElementMethod "iteratePads" o = ElementIteratePadsMethodInfo
+    ResolveElementMethod "iterateSinkPads" o = ElementIterateSinkPadsMethodInfo
+    ResolveElementMethod "iterateSrcPads" o = ElementIterateSrcPadsMethodInfo
+    ResolveElementMethod "link" o = ElementLinkMethodInfo
+    ResolveElementMethod "linkFiltered" o = ElementLinkFilteredMethodInfo
+    ResolveElementMethod "linkPads" o = ElementLinkPadsMethodInfo
+    ResolveElementMethod "linkPadsFiltered" o = ElementLinkPadsFilteredMethodInfo
+    ResolveElementMethod "linkPadsFull" o = ElementLinkPadsFullMethodInfo
+    ResolveElementMethod "lostState" o = ElementLostStateMethodInfo
+    ResolveElementMethod "messageFull" o = ElementMessageFullMethodInfo
+    ResolveElementMethod "noMorePads" o = ElementNoMorePadsMethodInfo
+    ResolveElementMethod "notify" o = GObject.ObjectNotifyMethodInfo
+    ResolveElementMethod "notifyByPspec" o = GObject.ObjectNotifyByPspecMethodInfo
+    ResolveElementMethod "postMessage" o = ElementPostMessageMethodInfo
+    ResolveElementMethod "provideClock" o = ElementProvideClockMethodInfo
+    ResolveElementMethod "query" o = ElementQueryMethodInfo
+    ResolveElementMethod "queryConvert" o = ElementQueryConvertMethodInfo
+    ResolveElementMethod "queryDuration" o = ElementQueryDurationMethodInfo
+    ResolveElementMethod "queryPosition" o = ElementQueryPositionMethodInfo
+    ResolveElementMethod "refSink" o = GObject.ObjectRefSinkMethodInfo
+    ResolveElementMethod "releaseRequestPad" o = ElementReleaseRequestPadMethodInfo
+    ResolveElementMethod "removeControlBinding" o = ObjectRemoveControlBindingMethodInfo
+    ResolveElementMethod "removePad" o = ElementRemovePadMethodInfo
+    ResolveElementMethod "replaceData" o = GObject.ObjectReplaceDataMethodInfo
+    ResolveElementMethod "replaceQdata" o = GObject.ObjectReplaceQdataMethodInfo
+    ResolveElementMethod "requestPad" o = ElementRequestPadMethodInfo
+    ResolveElementMethod "runDispose" o = GObject.ObjectRunDisposeMethodInfo
+    ResolveElementMethod "seek" o = ElementSeekMethodInfo
+    ResolveElementMethod "seekSimple" o = ElementSeekSimpleMethodInfo
+    ResolveElementMethod "sendEvent" o = ElementSendEventMethodInfo
+    ResolveElementMethod "stealData" o = GObject.ObjectStealDataMethodInfo
+    ResolveElementMethod "stealQdata" o = GObject.ObjectStealQdataMethodInfo
+    ResolveElementMethod "suggestNextSync" o = ObjectSuggestNextSyncMethodInfo
+    ResolveElementMethod "syncStateWithParent" o = ElementSyncStateWithParentMethodInfo
+    ResolveElementMethod "syncValues" o = ObjectSyncValuesMethodInfo
+    ResolveElementMethod "thawNotify" o = GObject.ObjectThawNotifyMethodInfo
+    ResolveElementMethod "unlink" o = ElementUnlinkMethodInfo
+    ResolveElementMethod "unlinkPads" o = ElementUnlinkPadsMethodInfo
+    ResolveElementMethod "unparent" o = ObjectUnparentMethodInfo
+    ResolveElementMethod "watchClosure" o = GObject.ObjectWatchClosureMethodInfo
+    ResolveElementMethod "getBaseTime" o = ElementGetBaseTimeMethodInfo
+    ResolveElementMethod "getBus" o = ElementGetBusMethodInfo
+    ResolveElementMethod "getClock" o = ElementGetClockMethodInfo
+    ResolveElementMethod "getCompatiblePad" o = ElementGetCompatiblePadMethodInfo
+    ResolveElementMethod "getCompatiblePadTemplate" o = ElementGetCompatiblePadTemplateMethodInfo
+    ResolveElementMethod "getControlBinding" o = ObjectGetControlBindingMethodInfo
+    ResolveElementMethod "getControlRate" o = ObjectGetControlRateMethodInfo
+    ResolveElementMethod "getData" o = GObject.ObjectGetDataMethodInfo
+    ResolveElementMethod "getFactory" o = ElementGetFactoryMethodInfo
+    ResolveElementMethod "getGValueArray" o = ObjectGetGValueArrayMethodInfo
+    ResolveElementMethod "getName" o = ObjectGetNameMethodInfo
+    ResolveElementMethod "getParent" o = ObjectGetParentMethodInfo
+    ResolveElementMethod "getPathString" o = ObjectGetPathStringMethodInfo
+    ResolveElementMethod "getProperty" o = GObject.ObjectGetPropertyMethodInfo
+    ResolveElementMethod "getQdata" o = GObject.ObjectGetQdataMethodInfo
+    ResolveElementMethod "getRequestPad" o = ElementGetRequestPadMethodInfo
+    ResolveElementMethod "getStartTime" o = ElementGetStartTimeMethodInfo
+    ResolveElementMethod "getState" o = ElementGetStateMethodInfo
+    ResolveElementMethod "getStaticPad" o = ElementGetStaticPadMethodInfo
+    ResolveElementMethod "getValue" o = ObjectGetValueMethodInfo
+    ResolveElementMethod "getValueArray" o = ObjectGetValueArrayMethodInfo
+    ResolveElementMethod "setBaseTime" o = ElementSetBaseTimeMethodInfo
+    ResolveElementMethod "setBus" o = ElementSetBusMethodInfo
+    ResolveElementMethod "setClock" o = ElementSetClockMethodInfo
+    ResolveElementMethod "setContext" o = ElementSetContextMethodInfo
+    ResolveElementMethod "setControlBindingDisabled" o = ObjectSetControlBindingDisabledMethodInfo
+    ResolveElementMethod "setControlBindingsDisabled" o = ObjectSetControlBindingsDisabledMethodInfo
+    ResolveElementMethod "setControlRate" o = ObjectSetControlRateMethodInfo
+    ResolveElementMethod "setData" o = GObject.ObjectSetDataMethodInfo
+    ResolveElementMethod "setLockedState" o = ElementSetLockedStateMethodInfo
+    ResolveElementMethod "setName" o = ObjectSetNameMethodInfo
+    ResolveElementMethod "setParent" o = ObjectSetParentMethodInfo
+    ResolveElementMethod "setProperty" o = GObject.ObjectSetPropertyMethodInfo
+    ResolveElementMethod "setStartTime" o = ElementSetStartTimeMethodInfo
+    ResolveElementMethod "setState" o = ElementSetStateMethodInfo
+    ResolveElementMethod l o = MethodResolutionFailed l o
+
+instance (info ~ ResolveElementMethod t Element, MethodInfo info Element p) => IsLabelProxy t (Element -> p) where
+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)
+
+#if MIN_VERSION_base(4,9,0)
+instance (info ~ ResolveElementMethod t Element, MethodInfo info Element p) => IsLabel t (Element -> p) where
+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)
+#endif
+
+-- signal Element::no-more-pads
+type ElementNoMorePadsCallback =
+    IO ()
+
+noElementNoMorePadsCallback :: Maybe ElementNoMorePadsCallback
+noElementNoMorePadsCallback = Nothing
+
+type ElementNoMorePadsCallbackC =
+    Ptr () ->                               -- object
+    Ptr () ->                               -- user_data
+    IO ()
+
+foreign import ccall "wrapper"
+    mkElementNoMorePadsCallback :: ElementNoMorePadsCallbackC -> IO (FunPtr ElementNoMorePadsCallbackC)
+
+elementNoMorePadsClosure :: ElementNoMorePadsCallback -> IO Closure
+elementNoMorePadsClosure cb = newCClosure =<< mkElementNoMorePadsCallback wrapped
+    where wrapped = elementNoMorePadsCallbackWrapper cb
+
+elementNoMorePadsCallbackWrapper ::
+    ElementNoMorePadsCallback ->
+    Ptr () ->
+    Ptr () ->
+    IO ()
+elementNoMorePadsCallbackWrapper _cb _ _ = do
+    _cb 
+
+onElementNoMorePads :: (GObject a, MonadIO m) => a -> ElementNoMorePadsCallback -> m SignalHandlerId
+onElementNoMorePads obj cb = liftIO $ connectElementNoMorePads obj cb SignalConnectBefore
+afterElementNoMorePads :: (GObject a, MonadIO m) => a -> ElementNoMorePadsCallback -> m SignalHandlerId
+afterElementNoMorePads obj cb = connectElementNoMorePads obj cb SignalConnectAfter
+
+connectElementNoMorePads :: (GObject a, MonadIO m) =>
+                            a -> ElementNoMorePadsCallback -> SignalConnectMode -> m SignalHandlerId
+connectElementNoMorePads obj cb after = liftIO $ do
+    cb' <- mkElementNoMorePadsCallback (elementNoMorePadsCallbackWrapper cb)
+    connectSignalFunPtr obj "no-more-pads" cb' after
+
+-- signal Element::pad-added
+type ElementPadAddedCallback =
+    Pad ->
+    IO ()
+
+noElementPadAddedCallback :: Maybe ElementPadAddedCallback
+noElementPadAddedCallback = Nothing
+
+type ElementPadAddedCallbackC =
+    Ptr () ->                               -- object
+    Ptr Pad ->
+    Ptr () ->                               -- user_data
+    IO ()
+
+foreign import ccall "wrapper"
+    mkElementPadAddedCallback :: ElementPadAddedCallbackC -> IO (FunPtr ElementPadAddedCallbackC)
+
+elementPadAddedClosure :: ElementPadAddedCallback -> IO Closure
+elementPadAddedClosure cb = newCClosure =<< mkElementPadAddedCallback wrapped
+    where wrapped = elementPadAddedCallbackWrapper cb
+
+elementPadAddedCallbackWrapper ::
+    ElementPadAddedCallback ->
+    Ptr () ->
+    Ptr Pad ->
+    Ptr () ->
+    IO ()
+elementPadAddedCallbackWrapper _cb _ newPad _ = do
+    newPad' <- (newObject Pad) newPad
+    _cb  newPad'
+
+onElementPadAdded :: (GObject a, MonadIO m) => a -> ElementPadAddedCallback -> m SignalHandlerId
+onElementPadAdded obj cb = liftIO $ connectElementPadAdded obj cb SignalConnectBefore
+afterElementPadAdded :: (GObject a, MonadIO m) => a -> ElementPadAddedCallback -> m SignalHandlerId
+afterElementPadAdded obj cb = connectElementPadAdded obj cb SignalConnectAfter
+
+connectElementPadAdded :: (GObject a, MonadIO m) =>
+                          a -> ElementPadAddedCallback -> SignalConnectMode -> m SignalHandlerId
+connectElementPadAdded obj cb after = liftIO $ do
+    cb' <- mkElementPadAddedCallback (elementPadAddedCallbackWrapper cb)
+    connectSignalFunPtr obj "pad-added" cb' after
+
+-- signal Element::pad-removed
+type ElementPadRemovedCallback =
+    Pad ->
+    IO ()
+
+noElementPadRemovedCallback :: Maybe ElementPadRemovedCallback
+noElementPadRemovedCallback = Nothing
+
+type ElementPadRemovedCallbackC =
+    Ptr () ->                               -- object
+    Ptr Pad ->
+    Ptr () ->                               -- user_data
+    IO ()
+
+foreign import ccall "wrapper"
+    mkElementPadRemovedCallback :: ElementPadRemovedCallbackC -> IO (FunPtr ElementPadRemovedCallbackC)
+
+elementPadRemovedClosure :: ElementPadRemovedCallback -> IO Closure
+elementPadRemovedClosure cb = newCClosure =<< mkElementPadRemovedCallback wrapped
+    where wrapped = elementPadRemovedCallbackWrapper cb
+
+elementPadRemovedCallbackWrapper ::
+    ElementPadRemovedCallback ->
+    Ptr () ->
+    Ptr Pad ->
+    Ptr () ->
+    IO ()
+elementPadRemovedCallbackWrapper _cb _ oldPad _ = do
+    oldPad' <- (newObject Pad) oldPad
+    _cb  oldPad'
+
+onElementPadRemoved :: (GObject a, MonadIO m) => a -> ElementPadRemovedCallback -> m SignalHandlerId
+onElementPadRemoved obj cb = liftIO $ connectElementPadRemoved obj cb SignalConnectBefore
+afterElementPadRemoved :: (GObject a, MonadIO m) => a -> ElementPadRemovedCallback -> m SignalHandlerId
+afterElementPadRemoved obj cb = connectElementPadRemoved obj cb SignalConnectAfter
+
+connectElementPadRemoved :: (GObject a, MonadIO m) =>
+                            a -> ElementPadRemovedCallback -> SignalConnectMode -> m SignalHandlerId
+connectElementPadRemoved obj cb after = liftIO $ do
+    cb' <- mkElementPadRemovedCallback (elementPadRemovedCallbackWrapper cb)
+    connectSignalFunPtr obj "pad-removed" cb' after
+
+type instance AttributeList Element = ElementAttributeList
+type ElementAttributeList = ('[ '("name", ObjectNamePropertyInfo), '("parent", ObjectParentPropertyInfo)] :: [(Symbol, *)])
+
+data ElementNoMorePadsSignalInfo
+instance SignalInfo ElementNoMorePadsSignalInfo where
+    type HaskellCallbackType ElementNoMorePadsSignalInfo = ElementNoMorePadsCallback
+    connectSignal _ = connectElementNoMorePads
+
+data ElementPadAddedSignalInfo
+instance SignalInfo ElementPadAddedSignalInfo where
+    type HaskellCallbackType ElementPadAddedSignalInfo = ElementPadAddedCallback
+    connectSignal _ = connectElementPadAdded
+
+data ElementPadRemovedSignalInfo
+instance SignalInfo ElementPadRemovedSignalInfo where
+    type HaskellCallbackType ElementPadRemovedSignalInfo = ElementPadRemovedCallback
+    connectSignal _ = connectElementPadRemoved
+
+type instance SignalList Element = ElementSignalList
+type ElementSignalList = ('[ '("deepNotify", ObjectDeepNotifySignalInfo), '("noMorePads", ElementNoMorePadsSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("padAdded", ElementPadAddedSignalInfo), '("padRemoved", ElementPadRemovedSignalInfo)] :: [(Symbol, *)])
+
+-- method Element::abort_state
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_element_abort_state" gst_element_abort_state :: 
+    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"
+    IO ()
+
+
+elementAbortState ::
+    (MonadIO m, ElementK a) =>
+    a                                       -- _obj
+    -> m ()                                 -- result
+elementAbortState _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    gst_element_abort_state _obj'
+    touchManagedPtr _obj
+    return ()
+
+data ElementAbortStateMethodInfo
+instance (signature ~ (m ()), MonadIO m, ElementK a) => MethodInfo ElementAbortStateMethodInfo a signature where
+    overloadedMethod _ = elementAbortState
+
+-- method Element::add_pad
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pad", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_element_add_pad" gst_element_add_pad :: 
+    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"
+    Ptr Pad ->                              -- pad : TInterface "Gst" "Pad"
+    IO CInt
+
+
+elementAddPad ::
+    (MonadIO m, ElementK a, PadK b) =>
+    a                                       -- _obj
+    -> b                                    -- pad
+    -> m Bool                               -- result
+elementAddPad _obj pad = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    pad' <- refObject pad
+    result <- gst_element_add_pad _obj' pad'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    touchManagedPtr pad
+    return result'
+
+data ElementAddPadMethodInfo
+instance (signature ~ (b -> m Bool), MonadIO m, ElementK a, PadK b) => MethodInfo ElementAddPadMethodInfo a signature where
+    overloadedMethod _ = elementAddPad
+
+-- method Element::change_state
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "transition", argType = TInterface "Gst" "StateChange", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "StateChangeReturn"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_element_change_state" gst_element_change_state :: 
+    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"
+    CUInt ->                                -- transition : TInterface "Gst" "StateChange"
+    IO CUInt
+
+
+elementChangeState ::
+    (MonadIO m, ElementK a) =>
+    a                                       -- _obj
+    -> StateChange                          -- transition
+    -> m StateChangeReturn                  -- result
+elementChangeState _obj transition = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let transition' = (fromIntegral . fromEnum) transition
+    result <- gst_element_change_state _obj' transition'
+    let result' = (toEnum . fromIntegral) result
+    touchManagedPtr _obj
+    return result'
+
+data ElementChangeStateMethodInfo
+instance (signature ~ (StateChange -> m StateChangeReturn), MonadIO m, ElementK a) => MethodInfo ElementChangeStateMethodInfo a signature where
+    overloadedMethod _ = elementChangeState
+
+-- method Element::continue_state
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "ret", argType = TInterface "Gst" "StateChangeReturn", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "StateChangeReturn"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_element_continue_state" gst_element_continue_state :: 
+    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"
+    CUInt ->                                -- ret : TInterface "Gst" "StateChangeReturn"
+    IO CUInt
+
+
+elementContinueState ::
+    (MonadIO m, ElementK a) =>
+    a                                       -- _obj
+    -> StateChangeReturn                    -- ret
+    -> m StateChangeReturn                  -- result
+elementContinueState _obj ret = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let ret' = (fromIntegral . fromEnum) ret
+    result <- gst_element_continue_state _obj' ret'
+    let result' = (toEnum . fromIntegral) result
+    touchManagedPtr _obj
+    return result'
+
+data ElementContinueStateMethodInfo
+instance (signature ~ (StateChangeReturn -> m StateChangeReturn), MonadIO m, ElementK a) => MethodInfo ElementContinueStateMethodInfo a signature where
+    overloadedMethod _ = elementContinueState
+
+-- method Element::create_all_pads
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_element_create_all_pads" gst_element_create_all_pads :: 
+    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"
+    IO ()
+
+
+elementCreateAllPads ::
+    (MonadIO m, ElementK a) =>
+    a                                       -- _obj
+    -> m ()                                 -- result
+elementCreateAllPads _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    gst_element_create_all_pads _obj'
+    touchManagedPtr _obj
+    return ()
+
+data ElementCreateAllPadsMethodInfo
+instance (signature ~ (m ()), MonadIO m, ElementK a) => MethodInfo ElementCreateAllPadsMethodInfo a signature where
+    overloadedMethod _ = elementCreateAllPads
+
+-- method Element::get_base_time
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUInt64
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_element_get_base_time" gst_element_get_base_time :: 
+    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"
+    IO Word64
+
+
+elementGetBaseTime ::
+    (MonadIO m, ElementK a) =>
+    a                                       -- _obj
+    -> m Word64                             -- result
+elementGetBaseTime _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_element_get_base_time _obj'
+    touchManagedPtr _obj
+    return result
+
+data ElementGetBaseTimeMethodInfo
+instance (signature ~ (m Word64), MonadIO m, ElementK a) => MethodInfo ElementGetBaseTimeMethodInfo a signature where
+    overloadedMethod _ = elementGetBaseTime
+
+-- method Element::get_bus
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Bus"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_element_get_bus" gst_element_get_bus :: 
+    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"
+    IO (Ptr Bus)
+
+
+elementGetBus ::
+    (MonadIO m, ElementK a) =>
+    a                                       -- _obj
+    -> m Bus                                -- result
+elementGetBus _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_element_get_bus _obj'
+    checkUnexpectedReturnNULL "gst_element_get_bus" result
+    result' <- (wrapObject Bus) result
+    touchManagedPtr _obj
+    return result'
+
+data ElementGetBusMethodInfo
+instance (signature ~ (m Bus), MonadIO m, ElementK a) => MethodInfo ElementGetBusMethodInfo a signature where
+    overloadedMethod _ = elementGetBus
+
+-- method Element::get_clock
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Clock"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_element_get_clock" gst_element_get_clock :: 
+    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"
+    IO (Ptr Clock)
+
+
+elementGetClock ::
+    (MonadIO m, ElementK a) =>
+    a                                       -- _obj
+    -> m Clock                              -- result
+elementGetClock _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_element_get_clock _obj'
+    checkUnexpectedReturnNULL "gst_element_get_clock" result
+    result' <- (wrapObject Clock) result
+    touchManagedPtr _obj
+    return result'
+
+data ElementGetClockMethodInfo
+instance (signature ~ (m Clock), MonadIO m, ElementK a) => MethodInfo ElementGetClockMethodInfo a signature where
+    overloadedMethod _ = elementGetClock
+
+-- method Element::get_compatible_pad
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pad", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Pad"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_element_get_compatible_pad" gst_element_get_compatible_pad :: 
+    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"
+    Ptr Pad ->                              -- pad : TInterface "Gst" "Pad"
+    Ptr Caps ->                             -- caps : TInterface "Gst" "Caps"
+    IO (Ptr Pad)
+
+
+elementGetCompatiblePad ::
+    (MonadIO m, ElementK a, PadK b) =>
+    a                                       -- _obj
+    -> b                                    -- pad
+    -> Maybe (Caps)                         -- caps
+    -> m Pad                                -- result
+elementGetCompatiblePad _obj pad caps = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let pad' = unsafeManagedPtrCastPtr pad
+    maybeCaps <- case caps of
+        Nothing -> return nullPtr
+        Just jCaps -> do
+            let jCaps' = unsafeManagedPtrGetPtr jCaps
+            return jCaps'
+    result <- gst_element_get_compatible_pad _obj' pad' maybeCaps
+    checkUnexpectedReturnNULL "gst_element_get_compatible_pad" result
+    result' <- (wrapObject Pad) result
+    touchManagedPtr _obj
+    touchManagedPtr pad
+    whenJust caps touchManagedPtr
+    return result'
+
+data ElementGetCompatiblePadMethodInfo
+instance (signature ~ (b -> Maybe (Caps) -> m Pad), MonadIO m, ElementK a, PadK b) => MethodInfo ElementGetCompatiblePadMethodInfo a signature where
+    overloadedMethod _ = elementGetCompatiblePad
+
+-- method Element::get_compatible_pad_template
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "compattempl", argType = TInterface "Gst" "PadTemplate", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "PadTemplate"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_element_get_compatible_pad_template" gst_element_get_compatible_pad_template :: 
+    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"
+    Ptr PadTemplate ->                      -- compattempl : TInterface "Gst" "PadTemplate"
+    IO (Ptr PadTemplate)
+
+
+elementGetCompatiblePadTemplate ::
+    (MonadIO m, ElementK a, PadTemplateK b) =>
+    a                                       -- _obj
+    -> b                                    -- compattempl
+    -> m PadTemplate                        -- result
+elementGetCompatiblePadTemplate _obj compattempl = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let compattempl' = unsafeManagedPtrCastPtr compattempl
+    result <- gst_element_get_compatible_pad_template _obj' compattempl'
+    checkUnexpectedReturnNULL "gst_element_get_compatible_pad_template" result
+    result' <- (newObject PadTemplate) result
+    touchManagedPtr _obj
+    touchManagedPtr compattempl
+    return result'
+
+data ElementGetCompatiblePadTemplateMethodInfo
+instance (signature ~ (b -> m PadTemplate), MonadIO m, ElementK a, PadTemplateK b) => MethodInfo ElementGetCompatiblePadTemplateMethodInfo a signature where
+    overloadedMethod _ = elementGetCompatiblePadTemplate
+
+-- method Element::get_factory
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "ElementFactory"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_element_get_factory" gst_element_get_factory :: 
+    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"
+    IO (Ptr ElementFactory)
+
+
+elementGetFactory ::
+    (MonadIO m, ElementK a) =>
+    a                                       -- _obj
+    -> m ElementFactory                     -- result
+elementGetFactory _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_element_get_factory _obj'
+    checkUnexpectedReturnNULL "gst_element_get_factory" result
+    result' <- (newObject ElementFactory) result
+    touchManagedPtr _obj
+    return result'
+
+data ElementGetFactoryMethodInfo
+instance (signature ~ (m ElementFactory), MonadIO m, ElementK a) => MethodInfo ElementGetFactoryMethodInfo a signature where
+    overloadedMethod _ = elementGetFactory
+
+-- method Element::get_request_pad
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Pad"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_element_get_request_pad" gst_element_get_request_pad :: 
+    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"
+    CString ->                              -- name : TBasicType TUTF8
+    IO (Ptr Pad)
+
+
+elementGetRequestPad ::
+    (MonadIO m, ElementK a) =>
+    a                                       -- _obj
+    -> T.Text                               -- name
+    -> m Pad                                -- result
+elementGetRequestPad _obj name = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    name' <- textToCString name
+    result <- gst_element_get_request_pad _obj' name'
+    checkUnexpectedReturnNULL "gst_element_get_request_pad" result
+    result' <- (wrapObject Pad) result
+    touchManagedPtr _obj
+    freeMem name'
+    return result'
+
+data ElementGetRequestPadMethodInfo
+instance (signature ~ (T.Text -> m Pad), MonadIO m, ElementK a) => MethodInfo ElementGetRequestPadMethodInfo a signature where
+    overloadedMethod _ = elementGetRequestPad
+
+-- method Element::get_start_time
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUInt64
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_element_get_start_time" gst_element_get_start_time :: 
+    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"
+    IO Word64
+
+
+elementGetStartTime ::
+    (MonadIO m, ElementK a) =>
+    a                                       -- _obj
+    -> m Word64                             -- result
+elementGetStartTime _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_element_get_start_time _obj'
+    touchManagedPtr _obj
+    return result
+
+data ElementGetStartTimeMethodInfo
+instance (signature ~ (m Word64), MonadIO m, ElementK a) => MethodInfo ElementGetStartTimeMethodInfo a signature where
+    overloadedMethod _ = elementGetStartTime
+
+-- method Element::get_state
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "state", argType = TInterface "Gst" "State", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "pending", argType = TInterface "Gst" "State", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "timeout", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "StateChangeReturn"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_element_get_state" gst_element_get_state :: 
+    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"
+    Ptr CUInt ->                            -- state : TInterface "Gst" "State"
+    Ptr CUInt ->                            -- pending : TInterface "Gst" "State"
+    Word64 ->                               -- timeout : TBasicType TUInt64
+    IO CUInt
+
+
+elementGetState ::
+    (MonadIO m, ElementK a) =>
+    a                                       -- _obj
+    -> Word64                               -- timeout
+    -> m (StateChangeReturn,State,State)    -- result
+elementGetState _obj timeout = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    state <- allocMem :: IO (Ptr CUInt)
+    pending <- allocMem :: IO (Ptr CUInt)
+    result <- gst_element_get_state _obj' state pending timeout
+    let result' = (toEnum . fromIntegral) result
+    state' <- peek state
+    let state'' = (toEnum . fromIntegral) state'
+    pending' <- peek pending
+    let pending'' = (toEnum . fromIntegral) pending'
+    touchManagedPtr _obj
+    freeMem state
+    freeMem pending
+    return (result', state'', pending'')
+
+data ElementGetStateMethodInfo
+instance (signature ~ (Word64 -> m (StateChangeReturn,State,State)), MonadIO m, ElementK a) => MethodInfo ElementGetStateMethodInfo a signature where
+    overloadedMethod _ = elementGetState
+
+-- method Element::get_static_pad
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Pad"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_element_get_static_pad" gst_element_get_static_pad :: 
+    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"
+    CString ->                              -- name : TBasicType TUTF8
+    IO (Ptr Pad)
+
+
+elementGetStaticPad ::
+    (MonadIO m, ElementK a) =>
+    a                                       -- _obj
+    -> T.Text                               -- name
+    -> m Pad                                -- result
+elementGetStaticPad _obj name = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    name' <- textToCString name
+    result <- gst_element_get_static_pad _obj' name'
+    checkUnexpectedReturnNULL "gst_element_get_static_pad" result
+    result' <- (wrapObject Pad) result
+    touchManagedPtr _obj
+    freeMem name'
+    return result'
+
+data ElementGetStaticPadMethodInfo
+instance (signature ~ (T.Text -> m Pad), MonadIO m, ElementK a) => MethodInfo ElementGetStaticPadMethodInfo a signature where
+    overloadedMethod _ = elementGetStaticPad
+
+-- method Element::is_locked_state
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_element_is_locked_state" gst_element_is_locked_state :: 
+    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"
+    IO CInt
+
+
+elementIsLockedState ::
+    (MonadIO m, ElementK a) =>
+    a                                       -- _obj
+    -> m Bool                               -- result
+elementIsLockedState _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_element_is_locked_state _obj'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data ElementIsLockedStateMethodInfo
+instance (signature ~ (m Bool), MonadIO m, ElementK a) => MethodInfo ElementIsLockedStateMethodInfo a signature where
+    overloadedMethod _ = elementIsLockedState
+
+-- method Element::iterate_pads
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Iterator"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_element_iterate_pads" gst_element_iterate_pads :: 
+    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"
+    IO (Ptr Iterator)
+
+
+elementIteratePads ::
+    (MonadIO m, ElementK a) =>
+    a                                       -- _obj
+    -> m Iterator                           -- result
+elementIteratePads _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_element_iterate_pads _obj'
+    checkUnexpectedReturnNULL "gst_element_iterate_pads" result
+    result' <- (wrapBoxed Iterator) result
+    touchManagedPtr _obj
+    return result'
+
+data ElementIteratePadsMethodInfo
+instance (signature ~ (m Iterator), MonadIO m, ElementK a) => MethodInfo ElementIteratePadsMethodInfo a signature where
+    overloadedMethod _ = elementIteratePads
+
+-- method Element::iterate_sink_pads
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Iterator"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_element_iterate_sink_pads" gst_element_iterate_sink_pads :: 
+    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"
+    IO (Ptr Iterator)
+
+
+elementIterateSinkPads ::
+    (MonadIO m, ElementK a) =>
+    a                                       -- _obj
+    -> m Iterator                           -- result
+elementIterateSinkPads _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_element_iterate_sink_pads _obj'
+    checkUnexpectedReturnNULL "gst_element_iterate_sink_pads" result
+    result' <- (wrapBoxed Iterator) result
+    touchManagedPtr _obj
+    return result'
+
+data ElementIterateSinkPadsMethodInfo
+instance (signature ~ (m Iterator), MonadIO m, ElementK a) => MethodInfo ElementIterateSinkPadsMethodInfo a signature where
+    overloadedMethod _ = elementIterateSinkPads
+
+-- method Element::iterate_src_pads
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Iterator"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_element_iterate_src_pads" gst_element_iterate_src_pads :: 
+    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"
+    IO (Ptr Iterator)
+
+
+elementIterateSrcPads ::
+    (MonadIO m, ElementK a) =>
+    a                                       -- _obj
+    -> m Iterator                           -- result
+elementIterateSrcPads _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_element_iterate_src_pads _obj'
+    checkUnexpectedReturnNULL "gst_element_iterate_src_pads" result
+    result' <- (wrapBoxed Iterator) result
+    touchManagedPtr _obj
+    return result'
+
+data ElementIterateSrcPadsMethodInfo
+instance (signature ~ (m Iterator), MonadIO m, ElementK a) => MethodInfo ElementIterateSrcPadsMethodInfo a signature where
+    overloadedMethod _ = elementIterateSrcPads
+
+-- method Element::link
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_element_link" gst_element_link :: 
+    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"
+    Ptr Element ->                          -- dest : TInterface "Gst" "Element"
+    IO CInt
+
+
+elementLink ::
+    (MonadIO m, ElementK a, ElementK b) =>
+    a                                       -- _obj
+    -> b                                    -- dest
+    -> m Bool                               -- result
+elementLink _obj dest = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let dest' = unsafeManagedPtrCastPtr dest
+    result <- gst_element_link _obj' dest'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    touchManagedPtr dest
+    return result'
+
+data ElementLinkMethodInfo
+instance (signature ~ (b -> m Bool), MonadIO m, ElementK a, ElementK b) => MethodInfo ElementLinkMethodInfo a signature where
+    overloadedMethod _ = elementLink
+
+-- method Element::link_filtered
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "filter", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_element_link_filtered" gst_element_link_filtered :: 
+    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"
+    Ptr Element ->                          -- dest : TInterface "Gst" "Element"
+    Ptr Caps ->                             -- filter : TInterface "Gst" "Caps"
+    IO CInt
+
+
+elementLinkFiltered ::
+    (MonadIO m, ElementK a, ElementK b) =>
+    a                                       -- _obj
+    -> b                                    -- dest
+    -> Maybe (Caps)                         -- filter
+    -> m Bool                               -- result
+elementLinkFiltered _obj dest filter = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let dest' = unsafeManagedPtrCastPtr dest
+    maybeFilter <- case filter of
+        Nothing -> return nullPtr
+        Just jFilter -> do
+            let jFilter' = unsafeManagedPtrGetPtr jFilter
+            return jFilter'
+    result <- gst_element_link_filtered _obj' dest' maybeFilter
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    touchManagedPtr dest
+    whenJust filter touchManagedPtr
+    return result'
+
+data ElementLinkFilteredMethodInfo
+instance (signature ~ (b -> Maybe (Caps) -> m Bool), MonadIO m, ElementK a, ElementK b) => MethodInfo ElementLinkFilteredMethodInfo a signature where
+    overloadedMethod _ = elementLinkFiltered
+
+-- method Element::link_pads
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "srcpadname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "destpadname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_element_link_pads" gst_element_link_pads :: 
+    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"
+    CString ->                              -- srcpadname : TBasicType TUTF8
+    Ptr Element ->                          -- dest : TInterface "Gst" "Element"
+    CString ->                              -- destpadname : TBasicType TUTF8
+    IO CInt
+
+
+elementLinkPads ::
+    (MonadIO m, ElementK a, ElementK b) =>
+    a                                       -- _obj
+    -> Maybe (T.Text)                       -- srcpadname
+    -> b                                    -- dest
+    -> Maybe (T.Text)                       -- destpadname
+    -> m Bool                               -- result
+elementLinkPads _obj srcpadname dest destpadname = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    maybeSrcpadname <- case srcpadname of
+        Nothing -> return nullPtr
+        Just jSrcpadname -> do
+            jSrcpadname' <- textToCString jSrcpadname
+            return jSrcpadname'
+    let dest' = unsafeManagedPtrCastPtr dest
+    maybeDestpadname <- case destpadname of
+        Nothing -> return nullPtr
+        Just jDestpadname -> do
+            jDestpadname' <- textToCString jDestpadname
+            return jDestpadname'
+    result <- gst_element_link_pads _obj' maybeSrcpadname dest' maybeDestpadname
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    touchManagedPtr dest
+    freeMem maybeSrcpadname
+    freeMem maybeDestpadname
+    return result'
+
+data ElementLinkPadsMethodInfo
+instance (signature ~ (Maybe (T.Text) -> b -> Maybe (T.Text) -> m Bool), MonadIO m, ElementK a, ElementK b) => MethodInfo ElementLinkPadsMethodInfo a signature where
+    overloadedMethod _ = elementLinkPads
+
+-- method Element::link_pads_filtered
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "srcpadname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "destpadname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "filter", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_element_link_pads_filtered" gst_element_link_pads_filtered :: 
+    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"
+    CString ->                              -- srcpadname : TBasicType TUTF8
+    Ptr Element ->                          -- dest : TInterface "Gst" "Element"
+    CString ->                              -- destpadname : TBasicType TUTF8
+    Ptr Caps ->                             -- filter : TInterface "Gst" "Caps"
+    IO CInt
+
+
+elementLinkPadsFiltered ::
+    (MonadIO m, ElementK a, ElementK b) =>
+    a                                       -- _obj
+    -> Maybe (T.Text)                       -- srcpadname
+    -> b                                    -- dest
+    -> Maybe (T.Text)                       -- destpadname
+    -> Maybe (Caps)                         -- filter
+    -> m Bool                               -- result
+elementLinkPadsFiltered _obj srcpadname dest destpadname filter = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    maybeSrcpadname <- case srcpadname of
+        Nothing -> return nullPtr
+        Just jSrcpadname -> do
+            jSrcpadname' <- textToCString jSrcpadname
+            return jSrcpadname'
+    let dest' = unsafeManagedPtrCastPtr dest
+    maybeDestpadname <- case destpadname of
+        Nothing -> return nullPtr
+        Just jDestpadname -> do
+            jDestpadname' <- textToCString jDestpadname
+            return jDestpadname'
+    maybeFilter <- case filter of
+        Nothing -> return nullPtr
+        Just jFilter -> do
+            let jFilter' = unsafeManagedPtrGetPtr jFilter
+            return jFilter'
+    result <- gst_element_link_pads_filtered _obj' maybeSrcpadname dest' maybeDestpadname maybeFilter
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    touchManagedPtr dest
+    whenJust filter touchManagedPtr
+    freeMem maybeSrcpadname
+    freeMem maybeDestpadname
+    return result'
+
+data ElementLinkPadsFilteredMethodInfo
+instance (signature ~ (Maybe (T.Text) -> b -> Maybe (T.Text) -> Maybe (Caps) -> m Bool), MonadIO m, ElementK a, ElementK b) => MethodInfo ElementLinkPadsFilteredMethodInfo a signature where
+    overloadedMethod _ = elementLinkPadsFiltered
+
+-- method Element::link_pads_full
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "srcpadname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "destpadname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface "Gst" "PadLinkCheck", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_element_link_pads_full" gst_element_link_pads_full :: 
+    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"
+    CString ->                              -- srcpadname : TBasicType TUTF8
+    Ptr Element ->                          -- dest : TInterface "Gst" "Element"
+    CString ->                              -- destpadname : TBasicType TUTF8
+    CUInt ->                                -- flags : TInterface "Gst" "PadLinkCheck"
+    IO CInt
+
+
+elementLinkPadsFull ::
+    (MonadIO m, ElementK a, ElementK b) =>
+    a                                       -- _obj
+    -> Maybe (T.Text)                       -- srcpadname
+    -> b                                    -- dest
+    -> Maybe (T.Text)                       -- destpadname
+    -> [PadLinkCheck]                       -- flags
+    -> m Bool                               -- result
+elementLinkPadsFull _obj srcpadname dest destpadname flags = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    maybeSrcpadname <- case srcpadname of
+        Nothing -> return nullPtr
+        Just jSrcpadname -> do
+            jSrcpadname' <- textToCString jSrcpadname
+            return jSrcpadname'
+    let dest' = unsafeManagedPtrCastPtr dest
+    maybeDestpadname <- case destpadname of
+        Nothing -> return nullPtr
+        Just jDestpadname -> do
+            jDestpadname' <- textToCString jDestpadname
+            return jDestpadname'
+    let flags' = gflagsToWord flags
+    result <- gst_element_link_pads_full _obj' maybeSrcpadname dest' maybeDestpadname flags'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    touchManagedPtr dest
+    freeMem maybeSrcpadname
+    freeMem maybeDestpadname
+    return result'
+
+data ElementLinkPadsFullMethodInfo
+instance (signature ~ (Maybe (T.Text) -> b -> Maybe (T.Text) -> [PadLinkCheck] -> m Bool), MonadIO m, ElementK a, ElementK b) => MethodInfo ElementLinkPadsFullMethodInfo a signature where
+    overloadedMethod _ = elementLinkPadsFull
+
+-- method Element::lost_state
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_element_lost_state" gst_element_lost_state :: 
+    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"
+    IO ()
+
+
+elementLostState ::
+    (MonadIO m, ElementK a) =>
+    a                                       -- _obj
+    -> m ()                                 -- result
+elementLostState _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    gst_element_lost_state _obj'
+    touchManagedPtr _obj
+    return ()
+
+data ElementLostStateMethodInfo
+instance (signature ~ (m ()), MonadIO m, ElementK a) => MethodInfo ElementLostStateMethodInfo a signature where
+    overloadedMethod _ = elementLostState
+
+-- method Element::message_full
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "type", argType = TInterface "Gst" "MessageType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "domain", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "code", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "debug", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "file", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "function", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "line", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_element_message_full" gst_element_message_full :: 
+    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"
+    CUInt ->                                -- type : TInterface "Gst" "MessageType"
+    Word32 ->                               -- domain : TBasicType TUInt32
+    Int32 ->                                -- code : TBasicType TInt32
+    CString ->                              -- text : TBasicType TUTF8
+    CString ->                              -- debug : TBasicType TUTF8
+    CString ->                              -- file : TBasicType TUTF8
+    CString ->                              -- function : TBasicType TUTF8
+    Int32 ->                                -- line : TBasicType TInt32
+    IO ()
+
+
+elementMessageFull ::
+    (MonadIO m, ElementK a) =>
+    a                                       -- _obj
+    -> [MessageType]                        -- type_
+    -> Word32                               -- domain
+    -> Int32                                -- code
+    -> Maybe (T.Text)                       -- text
+    -> Maybe (T.Text)                       -- debug
+    -> T.Text                               -- file
+    -> T.Text                               -- function
+    -> Int32                                -- line
+    -> m ()                                 -- result
+elementMessageFull _obj type_ domain code text debug file function line = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let type_' = gflagsToWord type_
+    maybeText <- case text of
+        Nothing -> return nullPtr
+        Just jText -> do
+            jText' <- textToCString jText
+            return jText'
+    maybeDebug <- case debug of
+        Nothing -> return nullPtr
+        Just jDebug -> do
+            jDebug' <- textToCString jDebug
+            return jDebug'
+    file' <- textToCString file
+    function' <- textToCString function
+    gst_element_message_full _obj' type_' domain code maybeText maybeDebug file' function' line
+    touchManagedPtr _obj
+    freeMem file'
+    freeMem function'
+    return ()
+
+data ElementMessageFullMethodInfo
+instance (signature ~ ([MessageType] -> Word32 -> Int32 -> Maybe (T.Text) -> Maybe (T.Text) -> T.Text -> T.Text -> Int32 -> m ()), MonadIO m, ElementK a) => MethodInfo ElementMessageFullMethodInfo a signature where
+    overloadedMethod _ = elementMessageFull
+
+-- method Element::no_more_pads
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_element_no_more_pads" gst_element_no_more_pads :: 
+    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"
+    IO ()
+
+
+elementNoMorePads ::
+    (MonadIO m, ElementK a) =>
+    a                                       -- _obj
+    -> m ()                                 -- result
+elementNoMorePads _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    gst_element_no_more_pads _obj'
+    touchManagedPtr _obj
+    return ()
+
+data ElementNoMorePadsMethodInfo
+instance (signature ~ (m ()), MonadIO m, ElementK a) => MethodInfo ElementNoMorePadsMethodInfo a signature where
+    overloadedMethod _ = elementNoMorePads
+
+-- method Element::post_message
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "message", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_element_post_message" gst_element_post_message :: 
+    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"
+    Ptr Message ->                          -- message : TInterface "Gst" "Message"
+    IO CInt
+
+
+elementPostMessage ::
+    (MonadIO m, ElementK a) =>
+    a                                       -- _obj
+    -> Message                              -- message
+    -> m Bool                               -- result
+elementPostMessage _obj message = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    message' <- copyBoxed message
+    result <- gst_element_post_message _obj' message'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    touchManagedPtr message
+    return result'
+
+data ElementPostMessageMethodInfo
+instance (signature ~ (Message -> m Bool), MonadIO m, ElementK a) => MethodInfo ElementPostMessageMethodInfo a signature where
+    overloadedMethod _ = elementPostMessage
+
+-- method Element::provide_clock
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Clock"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_element_provide_clock" gst_element_provide_clock :: 
+    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"
+    IO (Ptr Clock)
+
+
+elementProvideClock ::
+    (MonadIO m, ElementK a) =>
+    a                                       -- _obj
+    -> m Clock                              -- result
+elementProvideClock _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_element_provide_clock _obj'
+    checkUnexpectedReturnNULL "gst_element_provide_clock" result
+    result' <- (wrapObject Clock) result
+    touchManagedPtr _obj
+    return result'
+
+data ElementProvideClockMethodInfo
+instance (signature ~ (m Clock), MonadIO m, ElementK a) => MethodInfo ElementProvideClockMethodInfo a signature where
+    overloadedMethod _ = elementProvideClock
+
+-- method Element::query
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "query", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_element_query" gst_element_query :: 
+    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"
+    Ptr Query ->                            -- query : TInterface "Gst" "Query"
+    IO CInt
+
+
+elementQuery ::
+    (MonadIO m, ElementK a) =>
+    a                                       -- _obj
+    -> Query                                -- query
+    -> m Bool                               -- result
+elementQuery _obj query = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let query' = unsafeManagedPtrGetPtr query
+    result <- gst_element_query _obj' query'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    touchManagedPtr query
+    return result'
+
+data ElementQueryMethodInfo
+instance (signature ~ (Query -> m Bool), MonadIO m, ElementK a) => MethodInfo ElementQueryMethodInfo a signature where
+    overloadedMethod _ = elementQuery
+
+-- method Element::query_convert
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "src_format", argType = TInterface "Gst" "Format", direction = DirectionInout, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "src_val", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest_format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest_val", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_element_query_convert" gst_element_query_convert :: 
+    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"
+    Ptr CUInt ->                            -- src_format : TInterface "Gst" "Format"
+    Int64 ->                                -- src_val : TBasicType TInt64
+    CUInt ->                                -- dest_format : TInterface "Gst" "Format"
+    Ptr Int64 ->                            -- dest_val : TBasicType TInt64
+    IO CInt
+
+
+elementQueryConvert ::
+    (MonadIO m, ElementK a) =>
+    a                                       -- _obj
+    -> Format                               -- srcFormat
+    -> Int64                                -- srcVal
+    -> Format                               -- destFormat
+    -> m (Bool,Format,Int64)                -- result
+elementQueryConvert _obj srcFormat srcVal destFormat = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let srcFormat' = (fromIntegral . fromEnum) srcFormat
+    srcFormat'' <- allocMem :: IO (Ptr CUInt)
+    poke srcFormat'' srcFormat'
+    let destFormat' = (fromIntegral . fromEnum) destFormat
+    destVal <- allocMem :: IO (Ptr Int64)
+    result <- gst_element_query_convert _obj' srcFormat'' srcVal destFormat' destVal
+    let result' = (/= 0) result
+    srcFormat''' <- peek srcFormat''
+    let srcFormat'''' = (toEnum . fromIntegral) srcFormat'''
+    destVal' <- peek destVal
+    touchManagedPtr _obj
+    freeMem srcFormat''
+    freeMem destVal
+    return (result', srcFormat'''', destVal')
+
+data ElementQueryConvertMethodInfo
+instance (signature ~ (Format -> Int64 -> Format -> m (Bool,Format,Int64)), MonadIO m, ElementK a) => MethodInfo ElementQueryConvertMethodInfo a signature where
+    overloadedMethod _ = elementQueryConvert
+
+-- method Element::query_duration
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "duration", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_element_query_duration" gst_element_query_duration :: 
+    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"
+    CUInt ->                                -- format : TInterface "Gst" "Format"
+    Ptr Int64 ->                            -- duration : TBasicType TInt64
+    IO CInt
+
+
+elementQueryDuration ::
+    (MonadIO m, ElementK a) =>
+    a                                       -- _obj
+    -> Format                               -- format
+    -> m (Bool,Int64)                       -- result
+elementQueryDuration _obj format = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let format' = (fromIntegral . fromEnum) format
+    duration <- allocMem :: IO (Ptr Int64)
+    result <- gst_element_query_duration _obj' format' duration
+    let result' = (/= 0) result
+    duration' <- peek duration
+    touchManagedPtr _obj
+    freeMem duration
+    return (result', duration')
+
+data ElementQueryDurationMethodInfo
+instance (signature ~ (Format -> m (Bool,Int64)), MonadIO m, ElementK a) => MethodInfo ElementQueryDurationMethodInfo a signature where
+    overloadedMethod _ = elementQueryDuration
+
+-- method Element::query_position
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cur", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_element_query_position" gst_element_query_position :: 
+    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"
+    CUInt ->                                -- format : TInterface "Gst" "Format"
+    Ptr Int64 ->                            -- cur : TBasicType TInt64
+    IO CInt
+
+
+elementQueryPosition ::
+    (MonadIO m, ElementK a) =>
+    a                                       -- _obj
+    -> Format                               -- format
+    -> m (Bool,Int64)                       -- result
+elementQueryPosition _obj format = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let format' = (fromIntegral . fromEnum) format
+    cur <- allocMem :: IO (Ptr Int64)
+    result <- gst_element_query_position _obj' format' cur
+    let result' = (/= 0) result
+    cur' <- peek cur
+    touchManagedPtr _obj
+    freeMem cur
+    return (result', cur')
+
+data ElementQueryPositionMethodInfo
+instance (signature ~ (Format -> m (Bool,Int64)), MonadIO m, ElementK a) => MethodInfo ElementQueryPositionMethodInfo a signature where
+    overloadedMethod _ = elementQueryPosition
+
+-- method Element::release_request_pad
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pad", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_element_release_request_pad" gst_element_release_request_pad :: 
+    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"
+    Ptr Pad ->                              -- pad : TInterface "Gst" "Pad"
+    IO ()
+
+
+elementReleaseRequestPad ::
+    (MonadIO m, ElementK a, PadK b) =>
+    a                                       -- _obj
+    -> b                                    -- pad
+    -> m ()                                 -- result
+elementReleaseRequestPad _obj pad = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let pad' = unsafeManagedPtrCastPtr pad
+    gst_element_release_request_pad _obj' pad'
+    touchManagedPtr _obj
+    touchManagedPtr pad
+    return ()
+
+data ElementReleaseRequestPadMethodInfo
+instance (signature ~ (b -> m ()), MonadIO m, ElementK a, PadK b) => MethodInfo ElementReleaseRequestPadMethodInfo a signature where
+    overloadedMethod _ = elementReleaseRequestPad
+
+-- method Element::remove_pad
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pad", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_element_remove_pad" gst_element_remove_pad :: 
+    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"
+    Ptr Pad ->                              -- pad : TInterface "Gst" "Pad"
+    IO CInt
+
+
+elementRemovePad ::
+    (MonadIO m, ElementK a, PadK b) =>
+    a                                       -- _obj
+    -> b                                    -- pad
+    -> m Bool                               -- result
+elementRemovePad _obj pad = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    pad' <- refObject pad
+    result <- gst_element_remove_pad _obj' pad'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    touchManagedPtr pad
+    return result'
+
+data ElementRemovePadMethodInfo
+instance (signature ~ (b -> m Bool), MonadIO m, ElementK a, PadK b) => MethodInfo ElementRemovePadMethodInfo a signature where
+    overloadedMethod _ = elementRemovePad
+
+-- method Element::request_pad
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "templ", argType = TInterface "Gst" "PadTemplate", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Pad"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_element_request_pad" gst_element_request_pad :: 
+    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"
+    Ptr PadTemplate ->                      -- templ : TInterface "Gst" "PadTemplate"
+    CString ->                              -- name : TBasicType TUTF8
+    Ptr Caps ->                             -- caps : TInterface "Gst" "Caps"
+    IO (Ptr Pad)
+
+
+elementRequestPad ::
+    (MonadIO m, ElementK a, PadTemplateK b) =>
+    a                                       -- _obj
+    -> b                                    -- templ
+    -> Maybe (T.Text)                       -- name
+    -> Maybe (Caps)                         -- caps
+    -> m Pad                                -- result
+elementRequestPad _obj templ name caps = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let templ' = unsafeManagedPtrCastPtr templ
+    maybeName <- case name of
+        Nothing -> return nullPtr
+        Just jName -> do
+            jName' <- textToCString jName
+            return jName'
+    maybeCaps <- case caps of
+        Nothing -> return nullPtr
+        Just jCaps -> do
+            let jCaps' = unsafeManagedPtrGetPtr jCaps
+            return jCaps'
+    result <- gst_element_request_pad _obj' templ' maybeName maybeCaps
+    checkUnexpectedReturnNULL "gst_element_request_pad" result
+    result' <- (wrapObject Pad) result
+    touchManagedPtr _obj
+    touchManagedPtr templ
+    whenJust caps touchManagedPtr
+    freeMem maybeName
+    return result'
+
+data ElementRequestPadMethodInfo
+instance (signature ~ (b -> Maybe (T.Text) -> Maybe (Caps) -> m Pad), MonadIO m, ElementK a, PadTemplateK b) => MethodInfo ElementRequestPadMethodInfo a signature where
+    overloadedMethod _ = elementRequestPad
+
+-- method Element::seek
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "rate", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface "Gst" "SeekFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start_type", argType = TInterface "Gst" "SeekType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stop_type", argType = TInterface "Gst" "SeekType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stop", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_element_seek" gst_element_seek :: 
+    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"
+    CDouble ->                              -- rate : TBasicType TDouble
+    CUInt ->                                -- format : TInterface "Gst" "Format"
+    CUInt ->                                -- flags : TInterface "Gst" "SeekFlags"
+    CUInt ->                                -- start_type : TInterface "Gst" "SeekType"
+    Int64 ->                                -- start : TBasicType TInt64
+    CUInt ->                                -- stop_type : TInterface "Gst" "SeekType"
+    Int64 ->                                -- stop : TBasicType TInt64
+    IO CInt
+
+
+elementSeek ::
+    (MonadIO m, ElementK a) =>
+    a                                       -- _obj
+    -> Double                               -- rate
+    -> Format                               -- format
+    -> [SeekFlags]                          -- flags
+    -> SeekType                             -- startType
+    -> Int64                                -- start
+    -> SeekType                             -- stopType
+    -> Int64                                -- stop
+    -> m Bool                               -- result
+elementSeek _obj rate format flags startType start stopType stop = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let rate' = realToFrac rate
+    let format' = (fromIntegral . fromEnum) format
+    let flags' = gflagsToWord flags
+    let startType' = (fromIntegral . fromEnum) startType
+    let stopType' = (fromIntegral . fromEnum) stopType
+    result <- gst_element_seek _obj' rate' format' flags' startType' start stopType' stop
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data ElementSeekMethodInfo
+instance (signature ~ (Double -> Format -> [SeekFlags] -> SeekType -> Int64 -> SeekType -> Int64 -> m Bool), MonadIO m, ElementK a) => MethodInfo ElementSeekMethodInfo a signature where
+    overloadedMethod _ = elementSeek
+
+-- method Element::seek_simple
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "seek_flags", argType = TInterface "Gst" "SeekFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "seek_pos", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_element_seek_simple" gst_element_seek_simple :: 
+    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"
+    CUInt ->                                -- format : TInterface "Gst" "Format"
+    CUInt ->                                -- seek_flags : TInterface "Gst" "SeekFlags"
+    Int64 ->                                -- seek_pos : TBasicType TInt64
+    IO CInt
+
+
+elementSeekSimple ::
+    (MonadIO m, ElementK a) =>
+    a                                       -- _obj
+    -> Format                               -- format
+    -> [SeekFlags]                          -- seekFlags
+    -> Int64                                -- seekPos
+    -> m Bool                               -- result
+elementSeekSimple _obj format seekFlags seekPos = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let format' = (fromIntegral . fromEnum) format
+    let seekFlags' = gflagsToWord seekFlags
+    result <- gst_element_seek_simple _obj' format' seekFlags' seekPos
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data ElementSeekSimpleMethodInfo
+instance (signature ~ (Format -> [SeekFlags] -> Int64 -> m Bool), MonadIO m, ElementK a) => MethodInfo ElementSeekSimpleMethodInfo a signature where
+    overloadedMethod _ = elementSeekSimple
+
+-- method Element::send_event
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "event", argType = TInterface "Gst" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_element_send_event" gst_element_send_event :: 
+    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"
+    Ptr Event ->                            -- event : TInterface "Gst" "Event"
+    IO CInt
+
+
+elementSendEvent ::
+    (MonadIO m, ElementK a) =>
+    a                                       -- _obj
+    -> Event                                -- event
+    -> m Bool                               -- result
+elementSendEvent _obj event = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    event' <- copyBoxed event
+    result <- gst_element_send_event _obj' event'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    touchManagedPtr event
+    return result'
+
+data ElementSendEventMethodInfo
+instance (signature ~ (Event -> m Bool), MonadIO m, ElementK a) => MethodInfo ElementSendEventMethodInfo a signature where
+    overloadedMethod _ = elementSendEvent
+
+-- method Element::set_base_time
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "time", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_element_set_base_time" gst_element_set_base_time :: 
+    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"
+    Word64 ->                               -- time : TBasicType TUInt64
+    IO ()
+
+
+elementSetBaseTime ::
+    (MonadIO m, ElementK a) =>
+    a                                       -- _obj
+    -> Word64                               -- time
+    -> m ()                                 -- result
+elementSetBaseTime _obj time = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    gst_element_set_base_time _obj' time
+    touchManagedPtr _obj
+    return ()
+
+data ElementSetBaseTimeMethodInfo
+instance (signature ~ (Word64 -> m ()), MonadIO m, ElementK a) => MethodInfo ElementSetBaseTimeMethodInfo a signature where
+    overloadedMethod _ = elementSetBaseTime
+
+-- method Element::set_bus
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "bus", argType = TInterface "Gst" "Bus", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_element_set_bus" gst_element_set_bus :: 
+    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"
+    Ptr Bus ->                              -- bus : TInterface "Gst" "Bus"
+    IO ()
+
+
+elementSetBus ::
+    (MonadIO m, ElementK a, BusK b) =>
+    a                                       -- _obj
+    -> b                                    -- bus
+    -> m ()                                 -- result
+elementSetBus _obj bus = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let bus' = unsafeManagedPtrCastPtr bus
+    gst_element_set_bus _obj' bus'
+    touchManagedPtr _obj
+    touchManagedPtr bus
+    return ()
+
+data ElementSetBusMethodInfo
+instance (signature ~ (b -> m ()), MonadIO m, ElementK a, BusK b) => MethodInfo ElementSetBusMethodInfo a signature where
+    overloadedMethod _ = elementSetBus
+
+-- method Element::set_clock
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "clock", argType = TInterface "Gst" "Clock", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_element_set_clock" gst_element_set_clock :: 
+    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"
+    Ptr Clock ->                            -- clock : TInterface "Gst" "Clock"
+    IO CInt
+
+
+elementSetClock ::
+    (MonadIO m, ElementK a, ClockK b) =>
+    a                                       -- _obj
+    -> b                                    -- clock
+    -> m Bool                               -- result
+elementSetClock _obj clock = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let clock' = unsafeManagedPtrCastPtr clock
+    result <- gst_element_set_clock _obj' clock'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    touchManagedPtr clock
+    return result'
+
+data ElementSetClockMethodInfo
+instance (signature ~ (b -> m Bool), MonadIO m, ElementK a, ClockK b) => MethodInfo ElementSetClockMethodInfo a signature where
+    overloadedMethod _ = elementSetClock
+
+-- method Element::set_context
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "context", argType = TInterface "Gst" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_element_set_context" gst_element_set_context :: 
+    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"
+    Ptr Context ->                          -- context : TInterface "Gst" "Context"
+    IO ()
+
+
+elementSetContext ::
+    (MonadIO m, ElementK a) =>
+    a                                       -- _obj
+    -> Context                              -- context
+    -> m ()                                 -- result
+elementSetContext _obj context = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let context' = unsafeManagedPtrGetPtr context
+    gst_element_set_context _obj' context'
+    touchManagedPtr _obj
+    touchManagedPtr context
+    return ()
+
+data ElementSetContextMethodInfo
+instance (signature ~ (Context -> m ()), MonadIO m, ElementK a) => MethodInfo ElementSetContextMethodInfo a signature where
+    overloadedMethod _ = elementSetContext
+
+-- method Element::set_locked_state
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "locked_state", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_element_set_locked_state" gst_element_set_locked_state :: 
+    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"
+    CInt ->                                 -- locked_state : TBasicType TBoolean
+    IO CInt
+
+
+elementSetLockedState ::
+    (MonadIO m, ElementK a) =>
+    a                                       -- _obj
+    -> Bool                                 -- lockedState
+    -> m Bool                               -- result
+elementSetLockedState _obj lockedState = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let lockedState' = (fromIntegral . fromEnum) lockedState
+    result <- gst_element_set_locked_state _obj' lockedState'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data ElementSetLockedStateMethodInfo
+instance (signature ~ (Bool -> m Bool), MonadIO m, ElementK a) => MethodInfo ElementSetLockedStateMethodInfo a signature where
+    overloadedMethod _ = elementSetLockedState
+
+-- method Element::set_start_time
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "time", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_element_set_start_time" gst_element_set_start_time :: 
+    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"
+    Word64 ->                               -- time : TBasicType TUInt64
+    IO ()
+
+
+elementSetStartTime ::
+    (MonadIO m, ElementK a) =>
+    a                                       -- _obj
+    -> Word64                               -- time
+    -> m ()                                 -- result
+elementSetStartTime _obj time = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    gst_element_set_start_time _obj' time
+    touchManagedPtr _obj
+    return ()
+
+data ElementSetStartTimeMethodInfo
+instance (signature ~ (Word64 -> m ()), MonadIO m, ElementK a) => MethodInfo ElementSetStartTimeMethodInfo a signature where
+    overloadedMethod _ = elementSetStartTime
+
+-- method Element::set_state
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "state", argType = TInterface "Gst" "State", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "StateChangeReturn"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_element_set_state" gst_element_set_state :: 
+    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"
+    CUInt ->                                -- state : TInterface "Gst" "State"
+    IO CUInt
+
+
+elementSetState ::
+    (MonadIO m, ElementK a) =>
+    a                                       -- _obj
+    -> State                                -- state
+    -> m StateChangeReturn                  -- result
+elementSetState _obj state = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let state' = (fromIntegral . fromEnum) state
+    result <- gst_element_set_state _obj' state'
+    let result' = (toEnum . fromIntegral) result
+    touchManagedPtr _obj
+    return result'
+
+data ElementSetStateMethodInfo
+instance (signature ~ (State -> m StateChangeReturn), MonadIO m, ElementK a) => MethodInfo ElementSetStateMethodInfo a signature where
+    overloadedMethod _ = elementSetState
+
+-- method Element::sync_state_with_parent
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_element_sync_state_with_parent" gst_element_sync_state_with_parent :: 
+    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"
+    IO CInt
+
+
+elementSyncStateWithParent ::
+    (MonadIO m, ElementK a) =>
+    a                                       -- _obj
+    -> m Bool                               -- result
+elementSyncStateWithParent _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_element_sync_state_with_parent _obj'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data ElementSyncStateWithParentMethodInfo
+instance (signature ~ (m Bool), MonadIO m, ElementK a) => MethodInfo ElementSyncStateWithParentMethodInfo a signature where
+    overloadedMethod _ = elementSyncStateWithParent
+
+-- method Element::unlink
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_element_unlink" gst_element_unlink :: 
+    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"
+    Ptr Element ->                          -- dest : TInterface "Gst" "Element"
+    IO ()
+
+
+elementUnlink ::
+    (MonadIO m, ElementK a, ElementK b) =>
+    a                                       -- _obj
+    -> b                                    -- dest
+    -> m ()                                 -- result
+elementUnlink _obj dest = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let dest' = unsafeManagedPtrCastPtr dest
+    gst_element_unlink _obj' dest'
+    touchManagedPtr _obj
+    touchManagedPtr dest
+    return ()
+
+data ElementUnlinkMethodInfo
+instance (signature ~ (b -> m ()), MonadIO m, ElementK a, ElementK b) => MethodInfo ElementUnlinkMethodInfo a signature where
+    overloadedMethod _ = elementUnlink
+
+-- method Element::unlink_pads
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "srcpadname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "destpadname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_element_unlink_pads" gst_element_unlink_pads :: 
+    Ptr Element ->                          -- _obj : TInterface "Gst" "Element"
+    CString ->                              -- srcpadname : TBasicType TUTF8
+    Ptr Element ->                          -- dest : TInterface "Gst" "Element"
+    CString ->                              -- destpadname : TBasicType TUTF8
+    IO ()
+
+
+elementUnlinkPads ::
+    (MonadIO m, ElementK a, ElementK b) =>
+    a                                       -- _obj
+    -> T.Text                               -- srcpadname
+    -> b                                    -- dest
+    -> T.Text                               -- destpadname
+    -> m ()                                 -- result
+elementUnlinkPads _obj srcpadname dest destpadname = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    srcpadname' <- textToCString srcpadname
+    let dest' = unsafeManagedPtrCastPtr dest
+    destpadname' <- textToCString destpadname
+    gst_element_unlink_pads _obj' srcpadname' dest' destpadname'
+    touchManagedPtr _obj
+    touchManagedPtr dest
+    freeMem srcpadname'
+    freeMem destpadname'
+    return ()
+
+data ElementUnlinkPadsMethodInfo
+instance (signature ~ (T.Text -> b -> T.Text -> m ()), MonadIO m, ElementK a, ElementK b) => MethodInfo ElementUnlinkPadsMethodInfo a signature where
+    overloadedMethod _ = elementUnlinkPads
+
+-- method Element::make_from_uri
+-- method type : MemberFunction
+-- Args : [Arg {argCName = "type", argType = TInterface "Gst" "URIType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "elementname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Element"
+-- throws : True
+-- Skip return : False
+
+foreign import ccall "gst_element_make_from_uri" gst_element_make_from_uri :: 
+    CUInt ->                                -- type : TInterface "Gst" "URIType"
+    CString ->                              -- uri : TBasicType TUTF8
+    CString ->                              -- elementname : TBasicType TUTF8
+    Ptr (Ptr GError) ->                     -- error
+    IO (Ptr Element)
+
+
+elementMakeFromUri ::
+    (MonadIO m) =>
+    URIType                                 -- type_
+    -> T.Text                               -- uri
+    -> Maybe (T.Text)                       -- elementname
+    -> m Element                            -- result
+elementMakeFromUri type_ uri elementname = liftIO $ do
+    let type_' = (fromIntegral . fromEnum) type_
+    uri' <- textToCString uri
+    maybeElementname <- case elementname of
+        Nothing -> return nullPtr
+        Just jElementname -> do
+            jElementname' <- textToCString jElementname
+            return jElementname'
+    onException (do
+        result <- propagateGError $ gst_element_make_from_uri type_' uri' maybeElementname
+        checkUnexpectedReturnNULL "gst_element_make_from_uri" result
+        result' <- (newObject Element) result
+        freeMem uri'
+        freeMem maybeElementname
+        return result'
+     ) (do
+        freeMem uri'
+        freeMem maybeElementname
+     )
+
+-- method Element::register
+-- method type : MemberFunction
+-- Args : [Arg {argCName = "plugin", argType = TInterface "Gst" "Plugin", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "rank", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "type", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_element_register" gst_element_register :: 
+    Ptr Plugin ->                           -- plugin : TInterface "Gst" "Plugin"
+    CString ->                              -- name : TBasicType TUTF8
+    Word32 ->                               -- rank : TBasicType TUInt32
+    CGType ->                               -- type : TBasicType TGType
+    IO CInt
+
+
+elementRegister ::
+    (MonadIO m, PluginK a) =>
+    Maybe (a)                               -- plugin
+    -> T.Text                               -- name
+    -> Word32                               -- rank
+    -> GType                                -- type_
+    -> m Bool                               -- result
+elementRegister plugin name rank type_ = liftIO $ do
+    maybePlugin <- case plugin of
+        Nothing -> return nullPtr
+        Just jPlugin -> do
+            let jPlugin' = unsafeManagedPtrCastPtr jPlugin
+            return jPlugin'
+    name' <- textToCString name
+    let type_' = gtypeToCGType type_
+    result <- gst_element_register maybePlugin name' rank type_'
+    let result' = (/= 0) result
+    whenJust plugin touchManagedPtr
+    freeMem name'
+    return result'
+
+-- method Element::state_change_return_get_name
+-- method type : MemberFunction
+-- Args : [Arg {argCName = "state_ret", argType = TInterface "Gst" "StateChangeReturn", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUTF8
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_element_state_change_return_get_name" gst_element_state_change_return_get_name :: 
+    CUInt ->                                -- state_ret : TInterface "Gst" "StateChangeReturn"
+    IO CString
+
+
+elementStateChangeReturnGetName ::
+    (MonadIO m) =>
+    StateChangeReturn                       -- stateRet
+    -> m T.Text                             -- result
+elementStateChangeReturnGetName stateRet = liftIO $ do
+    let stateRet' = (fromIntegral . fromEnum) stateRet
+    result <- gst_element_state_change_return_get_name stateRet'
+    checkUnexpectedReturnNULL "gst_element_state_change_return_get_name" result
+    result' <- cstringToText result
+    return result'
+
+-- method Element::state_get_name
+-- method type : MemberFunction
+-- Args : [Arg {argCName = "state", argType = TInterface "Gst" "State", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUTF8
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_element_state_get_name" gst_element_state_get_name :: 
+    CUInt ->                                -- state : TInterface "Gst" "State"
+    IO CString
+
+
+elementStateGetName ::
+    (MonadIO m) =>
+    State                                   -- state
+    -> m T.Text                             -- result
+elementStateGetName state = liftIO $ do
+    let state' = (fromIntegral . fromEnum) state
+    result <- gst_element_state_get_name state'
+    checkUnexpectedReturnNULL "gst_element_state_get_name" result
+    result' <- cstringToText result
+    return result'
+
+
diff --git a/GI/Gst/Objects/Element.hs-boot b/GI/Gst/Objects/Element.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Objects/Element.hs-boot
@@ -0,0 +1,65 @@
+module GI.Gst.Objects.Element where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+newtype Element = Element (ForeignPtr Element)
+instance GObject Element where
+class GObject o => ElementK o
+instance (GObject o, IsDescendantOf Element o) => ElementK o
+data ElementNoMorePadsSignalInfo
+data ElementPadAddedSignalInfo
+data ElementPadRemovedSignalInfo
+data ElementAbortStateMethodInfo
+data ElementAddPadMethodInfo
+data ElementChangeStateMethodInfo
+data ElementContinueStateMethodInfo
+data ElementCreateAllPadsMethodInfo
+data ElementGetBaseTimeMethodInfo
+data ElementGetBusMethodInfo
+data ElementGetClockMethodInfo
+data ElementGetCompatiblePadMethodInfo
+data ElementGetCompatiblePadTemplateMethodInfo
+data ElementGetFactoryMethodInfo
+data ElementGetRequestPadMethodInfo
+data ElementGetStartTimeMethodInfo
+data ElementGetStateMethodInfo
+data ElementGetStaticPadMethodInfo
+data ElementIsLockedStateMethodInfo
+data ElementIteratePadsMethodInfo
+data ElementIterateSinkPadsMethodInfo
+data ElementIterateSrcPadsMethodInfo
+data ElementLinkMethodInfo
+data ElementLinkFilteredMethodInfo
+data ElementLinkPadsMethodInfo
+data ElementLinkPadsFilteredMethodInfo
+data ElementLinkPadsFullMethodInfo
+data ElementLostStateMethodInfo
+data ElementMessageFullMethodInfo
+data ElementNoMorePadsMethodInfo
+data ElementPostMessageMethodInfo
+data ElementProvideClockMethodInfo
+data ElementQueryMethodInfo
+data ElementQueryConvertMethodInfo
+data ElementQueryDurationMethodInfo
+data ElementQueryPositionMethodInfo
+data ElementReleaseRequestPadMethodInfo
+data ElementRemovePadMethodInfo
+data ElementRequestPadMethodInfo
+data ElementSeekMethodInfo
+data ElementSeekSimpleMethodInfo
+data ElementSendEventMethodInfo
+data ElementSetBaseTimeMethodInfo
+data ElementSetBusMethodInfo
+data ElementSetClockMethodInfo
+data ElementSetContextMethodInfo
+data ElementSetLockedStateMethodInfo
+data ElementSetStartTimeMethodInfo
+data ElementSetStateMethodInfo
+data ElementSyncStateWithParentMethodInfo
+data ElementUnlinkMethodInfo
+data ElementUnlinkPadsMethodInfo
diff --git a/GI/Gst/Objects/ElementFactory.hs b/GI/Gst/Objects/ElementFactory.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Objects/ElementFactory.hs
@@ -0,0 +1,780 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+-}
+
+module GI.Gst.Objects.ElementFactory
+    ( 
+
+-- * Exported types
+    ElementFactory(..)                      ,
+    ElementFactoryK                         ,
+    toElementFactory                        ,
+    noElementFactory                        ,
+
+
+ -- * Methods
+-- ** elementFactoryCanSinkAllCaps
+    ElementFactoryCanSinkAllCapsMethodInfo  ,
+    elementFactoryCanSinkAllCaps            ,
+
+
+-- ** elementFactoryCanSinkAnyCaps
+    ElementFactoryCanSinkAnyCapsMethodInfo  ,
+    elementFactoryCanSinkAnyCaps            ,
+
+
+-- ** elementFactoryCanSrcAllCaps
+    ElementFactoryCanSrcAllCapsMethodInfo   ,
+    elementFactoryCanSrcAllCaps             ,
+
+
+-- ** elementFactoryCanSrcAnyCaps
+    ElementFactoryCanSrcAnyCapsMethodInfo   ,
+    elementFactoryCanSrcAnyCaps             ,
+
+
+-- ** elementFactoryCreate
+    ElementFactoryCreateMethodInfo          ,
+    elementFactoryCreate                    ,
+
+
+-- ** elementFactoryFind
+    elementFactoryFind                      ,
+
+
+-- ** elementFactoryGetElementType
+    ElementFactoryGetElementTypeMethodInfo  ,
+    elementFactoryGetElementType            ,
+
+
+-- ** elementFactoryGetMetadata
+    ElementFactoryGetMetadataMethodInfo     ,
+    elementFactoryGetMetadata               ,
+
+
+-- ** elementFactoryGetMetadataKeys
+    ElementFactoryGetMetadataKeysMethodInfo ,
+    elementFactoryGetMetadataKeys           ,
+
+
+-- ** elementFactoryGetNumPadTemplates
+    ElementFactoryGetNumPadTemplatesMethodInfo,
+    elementFactoryGetNumPadTemplates        ,
+
+
+-- ** elementFactoryGetStaticPadTemplates
+    ElementFactoryGetStaticPadTemplatesMethodInfo,
+    elementFactoryGetStaticPadTemplates     ,
+
+
+-- ** elementFactoryGetUriProtocols
+    ElementFactoryGetUriProtocolsMethodInfo ,
+    elementFactoryGetUriProtocols           ,
+
+
+-- ** elementFactoryGetUriType
+    ElementFactoryGetUriTypeMethodInfo      ,
+    elementFactoryGetUriType                ,
+
+
+-- ** elementFactoryHasInterface
+    ElementFactoryHasInterfaceMethodInfo    ,
+    elementFactoryHasInterface              ,
+
+
+-- ** elementFactoryListFilter
+    elementFactoryListFilter                ,
+
+
+-- ** elementFactoryListGetElements
+    elementFactoryListGetElements           ,
+
+
+-- ** elementFactoryListIsType
+    ElementFactoryListIsTypeMethodInfo      ,
+    elementFactoryListIsType                ,
+
+
+-- ** elementFactoryMake
+    elementFactoryMake                      ,
+
+
+
+
+    ) where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+import GI.Gst.Callbacks
+import qualified GI.GObject as GObject
+
+newtype ElementFactory = ElementFactory (ForeignPtr ElementFactory)
+foreign import ccall "gst_element_factory_get_type"
+    c_gst_element_factory_get_type :: IO GType
+
+type instance ParentTypes ElementFactory = ElementFactoryParentTypes
+type ElementFactoryParentTypes = '[PluginFeature, Object, GObject.Object]
+
+instance GObject ElementFactory where
+    gobjectIsInitiallyUnowned _ = True
+    gobjectType _ = c_gst_element_factory_get_type
+    
+
+class GObject o => ElementFactoryK o
+instance (GObject o, IsDescendantOf ElementFactory o) => ElementFactoryK o
+
+toElementFactory :: ElementFactoryK o => o -> IO ElementFactory
+toElementFactory = unsafeCastTo ElementFactory
+
+noElementFactory :: Maybe ElementFactory
+noElementFactory = Nothing
+
+type family ResolveElementFactoryMethod (t :: Symbol) (o :: *) :: * where
+    ResolveElementFactoryMethod "addControlBinding" o = ObjectAddControlBindingMethodInfo
+    ResolveElementFactoryMethod "bindProperty" o = GObject.ObjectBindPropertyMethodInfo
+    ResolveElementFactoryMethod "bindPropertyFull" o = GObject.ObjectBindPropertyFullMethodInfo
+    ResolveElementFactoryMethod "canSinkAllCaps" o = ElementFactoryCanSinkAllCapsMethodInfo
+    ResolveElementFactoryMethod "canSinkAnyCaps" o = ElementFactoryCanSinkAnyCapsMethodInfo
+    ResolveElementFactoryMethod "canSrcAllCaps" o = ElementFactoryCanSrcAllCapsMethodInfo
+    ResolveElementFactoryMethod "canSrcAnyCaps" o = ElementFactoryCanSrcAnyCapsMethodInfo
+    ResolveElementFactoryMethod "checkVersion" o = PluginFeatureCheckVersionMethodInfo
+    ResolveElementFactoryMethod "create" o = ElementFactoryCreateMethodInfo
+    ResolveElementFactoryMethod "defaultError" o = ObjectDefaultErrorMethodInfo
+    ResolveElementFactoryMethod "forceFloating" o = GObject.ObjectForceFloatingMethodInfo
+    ResolveElementFactoryMethod "freezeNotify" o = GObject.ObjectFreezeNotifyMethodInfo
+    ResolveElementFactoryMethod "hasActiveControlBindings" o = ObjectHasActiveControlBindingsMethodInfo
+    ResolveElementFactoryMethod "hasAncestor" o = ObjectHasAncestorMethodInfo
+    ResolveElementFactoryMethod "hasAsAncestor" o = ObjectHasAsAncestorMethodInfo
+    ResolveElementFactoryMethod "hasAsParent" o = ObjectHasAsParentMethodInfo
+    ResolveElementFactoryMethod "hasInterface" o = ElementFactoryHasInterfaceMethodInfo
+    ResolveElementFactoryMethod "isFloating" o = GObject.ObjectIsFloatingMethodInfo
+    ResolveElementFactoryMethod "listIsType" o = ElementFactoryListIsTypeMethodInfo
+    ResolveElementFactoryMethod "load" o = PluginFeatureLoadMethodInfo
+    ResolveElementFactoryMethod "notify" o = GObject.ObjectNotifyMethodInfo
+    ResolveElementFactoryMethod "notifyByPspec" o = GObject.ObjectNotifyByPspecMethodInfo
+    ResolveElementFactoryMethod "refSink" o = GObject.ObjectRefSinkMethodInfo
+    ResolveElementFactoryMethod "removeControlBinding" o = ObjectRemoveControlBindingMethodInfo
+    ResolveElementFactoryMethod "replaceData" o = GObject.ObjectReplaceDataMethodInfo
+    ResolveElementFactoryMethod "replaceQdata" o = GObject.ObjectReplaceQdataMethodInfo
+    ResolveElementFactoryMethod "runDispose" o = GObject.ObjectRunDisposeMethodInfo
+    ResolveElementFactoryMethod "stealData" o = GObject.ObjectStealDataMethodInfo
+    ResolveElementFactoryMethod "stealQdata" o = GObject.ObjectStealQdataMethodInfo
+    ResolveElementFactoryMethod "suggestNextSync" o = ObjectSuggestNextSyncMethodInfo
+    ResolveElementFactoryMethod "syncValues" o = ObjectSyncValuesMethodInfo
+    ResolveElementFactoryMethod "thawNotify" o = GObject.ObjectThawNotifyMethodInfo
+    ResolveElementFactoryMethod "unparent" o = ObjectUnparentMethodInfo
+    ResolveElementFactoryMethod "watchClosure" o = GObject.ObjectWatchClosureMethodInfo
+    ResolveElementFactoryMethod "getControlBinding" o = ObjectGetControlBindingMethodInfo
+    ResolveElementFactoryMethod "getControlRate" o = ObjectGetControlRateMethodInfo
+    ResolveElementFactoryMethod "getData" o = GObject.ObjectGetDataMethodInfo
+    ResolveElementFactoryMethod "getElementType" o = ElementFactoryGetElementTypeMethodInfo
+    ResolveElementFactoryMethod "getGValueArray" o = ObjectGetGValueArrayMethodInfo
+    ResolveElementFactoryMethod "getMetadata" o = ElementFactoryGetMetadataMethodInfo
+    ResolveElementFactoryMethod "getMetadataKeys" o = ElementFactoryGetMetadataKeysMethodInfo
+    ResolveElementFactoryMethod "getName" o = ObjectGetNameMethodInfo
+    ResolveElementFactoryMethod "getNumPadTemplates" o = ElementFactoryGetNumPadTemplatesMethodInfo
+    ResolveElementFactoryMethod "getParent" o = ObjectGetParentMethodInfo
+    ResolveElementFactoryMethod "getPathString" o = ObjectGetPathStringMethodInfo
+    ResolveElementFactoryMethod "getPlugin" o = PluginFeatureGetPluginMethodInfo
+    ResolveElementFactoryMethod "getPluginName" o = PluginFeatureGetPluginNameMethodInfo
+    ResolveElementFactoryMethod "getProperty" o = GObject.ObjectGetPropertyMethodInfo
+    ResolveElementFactoryMethod "getQdata" o = GObject.ObjectGetQdataMethodInfo
+    ResolveElementFactoryMethod "getRank" o = PluginFeatureGetRankMethodInfo
+    ResolveElementFactoryMethod "getStaticPadTemplates" o = ElementFactoryGetStaticPadTemplatesMethodInfo
+    ResolveElementFactoryMethod "getUriProtocols" o = ElementFactoryGetUriProtocolsMethodInfo
+    ResolveElementFactoryMethod "getUriType" o = ElementFactoryGetUriTypeMethodInfo
+    ResolveElementFactoryMethod "getValue" o = ObjectGetValueMethodInfo
+    ResolveElementFactoryMethod "getValueArray" o = ObjectGetValueArrayMethodInfo
+    ResolveElementFactoryMethod "setControlBindingDisabled" o = ObjectSetControlBindingDisabledMethodInfo
+    ResolveElementFactoryMethod "setControlBindingsDisabled" o = ObjectSetControlBindingsDisabledMethodInfo
+    ResolveElementFactoryMethod "setControlRate" o = ObjectSetControlRateMethodInfo
+    ResolveElementFactoryMethod "setData" o = GObject.ObjectSetDataMethodInfo
+    ResolveElementFactoryMethod "setName" o = ObjectSetNameMethodInfo
+    ResolveElementFactoryMethod "setParent" o = ObjectSetParentMethodInfo
+    ResolveElementFactoryMethod "setProperty" o = GObject.ObjectSetPropertyMethodInfo
+    ResolveElementFactoryMethod "setRank" o = PluginFeatureSetRankMethodInfo
+    ResolveElementFactoryMethod l o = MethodResolutionFailed l o
+
+instance (info ~ ResolveElementFactoryMethod t ElementFactory, MethodInfo info ElementFactory p) => IsLabelProxy t (ElementFactory -> p) where
+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)
+
+#if MIN_VERSION_base(4,9,0)
+instance (info ~ ResolveElementFactoryMethod t ElementFactory, MethodInfo info ElementFactory p) => IsLabel t (ElementFactory -> p) where
+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)
+#endif
+
+type instance AttributeList ElementFactory = ElementFactoryAttributeList
+type ElementFactoryAttributeList = ('[ '("name", ObjectNamePropertyInfo), '("parent", ObjectParentPropertyInfo)] :: [(Symbol, *)])
+
+type instance SignalList ElementFactory = ElementFactorySignalList
+type ElementFactorySignalList = ('[ '("deepNotify", ObjectDeepNotifySignalInfo), '("notify", GObject.ObjectNotifySignalInfo)] :: [(Symbol, *)])
+
+-- method ElementFactory::can_sink_all_caps
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "ElementFactory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_element_factory_can_sink_all_caps" gst_element_factory_can_sink_all_caps :: 
+    Ptr ElementFactory ->                   -- _obj : TInterface "Gst" "ElementFactory"
+    Ptr Caps ->                             -- caps : TInterface "Gst" "Caps"
+    IO CInt
+
+
+elementFactoryCanSinkAllCaps ::
+    (MonadIO m, ElementFactoryK a) =>
+    a                                       -- _obj
+    -> Caps                                 -- caps
+    -> m Bool                               -- result
+elementFactoryCanSinkAllCaps _obj caps = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let caps' = unsafeManagedPtrGetPtr caps
+    result <- gst_element_factory_can_sink_all_caps _obj' caps'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    touchManagedPtr caps
+    return result'
+
+data ElementFactoryCanSinkAllCapsMethodInfo
+instance (signature ~ (Caps -> m Bool), MonadIO m, ElementFactoryK a) => MethodInfo ElementFactoryCanSinkAllCapsMethodInfo a signature where
+    overloadedMethod _ = elementFactoryCanSinkAllCaps
+
+-- method ElementFactory::can_sink_any_caps
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "ElementFactory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_element_factory_can_sink_any_caps" gst_element_factory_can_sink_any_caps :: 
+    Ptr ElementFactory ->                   -- _obj : TInterface "Gst" "ElementFactory"
+    Ptr Caps ->                             -- caps : TInterface "Gst" "Caps"
+    IO CInt
+
+
+elementFactoryCanSinkAnyCaps ::
+    (MonadIO m, ElementFactoryK a) =>
+    a                                       -- _obj
+    -> Caps                                 -- caps
+    -> m Bool                               -- result
+elementFactoryCanSinkAnyCaps _obj caps = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let caps' = unsafeManagedPtrGetPtr caps
+    result <- gst_element_factory_can_sink_any_caps _obj' caps'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    touchManagedPtr caps
+    return result'
+
+data ElementFactoryCanSinkAnyCapsMethodInfo
+instance (signature ~ (Caps -> m Bool), MonadIO m, ElementFactoryK a) => MethodInfo ElementFactoryCanSinkAnyCapsMethodInfo a signature where
+    overloadedMethod _ = elementFactoryCanSinkAnyCaps
+
+-- method ElementFactory::can_src_all_caps
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "ElementFactory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_element_factory_can_src_all_caps" gst_element_factory_can_src_all_caps :: 
+    Ptr ElementFactory ->                   -- _obj : TInterface "Gst" "ElementFactory"
+    Ptr Caps ->                             -- caps : TInterface "Gst" "Caps"
+    IO CInt
+
+
+elementFactoryCanSrcAllCaps ::
+    (MonadIO m, ElementFactoryK a) =>
+    a                                       -- _obj
+    -> Caps                                 -- caps
+    -> m Bool                               -- result
+elementFactoryCanSrcAllCaps _obj caps = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let caps' = unsafeManagedPtrGetPtr caps
+    result <- gst_element_factory_can_src_all_caps _obj' caps'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    touchManagedPtr caps
+    return result'
+
+data ElementFactoryCanSrcAllCapsMethodInfo
+instance (signature ~ (Caps -> m Bool), MonadIO m, ElementFactoryK a) => MethodInfo ElementFactoryCanSrcAllCapsMethodInfo a signature where
+    overloadedMethod _ = elementFactoryCanSrcAllCaps
+
+-- method ElementFactory::can_src_any_caps
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "ElementFactory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_element_factory_can_src_any_caps" gst_element_factory_can_src_any_caps :: 
+    Ptr ElementFactory ->                   -- _obj : TInterface "Gst" "ElementFactory"
+    Ptr Caps ->                             -- caps : TInterface "Gst" "Caps"
+    IO CInt
+
+
+elementFactoryCanSrcAnyCaps ::
+    (MonadIO m, ElementFactoryK a) =>
+    a                                       -- _obj
+    -> Caps                                 -- caps
+    -> m Bool                               -- result
+elementFactoryCanSrcAnyCaps _obj caps = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let caps' = unsafeManagedPtrGetPtr caps
+    result <- gst_element_factory_can_src_any_caps _obj' caps'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    touchManagedPtr caps
+    return result'
+
+data ElementFactoryCanSrcAnyCapsMethodInfo
+instance (signature ~ (Caps -> m Bool), MonadIO m, ElementFactoryK a) => MethodInfo ElementFactoryCanSrcAnyCapsMethodInfo a signature where
+    overloadedMethod _ = elementFactoryCanSrcAnyCaps
+
+-- method ElementFactory::create
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "ElementFactory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Element"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_element_factory_create" gst_element_factory_create :: 
+    Ptr ElementFactory ->                   -- _obj : TInterface "Gst" "ElementFactory"
+    CString ->                              -- name : TBasicType TUTF8
+    IO (Ptr Element)
+
+
+elementFactoryCreate ::
+    (MonadIO m, ElementFactoryK a) =>
+    a                                       -- _obj
+    -> Maybe (T.Text)                       -- name
+    -> m Element                            -- result
+elementFactoryCreate _obj name = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    maybeName <- case name of
+        Nothing -> return nullPtr
+        Just jName -> do
+            jName' <- textToCString jName
+            return jName'
+    result <- gst_element_factory_create _obj' maybeName
+    checkUnexpectedReturnNULL "gst_element_factory_create" result
+    result' <- (newObject Element) result
+    touchManagedPtr _obj
+    freeMem maybeName
+    return result'
+
+data ElementFactoryCreateMethodInfo
+instance (signature ~ (Maybe (T.Text) -> m Element), MonadIO m, ElementFactoryK a) => MethodInfo ElementFactoryCreateMethodInfo a signature where
+    overloadedMethod _ = elementFactoryCreate
+
+-- method ElementFactory::get_element_type
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "ElementFactory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TGType
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_element_factory_get_element_type" gst_element_factory_get_element_type :: 
+    Ptr ElementFactory ->                   -- _obj : TInterface "Gst" "ElementFactory"
+    IO CGType
+
+
+elementFactoryGetElementType ::
+    (MonadIO m, ElementFactoryK a) =>
+    a                                       -- _obj
+    -> m GType                              -- result
+elementFactoryGetElementType _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_element_factory_get_element_type _obj'
+    let result' = GType result
+    touchManagedPtr _obj
+    return result'
+
+data ElementFactoryGetElementTypeMethodInfo
+instance (signature ~ (m GType), MonadIO m, ElementFactoryK a) => MethodInfo ElementFactoryGetElementTypeMethodInfo a signature where
+    overloadedMethod _ = elementFactoryGetElementType
+
+-- method ElementFactory::get_metadata
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "ElementFactory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUTF8
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_element_factory_get_metadata" gst_element_factory_get_metadata :: 
+    Ptr ElementFactory ->                   -- _obj : TInterface "Gst" "ElementFactory"
+    CString ->                              -- key : TBasicType TUTF8
+    IO CString
+
+
+elementFactoryGetMetadata ::
+    (MonadIO m, ElementFactoryK a) =>
+    a                                       -- _obj
+    -> T.Text                               -- key
+    -> m T.Text                             -- result
+elementFactoryGetMetadata _obj key = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    key' <- textToCString key
+    result <- gst_element_factory_get_metadata _obj' key'
+    checkUnexpectedReturnNULL "gst_element_factory_get_metadata" result
+    result' <- cstringToText result
+    touchManagedPtr _obj
+    freeMem key'
+    return result'
+
+data ElementFactoryGetMetadataMethodInfo
+instance (signature ~ (T.Text -> m T.Text), MonadIO m, ElementFactoryK a) => MethodInfo ElementFactoryGetMetadataMethodInfo a signature where
+    overloadedMethod _ = elementFactoryGetMetadata
+
+-- method ElementFactory::get_metadata_keys
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "ElementFactory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TCArray True (-1) (-1) (TBasicType TUTF8)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_element_factory_get_metadata_keys" gst_element_factory_get_metadata_keys :: 
+    Ptr ElementFactory ->                   -- _obj : TInterface "Gst" "ElementFactory"
+    IO (Ptr CString)
+
+
+elementFactoryGetMetadataKeys ::
+    (MonadIO m, ElementFactoryK a) =>
+    a                                       -- _obj
+    -> m [T.Text]                           -- result
+elementFactoryGetMetadataKeys _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_element_factory_get_metadata_keys _obj'
+    checkUnexpectedReturnNULL "gst_element_factory_get_metadata_keys" result
+    result' <- unpackZeroTerminatedUTF8CArray result
+    mapZeroTerminatedCArray freeMem result
+    freeMem result
+    touchManagedPtr _obj
+    return result'
+
+data ElementFactoryGetMetadataKeysMethodInfo
+instance (signature ~ (m [T.Text]), MonadIO m, ElementFactoryK a) => MethodInfo ElementFactoryGetMetadataKeysMethodInfo a signature where
+    overloadedMethod _ = elementFactoryGetMetadataKeys
+
+-- method ElementFactory::get_num_pad_templates
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "ElementFactory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUInt32
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_element_factory_get_num_pad_templates" gst_element_factory_get_num_pad_templates :: 
+    Ptr ElementFactory ->                   -- _obj : TInterface "Gst" "ElementFactory"
+    IO Word32
+
+
+elementFactoryGetNumPadTemplates ::
+    (MonadIO m, ElementFactoryK a) =>
+    a                                       -- _obj
+    -> m Word32                             -- result
+elementFactoryGetNumPadTemplates _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_element_factory_get_num_pad_templates _obj'
+    touchManagedPtr _obj
+    return result
+
+data ElementFactoryGetNumPadTemplatesMethodInfo
+instance (signature ~ (m Word32), MonadIO m, ElementFactoryK a) => MethodInfo ElementFactoryGetNumPadTemplatesMethodInfo a signature where
+    overloadedMethod _ = elementFactoryGetNumPadTemplates
+
+-- method ElementFactory::get_static_pad_templates
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "ElementFactory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TGList (TInterface "Gst" "StaticPadTemplate")
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_element_factory_get_static_pad_templates" gst_element_factory_get_static_pad_templates :: 
+    Ptr ElementFactory ->                   -- _obj : TInterface "Gst" "ElementFactory"
+    IO (Ptr (GList (Ptr StaticPadTemplate)))
+
+
+elementFactoryGetStaticPadTemplates ::
+    (MonadIO m, ElementFactoryK a) =>
+    a                                       -- _obj
+    -> m [StaticPadTemplate]                -- result
+elementFactoryGetStaticPadTemplates _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_element_factory_get_static_pad_templates _obj'
+    checkUnexpectedReturnNULL "gst_element_factory_get_static_pad_templates" result
+    result' <- unpackGList result
+    result'' <- mapM (newPtr 64 StaticPadTemplate) result'
+    touchManagedPtr _obj
+    return result''
+
+data ElementFactoryGetStaticPadTemplatesMethodInfo
+instance (signature ~ (m [StaticPadTemplate]), MonadIO m, ElementFactoryK a) => MethodInfo ElementFactoryGetStaticPadTemplatesMethodInfo a signature where
+    overloadedMethod _ = elementFactoryGetStaticPadTemplates
+
+-- method ElementFactory::get_uri_protocols
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "ElementFactory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TCArray True (-1) (-1) (TBasicType TUTF8)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_element_factory_get_uri_protocols" gst_element_factory_get_uri_protocols :: 
+    Ptr ElementFactory ->                   -- _obj : TInterface "Gst" "ElementFactory"
+    IO (Ptr CString)
+
+
+elementFactoryGetUriProtocols ::
+    (MonadIO m, ElementFactoryK a) =>
+    a                                       -- _obj
+    -> m [T.Text]                           -- result
+elementFactoryGetUriProtocols _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_element_factory_get_uri_protocols _obj'
+    checkUnexpectedReturnNULL "gst_element_factory_get_uri_protocols" result
+    result' <- unpackZeroTerminatedUTF8CArray result
+    touchManagedPtr _obj
+    return result'
+
+data ElementFactoryGetUriProtocolsMethodInfo
+instance (signature ~ (m [T.Text]), MonadIO m, ElementFactoryK a) => MethodInfo ElementFactoryGetUriProtocolsMethodInfo a signature where
+    overloadedMethod _ = elementFactoryGetUriProtocols
+
+-- method ElementFactory::get_uri_type
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "ElementFactory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "URIType"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_element_factory_get_uri_type" gst_element_factory_get_uri_type :: 
+    Ptr ElementFactory ->                   -- _obj : TInterface "Gst" "ElementFactory"
+    IO CUInt
+
+
+elementFactoryGetUriType ::
+    (MonadIO m, ElementFactoryK a) =>
+    a                                       -- _obj
+    -> m URIType                            -- result
+elementFactoryGetUriType _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_element_factory_get_uri_type _obj'
+    let result' = (toEnum . fromIntegral) result
+    touchManagedPtr _obj
+    return result'
+
+data ElementFactoryGetUriTypeMethodInfo
+instance (signature ~ (m URIType), MonadIO m, ElementFactoryK a) => MethodInfo ElementFactoryGetUriTypeMethodInfo a signature where
+    overloadedMethod _ = elementFactoryGetUriType
+
+-- method ElementFactory::has_interface
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "ElementFactory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "interfacename", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_element_factory_has_interface" gst_element_factory_has_interface :: 
+    Ptr ElementFactory ->                   -- _obj : TInterface "Gst" "ElementFactory"
+    CString ->                              -- interfacename : TBasicType TUTF8
+    IO CInt
+
+
+elementFactoryHasInterface ::
+    (MonadIO m, ElementFactoryK a) =>
+    a                                       -- _obj
+    -> T.Text                               -- interfacename
+    -> m Bool                               -- result
+elementFactoryHasInterface _obj interfacename = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    interfacename' <- textToCString interfacename
+    result <- gst_element_factory_has_interface _obj' interfacename'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    freeMem interfacename'
+    return result'
+
+data ElementFactoryHasInterfaceMethodInfo
+instance (signature ~ (T.Text -> m Bool), MonadIO m, ElementFactoryK a) => MethodInfo ElementFactoryHasInterfaceMethodInfo a signature where
+    overloadedMethod _ = elementFactoryHasInterface
+
+-- method ElementFactory::list_is_type
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "ElementFactory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "type", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_element_factory_list_is_type" gst_element_factory_list_is_type :: 
+    Ptr ElementFactory ->                   -- _obj : TInterface "Gst" "ElementFactory"
+    Word64 ->                               -- type : TBasicType TUInt64
+    IO CInt
+
+
+elementFactoryListIsType ::
+    (MonadIO m, ElementFactoryK a) =>
+    a                                       -- _obj
+    -> Word64                               -- type_
+    -> m Bool                               -- result
+elementFactoryListIsType _obj type_ = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_element_factory_list_is_type _obj' type_
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data ElementFactoryListIsTypeMethodInfo
+instance (signature ~ (Word64 -> m Bool), MonadIO m, ElementFactoryK a) => MethodInfo ElementFactoryListIsTypeMethodInfo a signature where
+    overloadedMethod _ = elementFactoryListIsType
+
+-- method ElementFactory::find
+-- method type : MemberFunction
+-- Args : [Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "ElementFactory"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_element_factory_find" gst_element_factory_find :: 
+    CString ->                              -- name : TBasicType TUTF8
+    IO (Ptr ElementFactory)
+
+
+elementFactoryFind ::
+    (MonadIO m) =>
+    T.Text                                  -- name
+    -> m ElementFactory                     -- result
+elementFactoryFind name = liftIO $ do
+    name' <- textToCString name
+    result <- gst_element_factory_find name'
+    checkUnexpectedReturnNULL "gst_element_factory_find" result
+    result' <- (wrapObject ElementFactory) result
+    freeMem name'
+    return result'
+
+-- method ElementFactory::list_filter
+-- method type : MemberFunction
+-- Args : [Arg {argCName = "list", argType = TGList (TInterface "Gst" "ElementFactory"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "direction", argType = TInterface "Gst" "PadDirection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "subsetonly", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TGList (TInterface "Gst" "ElementFactory")
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_element_factory_list_filter" gst_element_factory_list_filter :: 
+    Ptr (GList (Ptr ElementFactory)) ->     -- list : TGList (TInterface "Gst" "ElementFactory")
+    Ptr Caps ->                             -- caps : TInterface "Gst" "Caps"
+    CUInt ->                                -- direction : TInterface "Gst" "PadDirection"
+    CInt ->                                 -- subsetonly : TBasicType TBoolean
+    IO (Ptr (GList (Ptr ElementFactory)))
+
+
+elementFactoryListFilter ::
+    (MonadIO m, ElementFactoryK a) =>
+    [a]                                     -- list
+    -> Caps                                 -- caps
+    -> PadDirection                         -- direction
+    -> Bool                                 -- subsetonly
+    -> m [ElementFactory]                   -- result
+elementFactoryListFilter list caps direction subsetonly = liftIO $ do
+    let list' = map unsafeManagedPtrCastPtr list
+    list'' <- packGList list'
+    let caps' = unsafeManagedPtrGetPtr caps
+    let direction' = (fromIntegral . fromEnum) direction
+    let subsetonly' = (fromIntegral . fromEnum) subsetonly
+    result <- gst_element_factory_list_filter list'' caps' direction' subsetonly'
+    checkUnexpectedReturnNULL "gst_element_factory_list_filter" result
+    result' <- unpackGList result
+    result'' <- mapM (wrapObject ElementFactory) result'
+    g_list_free result
+    mapM_ touchManagedPtr list
+    touchManagedPtr caps
+    g_list_free list''
+    return result''
+
+-- method ElementFactory::list_get_elements
+-- method type : MemberFunction
+-- Args : [Arg {argCName = "type", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "minrank", argType = TInterface "Gst" "Rank", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TGList (TInterface "Gst" "ElementFactory")
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_element_factory_list_get_elements" gst_element_factory_list_get_elements :: 
+    Word64 ->                               -- type : TBasicType TUInt64
+    CUInt ->                                -- minrank : TInterface "Gst" "Rank"
+    IO (Ptr (GList (Ptr ElementFactory)))
+
+
+elementFactoryListGetElements ::
+    (MonadIO m) =>
+    Word64                                  -- type_
+    -> Rank                                 -- minrank
+    -> m [ElementFactory]                   -- result
+elementFactoryListGetElements type_ minrank = liftIO $ do
+    let minrank' = (fromIntegral . fromEnum) minrank
+    result <- gst_element_factory_list_get_elements type_ minrank'
+    checkUnexpectedReturnNULL "gst_element_factory_list_get_elements" result
+    result' <- unpackGList result
+    result'' <- mapM (wrapObject ElementFactory) result'
+    g_list_free result
+    return result''
+
+-- method ElementFactory::make
+-- method type : MemberFunction
+-- Args : [Arg {argCName = "factoryname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Element"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_element_factory_make" gst_element_factory_make :: 
+    CString ->                              -- factoryname : TBasicType TUTF8
+    CString ->                              -- name : TBasicType TUTF8
+    IO (Ptr Element)
+
+
+elementFactoryMake ::
+    (MonadIO m) =>
+    T.Text                                  -- factoryname
+    -> Maybe (T.Text)                       -- name
+    -> m Element                            -- result
+elementFactoryMake factoryname name = liftIO $ do
+    factoryname' <- textToCString factoryname
+    maybeName <- case name of
+        Nothing -> return nullPtr
+        Just jName -> do
+            jName' <- textToCString jName
+            return jName'
+    result <- gst_element_factory_make factoryname' maybeName
+    checkUnexpectedReturnNULL "gst_element_factory_make" result
+    result' <- (newObject Element) result
+    freeMem factoryname'
+    freeMem maybeName
+    return result'
+
+
diff --git a/GI/Gst/Objects/ElementFactory.hs-boot b/GI/Gst/Objects/ElementFactory.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Objects/ElementFactory.hs-boot
@@ -0,0 +1,27 @@
+module GI.Gst.Objects.ElementFactory where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+newtype ElementFactory = ElementFactory (ForeignPtr ElementFactory)
+instance GObject ElementFactory where
+class GObject o => ElementFactoryK o
+instance (GObject o, IsDescendantOf ElementFactory o) => ElementFactoryK o
+data ElementFactoryCanSinkAllCapsMethodInfo
+data ElementFactoryCanSinkAnyCapsMethodInfo
+data ElementFactoryCanSrcAllCapsMethodInfo
+data ElementFactoryCanSrcAnyCapsMethodInfo
+data ElementFactoryCreateMethodInfo
+data ElementFactoryGetElementTypeMethodInfo
+data ElementFactoryGetMetadataMethodInfo
+data ElementFactoryGetMetadataKeysMethodInfo
+data ElementFactoryGetNumPadTemplatesMethodInfo
+data ElementFactoryGetStaticPadTemplatesMethodInfo
+data ElementFactoryGetUriProtocolsMethodInfo
+data ElementFactoryGetUriTypeMethodInfo
+data ElementFactoryHasInterfaceMethodInfo
+data ElementFactoryListIsTypeMethodInfo
diff --git a/GI/Gst/Objects/GhostPad.hs b/GI/Gst/Objects/GhostPad.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Objects/GhostPad.hs
@@ -0,0 +1,536 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+-}
+
+module GI.Gst.Objects.GhostPad
+    ( 
+
+-- * Exported types
+    GhostPad(..)                            ,
+    GhostPadK                               ,
+    toGhostPad                              ,
+    noGhostPad                              ,
+
+
+ -- * Methods
+-- ** ghostPadActivateModeDefault
+    ghostPadActivateModeDefault             ,
+
+
+-- ** ghostPadConstruct
+    GhostPadConstructMethodInfo             ,
+    ghostPadConstruct                       ,
+
+
+-- ** ghostPadGetTarget
+    GhostPadGetTargetMethodInfo             ,
+    ghostPadGetTarget                       ,
+
+
+-- ** ghostPadInternalActivateModeDefault
+    ghostPadInternalActivateModeDefault     ,
+
+
+-- ** ghostPadNew
+    ghostPadNew                             ,
+
+
+-- ** ghostPadNewFromTemplate
+    ghostPadNewFromTemplate                 ,
+
+
+-- ** ghostPadNewNoTarget
+    ghostPadNewNoTarget                     ,
+
+
+-- ** ghostPadNewNoTargetFromTemplate
+    ghostPadNewNoTargetFromTemplate         ,
+
+
+-- ** ghostPadSetTarget
+    GhostPadSetTargetMethodInfo             ,
+    ghostPadSetTarget                       ,
+
+
+
+
+    ) where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+import GI.Gst.Callbacks
+import qualified GI.GObject as GObject
+
+newtype GhostPad = GhostPad (ForeignPtr GhostPad)
+foreign import ccall "gst_ghost_pad_get_type"
+    c_gst_ghost_pad_get_type :: IO GType
+
+type instance ParentTypes GhostPad = GhostPadParentTypes
+type GhostPadParentTypes = '[ProxyPad, Pad, Object, GObject.Object]
+
+instance GObject GhostPad where
+    gobjectIsInitiallyUnowned _ = True
+    gobjectType _ = c_gst_ghost_pad_get_type
+    
+
+class GObject o => GhostPadK o
+instance (GObject o, IsDescendantOf GhostPad o) => GhostPadK o
+
+toGhostPad :: GhostPadK o => o -> IO GhostPad
+toGhostPad = unsafeCastTo GhostPad
+
+noGhostPad :: Maybe GhostPad
+noGhostPad = Nothing
+
+type family ResolveGhostPadMethod (t :: Symbol) (o :: *) :: * where
+    ResolveGhostPadMethod "activateMode" o = PadActivateModeMethodInfo
+    ResolveGhostPadMethod "addControlBinding" o = ObjectAddControlBindingMethodInfo
+    ResolveGhostPadMethod "addProbe" o = PadAddProbeMethodInfo
+    ResolveGhostPadMethod "bindProperty" o = GObject.ObjectBindPropertyMethodInfo
+    ResolveGhostPadMethod "bindPropertyFull" o = GObject.ObjectBindPropertyFullMethodInfo
+    ResolveGhostPadMethod "canLink" o = PadCanLinkMethodInfo
+    ResolveGhostPadMethod "chain" o = PadChainMethodInfo
+    ResolveGhostPadMethod "chainList" o = PadChainListMethodInfo
+    ResolveGhostPadMethod "checkReconfigure" o = PadCheckReconfigureMethodInfo
+    ResolveGhostPadMethod "construct" o = GhostPadConstructMethodInfo
+    ResolveGhostPadMethod "createStreamId" o = PadCreateStreamIdMethodInfo
+    ResolveGhostPadMethod "defaultError" o = ObjectDefaultErrorMethodInfo
+    ResolveGhostPadMethod "eventDefault" o = PadEventDefaultMethodInfo
+    ResolveGhostPadMethod "forceFloating" o = GObject.ObjectForceFloatingMethodInfo
+    ResolveGhostPadMethod "forward" o = PadForwardMethodInfo
+    ResolveGhostPadMethod "freezeNotify" o = GObject.ObjectFreezeNotifyMethodInfo
+    ResolveGhostPadMethod "hasActiveControlBindings" o = ObjectHasActiveControlBindingsMethodInfo
+    ResolveGhostPadMethod "hasAncestor" o = ObjectHasAncestorMethodInfo
+    ResolveGhostPadMethod "hasAsAncestor" o = ObjectHasAsAncestorMethodInfo
+    ResolveGhostPadMethod "hasAsParent" o = ObjectHasAsParentMethodInfo
+    ResolveGhostPadMethod "hasCurrentCaps" o = PadHasCurrentCapsMethodInfo
+    ResolveGhostPadMethod "isActive" o = PadIsActiveMethodInfo
+    ResolveGhostPadMethod "isBlocked" o = PadIsBlockedMethodInfo
+    ResolveGhostPadMethod "isBlocking" o = PadIsBlockingMethodInfo
+    ResolveGhostPadMethod "isFloating" o = GObject.ObjectIsFloatingMethodInfo
+    ResolveGhostPadMethod "isLinked" o = PadIsLinkedMethodInfo
+    ResolveGhostPadMethod "iterateInternalLinks" o = PadIterateInternalLinksMethodInfo
+    ResolveGhostPadMethod "link" o = PadLinkMethodInfo
+    ResolveGhostPadMethod "linkFull" o = PadLinkFullMethodInfo
+    ResolveGhostPadMethod "markReconfigure" o = PadMarkReconfigureMethodInfo
+    ResolveGhostPadMethod "needsReconfigure" o = PadNeedsReconfigureMethodInfo
+    ResolveGhostPadMethod "notify" o = GObject.ObjectNotifyMethodInfo
+    ResolveGhostPadMethod "notifyByPspec" o = GObject.ObjectNotifyByPspecMethodInfo
+    ResolveGhostPadMethod "pauseTask" o = PadPauseTaskMethodInfo
+    ResolveGhostPadMethod "peerQuery" o = PadPeerQueryMethodInfo
+    ResolveGhostPadMethod "peerQueryAcceptCaps" o = PadPeerQueryAcceptCapsMethodInfo
+    ResolveGhostPadMethod "peerQueryCaps" o = PadPeerQueryCapsMethodInfo
+    ResolveGhostPadMethod "peerQueryConvert" o = PadPeerQueryConvertMethodInfo
+    ResolveGhostPadMethod "peerQueryDuration" o = PadPeerQueryDurationMethodInfo
+    ResolveGhostPadMethod "peerQueryPosition" o = PadPeerQueryPositionMethodInfo
+    ResolveGhostPadMethod "proxyQueryAcceptCaps" o = PadProxyQueryAcceptCapsMethodInfo
+    ResolveGhostPadMethod "proxyQueryCaps" o = PadProxyQueryCapsMethodInfo
+    ResolveGhostPadMethod "pullRange" o = PadPullRangeMethodInfo
+    ResolveGhostPadMethod "push" o = PadPushMethodInfo
+    ResolveGhostPadMethod "pushEvent" o = PadPushEventMethodInfo
+    ResolveGhostPadMethod "pushList" o = PadPushListMethodInfo
+    ResolveGhostPadMethod "query" o = PadQueryMethodInfo
+    ResolveGhostPadMethod "queryAcceptCaps" o = PadQueryAcceptCapsMethodInfo
+    ResolveGhostPadMethod "queryCaps" o = PadQueryCapsMethodInfo
+    ResolveGhostPadMethod "queryConvert" o = PadQueryConvertMethodInfo
+    ResolveGhostPadMethod "queryDefault" o = PadQueryDefaultMethodInfo
+    ResolveGhostPadMethod "queryDuration" o = PadQueryDurationMethodInfo
+    ResolveGhostPadMethod "queryPosition" o = PadQueryPositionMethodInfo
+    ResolveGhostPadMethod "refSink" o = GObject.ObjectRefSinkMethodInfo
+    ResolveGhostPadMethod "removeControlBinding" o = ObjectRemoveControlBindingMethodInfo
+    ResolveGhostPadMethod "removeProbe" o = PadRemoveProbeMethodInfo
+    ResolveGhostPadMethod "replaceData" o = GObject.ObjectReplaceDataMethodInfo
+    ResolveGhostPadMethod "replaceQdata" o = GObject.ObjectReplaceQdataMethodInfo
+    ResolveGhostPadMethod "runDispose" o = GObject.ObjectRunDisposeMethodInfo
+    ResolveGhostPadMethod "sendEvent" o = PadSendEventMethodInfo
+    ResolveGhostPadMethod "startTask" o = PadStartTaskMethodInfo
+    ResolveGhostPadMethod "stealData" o = GObject.ObjectStealDataMethodInfo
+    ResolveGhostPadMethod "stealQdata" o = GObject.ObjectStealQdataMethodInfo
+    ResolveGhostPadMethod "stickyEventsForeach" o = PadStickyEventsForeachMethodInfo
+    ResolveGhostPadMethod "stopTask" o = PadStopTaskMethodInfo
+    ResolveGhostPadMethod "storeStickyEvent" o = PadStoreStickyEventMethodInfo
+    ResolveGhostPadMethod "suggestNextSync" o = ObjectSuggestNextSyncMethodInfo
+    ResolveGhostPadMethod "syncValues" o = ObjectSyncValuesMethodInfo
+    ResolveGhostPadMethod "thawNotify" o = GObject.ObjectThawNotifyMethodInfo
+    ResolveGhostPadMethod "unlink" o = PadUnlinkMethodInfo
+    ResolveGhostPadMethod "unparent" o = ObjectUnparentMethodInfo
+    ResolveGhostPadMethod "useFixedCaps" o = PadUseFixedCapsMethodInfo
+    ResolveGhostPadMethod "watchClosure" o = GObject.ObjectWatchClosureMethodInfo
+    ResolveGhostPadMethod "getAllowedCaps" o = PadGetAllowedCapsMethodInfo
+    ResolveGhostPadMethod "getControlBinding" o = ObjectGetControlBindingMethodInfo
+    ResolveGhostPadMethod "getControlRate" o = ObjectGetControlRateMethodInfo
+    ResolveGhostPadMethod "getCurrentCaps" o = PadGetCurrentCapsMethodInfo
+    ResolveGhostPadMethod "getData" o = GObject.ObjectGetDataMethodInfo
+    ResolveGhostPadMethod "getDirection" o = PadGetDirectionMethodInfo
+    ResolveGhostPadMethod "getElementPrivate" o = PadGetElementPrivateMethodInfo
+    ResolveGhostPadMethod "getGValueArray" o = ObjectGetGValueArrayMethodInfo
+    ResolveGhostPadMethod "getInternal" o = ProxyPadGetInternalMethodInfo
+    ResolveGhostPadMethod "getLastFlowReturn" o = PadGetLastFlowReturnMethodInfo
+    ResolveGhostPadMethod "getName" o = ObjectGetNameMethodInfo
+    ResolveGhostPadMethod "getOffset" o = PadGetOffsetMethodInfo
+    ResolveGhostPadMethod "getPadTemplate" o = PadGetPadTemplateMethodInfo
+    ResolveGhostPadMethod "getPadTemplateCaps" o = PadGetPadTemplateCapsMethodInfo
+    ResolveGhostPadMethod "getParent" o = ObjectGetParentMethodInfo
+    ResolveGhostPadMethod "getParentElement" o = PadGetParentElementMethodInfo
+    ResolveGhostPadMethod "getPathString" o = ObjectGetPathStringMethodInfo
+    ResolveGhostPadMethod "getPeer" o = PadGetPeerMethodInfo
+    ResolveGhostPadMethod "getProperty" o = GObject.ObjectGetPropertyMethodInfo
+    ResolveGhostPadMethod "getQdata" o = GObject.ObjectGetQdataMethodInfo
+    ResolveGhostPadMethod "getRange" o = PadGetRangeMethodInfo
+    ResolveGhostPadMethod "getStickyEvent" o = PadGetStickyEventMethodInfo
+    ResolveGhostPadMethod "getStreamId" o = PadGetStreamIdMethodInfo
+    ResolveGhostPadMethod "getTarget" o = GhostPadGetTargetMethodInfo
+    ResolveGhostPadMethod "getValue" o = ObjectGetValueMethodInfo
+    ResolveGhostPadMethod "getValueArray" o = ObjectGetValueArrayMethodInfo
+    ResolveGhostPadMethod "setActivateFunctionFull" o = PadSetActivateFunctionFullMethodInfo
+    ResolveGhostPadMethod "setActivatemodeFunctionFull" o = PadSetActivatemodeFunctionFullMethodInfo
+    ResolveGhostPadMethod "setActive" o = PadSetActiveMethodInfo
+    ResolveGhostPadMethod "setChainFunctionFull" o = PadSetChainFunctionFullMethodInfo
+    ResolveGhostPadMethod "setChainListFunctionFull" o = PadSetChainListFunctionFullMethodInfo
+    ResolveGhostPadMethod "setControlBindingDisabled" o = ObjectSetControlBindingDisabledMethodInfo
+    ResolveGhostPadMethod "setControlBindingsDisabled" o = ObjectSetControlBindingsDisabledMethodInfo
+    ResolveGhostPadMethod "setControlRate" o = ObjectSetControlRateMethodInfo
+    ResolveGhostPadMethod "setData" o = GObject.ObjectSetDataMethodInfo
+    ResolveGhostPadMethod "setElementPrivate" o = PadSetElementPrivateMethodInfo
+    ResolveGhostPadMethod "setEventFunctionFull" o = PadSetEventFunctionFullMethodInfo
+    ResolveGhostPadMethod "setGetrangeFunctionFull" o = PadSetGetrangeFunctionFullMethodInfo
+    ResolveGhostPadMethod "setIterateInternalLinksFunctionFull" o = PadSetIterateInternalLinksFunctionFullMethodInfo
+    ResolveGhostPadMethod "setLinkFunctionFull" o = PadSetLinkFunctionFullMethodInfo
+    ResolveGhostPadMethod "setName" o = ObjectSetNameMethodInfo
+    ResolveGhostPadMethod "setOffset" o = PadSetOffsetMethodInfo
+    ResolveGhostPadMethod "setParent" o = ObjectSetParentMethodInfo
+    ResolveGhostPadMethod "setProperty" o = GObject.ObjectSetPropertyMethodInfo
+    ResolveGhostPadMethod "setQueryFunctionFull" o = PadSetQueryFunctionFullMethodInfo
+    ResolveGhostPadMethod "setTarget" o = GhostPadSetTargetMethodInfo
+    ResolveGhostPadMethod "setUnlinkFunctionFull" o = PadSetUnlinkFunctionFullMethodInfo
+    ResolveGhostPadMethod l o = MethodResolutionFailed l o
+
+instance (info ~ ResolveGhostPadMethod t GhostPad, MethodInfo info GhostPad p) => IsLabelProxy t (GhostPad -> p) where
+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)
+
+#if MIN_VERSION_base(4,9,0)
+instance (info ~ ResolveGhostPadMethod t GhostPad, MethodInfo info GhostPad p) => IsLabel t (GhostPad -> p) where
+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)
+#endif
+
+type instance AttributeList GhostPad = GhostPadAttributeList
+type GhostPadAttributeList = ('[ '("caps", PadCapsPropertyInfo), '("direction", PadDirectionPropertyInfo), '("name", ObjectNamePropertyInfo), '("offset", PadOffsetPropertyInfo), '("parent", ObjectParentPropertyInfo), '("template", PadTemplatePropertyInfo)] :: [(Symbol, *)])
+
+type instance SignalList GhostPad = GhostPadSignalList
+type GhostPadSignalList = ('[ '("deepNotify", ObjectDeepNotifySignalInfo), '("linked", PadLinkedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("unlinked", PadUnlinkedSignalInfo)] :: [(Symbol, *)])
+
+-- method GhostPad::new
+-- method type : Constructor
+-- Args : [Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "target", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "GhostPad"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_ghost_pad_new" gst_ghost_pad_new :: 
+    CString ->                              -- name : TBasicType TUTF8
+    Ptr Pad ->                              -- target : TInterface "Gst" "Pad"
+    IO (Ptr GhostPad)
+
+
+ghostPadNew ::
+    (MonadIO m, PadK a) =>
+    Maybe (T.Text)                          -- name
+    -> a                                    -- target
+    -> m GhostPad                           -- result
+ghostPadNew name target = liftIO $ do
+    maybeName <- case name of
+        Nothing -> return nullPtr
+        Just jName -> do
+            jName' <- textToCString jName
+            return jName'
+    let target' = unsafeManagedPtrCastPtr target
+    result <- gst_ghost_pad_new maybeName target'
+    checkUnexpectedReturnNULL "gst_ghost_pad_new" result
+    result' <- (newObject GhostPad) result
+    touchManagedPtr target
+    freeMem maybeName
+    return result'
+
+-- method GhostPad::new_from_template
+-- method type : Constructor
+-- Args : [Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "target", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "templ", argType = TInterface "Gst" "PadTemplate", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "GhostPad"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_ghost_pad_new_from_template" gst_ghost_pad_new_from_template :: 
+    CString ->                              -- name : TBasicType TUTF8
+    Ptr Pad ->                              -- target : TInterface "Gst" "Pad"
+    Ptr PadTemplate ->                      -- templ : TInterface "Gst" "PadTemplate"
+    IO (Ptr GhostPad)
+
+
+ghostPadNewFromTemplate ::
+    (MonadIO m, PadK a, PadTemplateK b) =>
+    Maybe (T.Text)                          -- name
+    -> a                                    -- target
+    -> b                                    -- templ
+    -> m GhostPad                           -- result
+ghostPadNewFromTemplate name target templ = liftIO $ do
+    maybeName <- case name of
+        Nothing -> return nullPtr
+        Just jName -> do
+            jName' <- textToCString jName
+            return jName'
+    let target' = unsafeManagedPtrCastPtr target
+    let templ' = unsafeManagedPtrCastPtr templ
+    result <- gst_ghost_pad_new_from_template maybeName target' templ'
+    checkUnexpectedReturnNULL "gst_ghost_pad_new_from_template" result
+    result' <- (wrapObject GhostPad) result
+    touchManagedPtr target
+    touchManagedPtr templ
+    freeMem maybeName
+    return result'
+
+-- method GhostPad::new_no_target
+-- method type : Constructor
+-- Args : [Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dir", argType = TInterface "Gst" "PadDirection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "GhostPad"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_ghost_pad_new_no_target" gst_ghost_pad_new_no_target :: 
+    CString ->                              -- name : TBasicType TUTF8
+    CUInt ->                                -- dir : TInterface "Gst" "PadDirection"
+    IO (Ptr GhostPad)
+
+
+ghostPadNewNoTarget ::
+    (MonadIO m) =>
+    Maybe (T.Text)                          -- name
+    -> PadDirection                         -- dir
+    -> m GhostPad                           -- result
+ghostPadNewNoTarget name dir = liftIO $ do
+    maybeName <- case name of
+        Nothing -> return nullPtr
+        Just jName -> do
+            jName' <- textToCString jName
+            return jName'
+    let dir' = (fromIntegral . fromEnum) dir
+    result <- gst_ghost_pad_new_no_target maybeName dir'
+    checkUnexpectedReturnNULL "gst_ghost_pad_new_no_target" result
+    result' <- (wrapObject GhostPad) result
+    freeMem maybeName
+    return result'
+
+-- method GhostPad::new_no_target_from_template
+-- method type : Constructor
+-- Args : [Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "templ", argType = TInterface "Gst" "PadTemplate", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "GhostPad"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_ghost_pad_new_no_target_from_template" gst_ghost_pad_new_no_target_from_template :: 
+    CString ->                              -- name : TBasicType TUTF8
+    Ptr PadTemplate ->                      -- templ : TInterface "Gst" "PadTemplate"
+    IO (Ptr GhostPad)
+
+
+ghostPadNewNoTargetFromTemplate ::
+    (MonadIO m, PadTemplateK a) =>
+    Maybe (T.Text)                          -- name
+    -> a                                    -- templ
+    -> m GhostPad                           -- result
+ghostPadNewNoTargetFromTemplate name templ = liftIO $ do
+    maybeName <- case name of
+        Nothing -> return nullPtr
+        Just jName -> do
+            jName' <- textToCString jName
+            return jName'
+    let templ' = unsafeManagedPtrCastPtr templ
+    result <- gst_ghost_pad_new_no_target_from_template maybeName templ'
+    checkUnexpectedReturnNULL "gst_ghost_pad_new_no_target_from_template" result
+    result' <- (wrapObject GhostPad) result
+    touchManagedPtr templ
+    freeMem maybeName
+    return result'
+
+-- method GhostPad::construct
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "GhostPad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_ghost_pad_construct" gst_ghost_pad_construct :: 
+    Ptr GhostPad ->                         -- _obj : TInterface "Gst" "GhostPad"
+    IO CInt
+
+
+ghostPadConstruct ::
+    (MonadIO m, GhostPadK a) =>
+    a                                       -- _obj
+    -> m Bool                               -- result
+ghostPadConstruct _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_ghost_pad_construct _obj'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data GhostPadConstructMethodInfo
+instance (signature ~ (m Bool), MonadIO m, GhostPadK a) => MethodInfo GhostPadConstructMethodInfo a signature where
+    overloadedMethod _ = ghostPadConstruct
+
+-- method GhostPad::get_target
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "GhostPad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Pad"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_ghost_pad_get_target" gst_ghost_pad_get_target :: 
+    Ptr GhostPad ->                         -- _obj : TInterface "Gst" "GhostPad"
+    IO (Ptr Pad)
+
+
+ghostPadGetTarget ::
+    (MonadIO m, GhostPadK a) =>
+    a                                       -- _obj
+    -> m Pad                                -- result
+ghostPadGetTarget _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_ghost_pad_get_target _obj'
+    checkUnexpectedReturnNULL "gst_ghost_pad_get_target" result
+    result' <- (wrapObject Pad) result
+    touchManagedPtr _obj
+    return result'
+
+data GhostPadGetTargetMethodInfo
+instance (signature ~ (m Pad), MonadIO m, GhostPadK a) => MethodInfo GhostPadGetTargetMethodInfo a signature where
+    overloadedMethod _ = ghostPadGetTarget
+
+-- method GhostPad::set_target
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "GhostPad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "newtarget", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_ghost_pad_set_target" gst_ghost_pad_set_target :: 
+    Ptr GhostPad ->                         -- _obj : TInterface "Gst" "GhostPad"
+    Ptr Pad ->                              -- newtarget : TInterface "Gst" "Pad"
+    IO CInt
+
+
+ghostPadSetTarget ::
+    (MonadIO m, GhostPadK a, PadK b) =>
+    a                                       -- _obj
+    -> Maybe (b)                            -- newtarget
+    -> m Bool                               -- result
+ghostPadSetTarget _obj newtarget = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    maybeNewtarget <- case newtarget of
+        Nothing -> return nullPtr
+        Just jNewtarget -> do
+            let jNewtarget' = unsafeManagedPtrCastPtr jNewtarget
+            return jNewtarget'
+    result <- gst_ghost_pad_set_target _obj' maybeNewtarget
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    whenJust newtarget touchManagedPtr
+    return result'
+
+data GhostPadSetTargetMethodInfo
+instance (signature ~ (Maybe (b) -> m Bool), MonadIO m, GhostPadK a, PadK b) => MethodInfo GhostPadSetTargetMethodInfo a signature where
+    overloadedMethod _ = ghostPadSetTarget
+
+-- method GhostPad::activate_mode_default
+-- method type : MemberFunction
+-- Args : [Arg {argCName = "pad", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "parent", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mode", argType = TInterface "Gst" "PadMode", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "active", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_ghost_pad_activate_mode_default" gst_ghost_pad_activate_mode_default :: 
+    Ptr Pad ->                              -- pad : TInterface "Gst" "Pad"
+    Ptr Object ->                           -- parent : TInterface "Gst" "Object"
+    CUInt ->                                -- mode : TInterface "Gst" "PadMode"
+    CInt ->                                 -- active : TBasicType TBoolean
+    IO CInt
+
+
+ghostPadActivateModeDefault ::
+    (MonadIO m, PadK a, ObjectK b) =>
+    a                                       -- pad
+    -> Maybe (b)                            -- parent
+    -> PadMode                              -- mode
+    -> Bool                                 -- active
+    -> m Bool                               -- result
+ghostPadActivateModeDefault pad parent mode active = liftIO $ do
+    let pad' = unsafeManagedPtrCastPtr pad
+    maybeParent <- case parent of
+        Nothing -> return nullPtr
+        Just jParent -> do
+            let jParent' = unsafeManagedPtrCastPtr jParent
+            return jParent'
+    let mode' = (fromIntegral . fromEnum) mode
+    let active' = (fromIntegral . fromEnum) active
+    result <- gst_ghost_pad_activate_mode_default pad' maybeParent mode' active'
+    let result' = (/= 0) result
+    touchManagedPtr pad
+    whenJust parent touchManagedPtr
+    return result'
+
+-- method GhostPad::internal_activate_mode_default
+-- method type : MemberFunction
+-- Args : [Arg {argCName = "pad", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "parent", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mode", argType = TInterface "Gst" "PadMode", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "active", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_ghost_pad_internal_activate_mode_default" gst_ghost_pad_internal_activate_mode_default :: 
+    Ptr Pad ->                              -- pad : TInterface "Gst" "Pad"
+    Ptr Object ->                           -- parent : TInterface "Gst" "Object"
+    CUInt ->                                -- mode : TInterface "Gst" "PadMode"
+    CInt ->                                 -- active : TBasicType TBoolean
+    IO CInt
+
+
+ghostPadInternalActivateModeDefault ::
+    (MonadIO m, PadK a, ObjectK b) =>
+    a                                       -- pad
+    -> Maybe (b)                            -- parent
+    -> PadMode                              -- mode
+    -> Bool                                 -- active
+    -> m Bool                               -- result
+ghostPadInternalActivateModeDefault pad parent mode active = liftIO $ do
+    let pad' = unsafeManagedPtrCastPtr pad
+    maybeParent <- case parent of
+        Nothing -> return nullPtr
+        Just jParent -> do
+            let jParent' = unsafeManagedPtrCastPtr jParent
+            return jParent'
+    let mode' = (fromIntegral . fromEnum) mode
+    let active' = (fromIntegral . fromEnum) active
+    result <- gst_ghost_pad_internal_activate_mode_default pad' maybeParent mode' active'
+    let result' = (/= 0) result
+    touchManagedPtr pad
+    whenJust parent touchManagedPtr
+    return result'
+
+
diff --git a/GI/Gst/Objects/GhostPad.hs-boot b/GI/Gst/Objects/GhostPad.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Objects/GhostPad.hs-boot
@@ -0,0 +1,16 @@
+module GI.Gst.Objects.GhostPad where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+newtype GhostPad = GhostPad (ForeignPtr GhostPad)
+instance GObject GhostPad where
+class GObject o => GhostPadK o
+instance (GObject o, IsDescendantOf GhostPad o) => GhostPadK o
+data GhostPadConstructMethodInfo
+data GhostPadGetTargetMethodInfo
+data GhostPadSetTargetMethodInfo
diff --git a/GI/Gst/Objects/Object.hs b/GI/Gst/Objects/Object.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Objects/Object.hs
@@ -0,0 +1,1290 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+-}
+
+module GI.Gst.Objects.Object
+    ( 
+
+-- * Exported types
+    Object(..)                              ,
+    ObjectK                                 ,
+    toObject                                ,
+    noObject                                ,
+
+
+ -- * Methods
+-- ** objectAddControlBinding
+    ObjectAddControlBindingMethodInfo       ,
+    objectAddControlBinding                 ,
+
+
+-- ** objectCheckUniqueness
+    objectCheckUniqueness                   ,
+
+
+-- ** objectDefaultDeepNotify
+    objectDefaultDeepNotify                 ,
+
+
+-- ** objectDefaultError
+    ObjectDefaultErrorMethodInfo            ,
+    objectDefaultError                      ,
+
+
+-- ** objectGetControlBinding
+    ObjectGetControlBindingMethodInfo       ,
+    objectGetControlBinding                 ,
+
+
+-- ** objectGetControlRate
+    ObjectGetControlRateMethodInfo          ,
+    objectGetControlRate                    ,
+
+
+-- ** objectGetGValueArray
+    ObjectGetGValueArrayMethodInfo          ,
+    objectGetGValueArray                    ,
+
+
+-- ** objectGetName
+    ObjectGetNameMethodInfo                 ,
+    objectGetName                           ,
+
+
+-- ** objectGetParent
+    ObjectGetParentMethodInfo               ,
+    objectGetParent                         ,
+
+
+-- ** objectGetPathString
+    ObjectGetPathStringMethodInfo           ,
+    objectGetPathString                     ,
+
+
+-- ** objectGetValue
+    ObjectGetValueMethodInfo                ,
+    objectGetValue                          ,
+
+
+-- ** objectGetValueArray
+    ObjectGetValueArrayMethodInfo           ,
+    objectGetValueArray                     ,
+
+
+-- ** objectHasActiveControlBindings
+    ObjectHasActiveControlBindingsMethodInfo,
+    objectHasActiveControlBindings          ,
+
+
+-- ** objectHasAncestor
+    ObjectHasAncestorMethodInfo             ,
+    objectHasAncestor                       ,
+
+
+-- ** objectHasAsAncestor
+    ObjectHasAsAncestorMethodInfo           ,
+    objectHasAsAncestor                     ,
+
+
+-- ** objectHasAsParent
+    ObjectHasAsParentMethodInfo             ,
+    objectHasAsParent                       ,
+
+
+-- ** objectRef
+    ObjectRefMethodInfo                     ,
+    objectRef                               ,
+
+
+-- ** objectRemoveControlBinding
+    ObjectRemoveControlBindingMethodInfo    ,
+    objectRemoveControlBinding              ,
+
+
+-- ** objectReplace
+    objectReplace                           ,
+
+
+-- ** objectSetControlBindingDisabled
+    ObjectSetControlBindingDisabledMethodInfo,
+    objectSetControlBindingDisabled         ,
+
+
+-- ** objectSetControlBindingsDisabled
+    ObjectSetControlBindingsDisabledMethodInfo,
+    objectSetControlBindingsDisabled        ,
+
+
+-- ** objectSetControlRate
+    ObjectSetControlRateMethodInfo          ,
+    objectSetControlRate                    ,
+
+
+-- ** objectSetName
+    ObjectSetNameMethodInfo                 ,
+    objectSetName                           ,
+
+
+-- ** objectSetParent
+    ObjectSetParentMethodInfo               ,
+    objectSetParent                         ,
+
+
+-- ** objectSuggestNextSync
+    ObjectSuggestNextSyncMethodInfo         ,
+    objectSuggestNextSync                   ,
+
+
+-- ** objectSyncValues
+    ObjectSyncValuesMethodInfo              ,
+    objectSyncValues                        ,
+
+
+-- ** objectUnparent
+    ObjectUnparentMethodInfo                ,
+    objectUnparent                          ,
+
+
+-- ** objectUnref
+    ObjectUnrefMethodInfo                   ,
+    objectUnref                             ,
+
+
+
+
+ -- * Properties
+-- ** Name
+    ObjectNamePropertyInfo                  ,
+    constructObjectName                     ,
+    getObjectName                           ,
+    setObjectName                           ,
+
+
+-- ** Parent
+    ObjectParentPropertyInfo                ,
+    constructObjectParent                   ,
+    getObjectParent                         ,
+    setObjectParent                         ,
+
+
+
+
+ -- * Signals
+-- ** DeepNotify
+    ObjectDeepNotifyCallback                ,
+    ObjectDeepNotifyCallbackC               ,
+    ObjectDeepNotifySignalInfo              ,
+    afterObjectDeepNotify                   ,
+    mkObjectDeepNotifyCallback              ,
+    noObjectDeepNotifyCallback              ,
+    objectDeepNotifyCallbackWrapper         ,
+    objectDeepNotifyClosure                 ,
+    onObjectDeepNotify                      ,
+
+
+
+
+    ) where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+import GI.Gst.Callbacks
+import qualified GI.GObject as GObject
+
+newtype Object = Object (ForeignPtr Object)
+foreign import ccall "gst_object_get_type"
+    c_gst_object_get_type :: IO GType
+
+type instance ParentTypes Object = ObjectParentTypes
+type ObjectParentTypes = '[GObject.Object]
+
+instance GObject Object where
+    gobjectIsInitiallyUnowned _ = True
+    gobjectType _ = c_gst_object_get_type
+    
+
+class GObject o => ObjectK o
+instance (GObject o, IsDescendantOf Object o) => ObjectK o
+
+toObject :: ObjectK o => o -> IO Object
+toObject = unsafeCastTo Object
+
+noObject :: Maybe Object
+noObject = Nothing
+
+type family ResolveObjectMethod (t :: Symbol) (o :: *) :: * where
+    ResolveObjectMethod "addControlBinding" o = ObjectAddControlBindingMethodInfo
+    ResolveObjectMethod "bindProperty" o = GObject.ObjectBindPropertyMethodInfo
+    ResolveObjectMethod "bindPropertyFull" o = GObject.ObjectBindPropertyFullMethodInfo
+    ResolveObjectMethod "defaultError" o = ObjectDefaultErrorMethodInfo
+    ResolveObjectMethod "forceFloating" o = GObject.ObjectForceFloatingMethodInfo
+    ResolveObjectMethod "freezeNotify" o = GObject.ObjectFreezeNotifyMethodInfo
+    ResolveObjectMethod "hasActiveControlBindings" o = ObjectHasActiveControlBindingsMethodInfo
+    ResolveObjectMethod "hasAncestor" o = ObjectHasAncestorMethodInfo
+    ResolveObjectMethod "hasAsAncestor" o = ObjectHasAsAncestorMethodInfo
+    ResolveObjectMethod "hasAsParent" o = ObjectHasAsParentMethodInfo
+    ResolveObjectMethod "isFloating" o = GObject.ObjectIsFloatingMethodInfo
+    ResolveObjectMethod "notify" o = GObject.ObjectNotifyMethodInfo
+    ResolveObjectMethod "notifyByPspec" o = GObject.ObjectNotifyByPspecMethodInfo
+    ResolveObjectMethod "refSink" o = GObject.ObjectRefSinkMethodInfo
+    ResolveObjectMethod "removeControlBinding" o = ObjectRemoveControlBindingMethodInfo
+    ResolveObjectMethod "replaceData" o = GObject.ObjectReplaceDataMethodInfo
+    ResolveObjectMethod "replaceQdata" o = GObject.ObjectReplaceQdataMethodInfo
+    ResolveObjectMethod "runDispose" o = GObject.ObjectRunDisposeMethodInfo
+    ResolveObjectMethod "stealData" o = GObject.ObjectStealDataMethodInfo
+    ResolveObjectMethod "stealQdata" o = GObject.ObjectStealQdataMethodInfo
+    ResolveObjectMethod "suggestNextSync" o = ObjectSuggestNextSyncMethodInfo
+    ResolveObjectMethod "syncValues" o = ObjectSyncValuesMethodInfo
+    ResolveObjectMethod "thawNotify" o = GObject.ObjectThawNotifyMethodInfo
+    ResolveObjectMethod "unparent" o = ObjectUnparentMethodInfo
+    ResolveObjectMethod "watchClosure" o = GObject.ObjectWatchClosureMethodInfo
+    ResolveObjectMethod "getControlBinding" o = ObjectGetControlBindingMethodInfo
+    ResolveObjectMethod "getControlRate" o = ObjectGetControlRateMethodInfo
+    ResolveObjectMethod "getData" o = GObject.ObjectGetDataMethodInfo
+    ResolveObjectMethod "getGValueArray" o = ObjectGetGValueArrayMethodInfo
+    ResolveObjectMethod "getName" o = ObjectGetNameMethodInfo
+    ResolveObjectMethod "getParent" o = ObjectGetParentMethodInfo
+    ResolveObjectMethod "getPathString" o = ObjectGetPathStringMethodInfo
+    ResolveObjectMethod "getProperty" o = GObject.ObjectGetPropertyMethodInfo
+    ResolveObjectMethod "getQdata" o = GObject.ObjectGetQdataMethodInfo
+    ResolveObjectMethod "getValue" o = ObjectGetValueMethodInfo
+    ResolveObjectMethod "getValueArray" o = ObjectGetValueArrayMethodInfo
+    ResolveObjectMethod "setControlBindingDisabled" o = ObjectSetControlBindingDisabledMethodInfo
+    ResolveObjectMethod "setControlBindingsDisabled" o = ObjectSetControlBindingsDisabledMethodInfo
+    ResolveObjectMethod "setControlRate" o = ObjectSetControlRateMethodInfo
+    ResolveObjectMethod "setData" o = GObject.ObjectSetDataMethodInfo
+    ResolveObjectMethod "setName" o = ObjectSetNameMethodInfo
+    ResolveObjectMethod "setParent" o = ObjectSetParentMethodInfo
+    ResolveObjectMethod "setProperty" o = GObject.ObjectSetPropertyMethodInfo
+    ResolveObjectMethod l o = MethodResolutionFailed l o
+
+instance (info ~ ResolveObjectMethod t Object, MethodInfo info Object p) => IsLabelProxy t (Object -> p) where
+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)
+
+#if MIN_VERSION_base(4,9,0)
+instance (info ~ ResolveObjectMethod t Object, MethodInfo info Object p) => IsLabel t (Object -> p) where
+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)
+#endif
+
+-- signal Object::deep-notify
+type ObjectDeepNotifyCallback =
+    Object ->
+    GParamSpec ->
+    IO ()
+
+noObjectDeepNotifyCallback :: Maybe ObjectDeepNotifyCallback
+noObjectDeepNotifyCallback = Nothing
+
+type ObjectDeepNotifyCallbackC =
+    Ptr () ->                               -- object
+    Ptr Object ->
+    Ptr GParamSpec ->
+    Ptr () ->                               -- user_data
+    IO ()
+
+foreign import ccall "wrapper"
+    mkObjectDeepNotifyCallback :: ObjectDeepNotifyCallbackC -> IO (FunPtr ObjectDeepNotifyCallbackC)
+
+objectDeepNotifyClosure :: ObjectDeepNotifyCallback -> IO Closure
+objectDeepNotifyClosure cb = newCClosure =<< mkObjectDeepNotifyCallback wrapped
+    where wrapped = objectDeepNotifyCallbackWrapper cb
+
+objectDeepNotifyCallbackWrapper ::
+    ObjectDeepNotifyCallback ->
+    Ptr () ->
+    Ptr Object ->
+    Ptr GParamSpec ->
+    Ptr () ->
+    IO ()
+objectDeepNotifyCallbackWrapper _cb _ propObject prop _ = do
+    propObject' <- (newObject Object) propObject
+    prop' <- newGParamSpecFromPtr prop
+    _cb  propObject' prop'
+
+onObjectDeepNotify :: (GObject a, MonadIO m) => a -> ObjectDeepNotifyCallback -> m SignalHandlerId
+onObjectDeepNotify obj cb = liftIO $ connectObjectDeepNotify obj cb SignalConnectBefore
+afterObjectDeepNotify :: (GObject a, MonadIO m) => a -> ObjectDeepNotifyCallback -> m SignalHandlerId
+afterObjectDeepNotify obj cb = connectObjectDeepNotify obj cb SignalConnectAfter
+
+connectObjectDeepNotify :: (GObject a, MonadIO m) =>
+                           a -> ObjectDeepNotifyCallback -> SignalConnectMode -> m SignalHandlerId
+connectObjectDeepNotify obj cb after = liftIO $ do
+    cb' <- mkObjectDeepNotifyCallback (objectDeepNotifyCallbackWrapper cb)
+    connectSignalFunPtr obj "deep-notify" cb' after
+
+-- VVV Prop "name"
+   -- Type: TBasicType TUTF8
+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]
+
+getObjectName :: (MonadIO m, ObjectK o) => o -> m T.Text
+getObjectName obj = liftIO $ getObjectPropertyString obj "name"
+
+setObjectName :: (MonadIO m, ObjectK o) => o -> T.Text -> m ()
+setObjectName obj val = liftIO $ setObjectPropertyString obj "name" val
+
+constructObjectName :: T.Text -> IO ([Char], GValue)
+constructObjectName val = constructObjectPropertyString "name" val
+
+data ObjectNamePropertyInfo
+instance AttrInfo ObjectNamePropertyInfo where
+    type AttrAllowedOps ObjectNamePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
+    type AttrSetTypeConstraint ObjectNamePropertyInfo = (~) T.Text
+    type AttrBaseTypeConstraint ObjectNamePropertyInfo = ObjectK
+    type AttrGetType ObjectNamePropertyInfo = T.Text
+    type AttrLabel ObjectNamePropertyInfo = "name"
+    attrGet _ = getObjectName
+    attrSet _ = setObjectName
+    attrConstruct _ = constructObjectName
+
+-- VVV Prop "parent"
+   -- Type: TInterface "Gst" "Object"
+   -- Flags: [PropertyReadable,PropertyWritable]
+
+getObjectParent :: (MonadIO m, ObjectK o) => o -> m Object
+getObjectParent obj = liftIO $ getObjectPropertyObject obj "parent" Object
+
+setObjectParent :: (MonadIO m, ObjectK o, ObjectK a) => o -> a -> m ()
+setObjectParent obj val = liftIO $ setObjectPropertyObject obj "parent" val
+
+constructObjectParent :: (ObjectK a) => a -> IO ([Char], GValue)
+constructObjectParent val = constructObjectPropertyObject "parent" val
+
+data ObjectParentPropertyInfo
+instance AttrInfo ObjectParentPropertyInfo where
+    type AttrAllowedOps ObjectParentPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
+    type AttrSetTypeConstraint ObjectParentPropertyInfo = ObjectK
+    type AttrBaseTypeConstraint ObjectParentPropertyInfo = ObjectK
+    type AttrGetType ObjectParentPropertyInfo = Object
+    type AttrLabel ObjectParentPropertyInfo = "parent"
+    attrGet _ = getObjectParent
+    attrSet _ = setObjectParent
+    attrConstruct _ = constructObjectParent
+
+type instance AttributeList Object = ObjectAttributeList
+type ObjectAttributeList = ('[ '("name", ObjectNamePropertyInfo), '("parent", ObjectParentPropertyInfo)] :: [(Symbol, *)])
+
+data ObjectDeepNotifySignalInfo
+instance SignalInfo ObjectDeepNotifySignalInfo where
+    type HaskellCallbackType ObjectDeepNotifySignalInfo = ObjectDeepNotifyCallback
+    connectSignal _ = connectObjectDeepNotify
+
+type instance SignalList Object = ObjectSignalList
+type ObjectSignalList = ('[ '("deepNotify", ObjectDeepNotifySignalInfo), '("notify", GObject.ObjectNotifySignalInfo)] :: [(Symbol, *)])
+
+-- method Object::add_control_binding
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "binding", argType = TInterface "Gst" "ControlBinding", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_object_add_control_binding" gst_object_add_control_binding :: 
+    Ptr Object ->                           -- _obj : TInterface "Gst" "Object"
+    Ptr ControlBinding ->                   -- binding : TInterface "Gst" "ControlBinding"
+    IO CInt
+
+
+objectAddControlBinding ::
+    (MonadIO m, ObjectK a, ControlBindingK b) =>
+    a                                       -- _obj
+    -> b                                    -- binding
+    -> m Bool                               -- result
+objectAddControlBinding _obj binding = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    binding' <- refObject binding
+    result <- gst_object_add_control_binding _obj' binding'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    touchManagedPtr binding
+    return result'
+
+data ObjectAddControlBindingMethodInfo
+instance (signature ~ (b -> m Bool), MonadIO m, ObjectK a, ControlBindingK b) => MethodInfo ObjectAddControlBindingMethodInfo a signature where
+    overloadedMethod _ = objectAddControlBinding
+
+-- method Object::default_error
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "error", argType = TError, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "debug", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_object_default_error" gst_object_default_error :: 
+    Ptr Object ->                           -- _obj : TInterface "Gst" "Object"
+    Ptr GError ->                           -- error : TError
+    CString ->                              -- debug : TBasicType TUTF8
+    IO ()
+
+
+objectDefaultError ::
+    (MonadIO m, ObjectK a) =>
+    a                                       -- _obj
+    -> GError                               -- error_
+    -> Maybe (T.Text)                       -- debug
+    -> m ()                                 -- result
+objectDefaultError _obj error_ debug = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let error_' = unsafeManagedPtrGetPtr error_
+    maybeDebug <- case debug of
+        Nothing -> return nullPtr
+        Just jDebug -> do
+            jDebug' <- textToCString jDebug
+            return jDebug'
+    gst_object_default_error _obj' error_' maybeDebug
+    touchManagedPtr _obj
+    touchManagedPtr error_
+    freeMem maybeDebug
+    return ()
+
+data ObjectDefaultErrorMethodInfo
+instance (signature ~ (GError -> Maybe (T.Text) -> m ()), MonadIO m, ObjectK a) => MethodInfo ObjectDefaultErrorMethodInfo a signature where
+    overloadedMethod _ = objectDefaultError
+
+-- method Object::get_control_binding
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "property_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "ControlBinding"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_object_get_control_binding" gst_object_get_control_binding :: 
+    Ptr Object ->                           -- _obj : TInterface "Gst" "Object"
+    CString ->                              -- property_name : TBasicType TUTF8
+    IO (Ptr ControlBinding)
+
+
+objectGetControlBinding ::
+    (MonadIO m, ObjectK a) =>
+    a                                       -- _obj
+    -> T.Text                               -- propertyName
+    -> m ControlBinding                     -- result
+objectGetControlBinding _obj propertyName = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    propertyName' <- textToCString propertyName
+    result <- gst_object_get_control_binding _obj' propertyName'
+    checkUnexpectedReturnNULL "gst_object_get_control_binding" result
+    result' <- (wrapObject ControlBinding) result
+    touchManagedPtr _obj
+    freeMem propertyName'
+    return result'
+
+data ObjectGetControlBindingMethodInfo
+instance (signature ~ (T.Text -> m ControlBinding), MonadIO m, ObjectK a) => MethodInfo ObjectGetControlBindingMethodInfo a signature where
+    overloadedMethod _ = objectGetControlBinding
+
+-- method Object::get_control_rate
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUInt64
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_object_get_control_rate" gst_object_get_control_rate :: 
+    Ptr Object ->                           -- _obj : TInterface "Gst" "Object"
+    IO Word64
+
+
+objectGetControlRate ::
+    (MonadIO m, ObjectK a) =>
+    a                                       -- _obj
+    -> m Word64                             -- result
+objectGetControlRate _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_object_get_control_rate _obj'
+    touchManagedPtr _obj
+    return result
+
+data ObjectGetControlRateMethodInfo
+instance (signature ~ (m Word64), MonadIO m, ObjectK a) => MethodInfo ObjectGetControlRateMethodInfo a signature where
+    overloadedMethod _ = objectGetControlRate
+
+-- method Object::get_g_value_array
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "property_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "timestamp", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "interval", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_values", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "values", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_object_get_g_value_array" gst_object_get_g_value_array :: 
+    Ptr Object ->                           -- _obj : TInterface "Gst" "Object"
+    CString ->                              -- property_name : TBasicType TUTF8
+    Word64 ->                               -- timestamp : TBasicType TUInt64
+    Word64 ->                               -- interval : TBasicType TUInt64
+    Word32 ->                               -- n_values : TBasicType TUInt32
+    Ptr GValue ->                           -- values : TInterface "GObject" "Value"
+    IO CInt
+
+
+objectGetGValueArray ::
+    (MonadIO m, ObjectK a) =>
+    a                                       -- _obj
+    -> T.Text                               -- propertyName
+    -> Word64                               -- timestamp
+    -> Word64                               -- interval
+    -> Word32                               -- nValues
+    -> GValue                               -- values
+    -> m Bool                               -- result
+objectGetGValueArray _obj propertyName timestamp interval nValues values = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    propertyName' <- textToCString propertyName
+    let values' = unsafeManagedPtrGetPtr values
+    result <- gst_object_get_g_value_array _obj' propertyName' timestamp interval nValues values'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    touchManagedPtr values
+    freeMem propertyName'
+    return result'
+
+data ObjectGetGValueArrayMethodInfo
+instance (signature ~ (T.Text -> Word64 -> Word64 -> Word32 -> GValue -> m Bool), MonadIO m, ObjectK a) => MethodInfo ObjectGetGValueArrayMethodInfo a signature where
+    overloadedMethod _ = objectGetGValueArray
+
+-- method Object::get_name
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUTF8
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_object_get_name" gst_object_get_name :: 
+    Ptr Object ->                           -- _obj : TInterface "Gst" "Object"
+    IO CString
+
+
+objectGetName ::
+    (MonadIO m, ObjectK a) =>
+    a                                       -- _obj
+    -> m T.Text                             -- result
+objectGetName _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_object_get_name _obj'
+    checkUnexpectedReturnNULL "gst_object_get_name" result
+    result' <- cstringToText result
+    freeMem result
+    touchManagedPtr _obj
+    return result'
+
+data ObjectGetNameMethodInfo
+instance (signature ~ (m T.Text), MonadIO m, ObjectK a) => MethodInfo ObjectGetNameMethodInfo a signature where
+    overloadedMethod _ = objectGetName
+
+-- method Object::get_parent
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Object"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_object_get_parent" gst_object_get_parent :: 
+    Ptr Object ->                           -- _obj : TInterface "Gst" "Object"
+    IO (Ptr Object)
+
+
+objectGetParent ::
+    (MonadIO m, ObjectK a) =>
+    a                                       -- _obj
+    -> m Object                             -- result
+objectGetParent _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_object_get_parent _obj'
+    checkUnexpectedReturnNULL "gst_object_get_parent" result
+    result' <- (wrapObject Object) result
+    touchManagedPtr _obj
+    return result'
+
+data ObjectGetParentMethodInfo
+instance (signature ~ (m Object), MonadIO m, ObjectK a) => MethodInfo ObjectGetParentMethodInfo a signature where
+    overloadedMethod _ = objectGetParent
+
+-- method Object::get_path_string
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUTF8
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_object_get_path_string" gst_object_get_path_string :: 
+    Ptr Object ->                           -- _obj : TInterface "Gst" "Object"
+    IO CString
+
+
+objectGetPathString ::
+    (MonadIO m, ObjectK a) =>
+    a                                       -- _obj
+    -> m T.Text                             -- result
+objectGetPathString _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_object_get_path_string _obj'
+    checkUnexpectedReturnNULL "gst_object_get_path_string" result
+    result' <- cstringToText result
+    freeMem result
+    touchManagedPtr _obj
+    return result'
+
+data ObjectGetPathStringMethodInfo
+instance (signature ~ (m T.Text), MonadIO m, ObjectK a) => MethodInfo ObjectGetPathStringMethodInfo a signature where
+    overloadedMethod _ = objectGetPathString
+
+-- method Object::get_value
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "property_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "timestamp", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "GObject" "Value"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_object_get_value" gst_object_get_value :: 
+    Ptr Object ->                           -- _obj : TInterface "Gst" "Object"
+    CString ->                              -- property_name : TBasicType TUTF8
+    Word64 ->                               -- timestamp : TBasicType TUInt64
+    IO (Ptr GValue)
+
+
+objectGetValue ::
+    (MonadIO m, ObjectK a) =>
+    a                                       -- _obj
+    -> T.Text                               -- propertyName
+    -> Word64                               -- timestamp
+    -> m GValue                             -- result
+objectGetValue _obj propertyName timestamp = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    propertyName' <- textToCString propertyName
+    result <- gst_object_get_value _obj' propertyName' timestamp
+    checkUnexpectedReturnNULL "gst_object_get_value" result
+    result' <- (wrapBoxed GValue) result
+    touchManagedPtr _obj
+    freeMem propertyName'
+    return result'
+
+data ObjectGetValueMethodInfo
+instance (signature ~ (T.Text -> Word64 -> m GValue), MonadIO m, ObjectK a) => MethodInfo ObjectGetValueMethodInfo a signature where
+    overloadedMethod _ = objectGetValue
+
+-- method Object::get_value_array
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "property_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "timestamp", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "interval", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_values", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "values", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_object_get_value_array" gst_object_get_value_array :: 
+    Ptr Object ->                           -- _obj : TInterface "Gst" "Object"
+    CString ->                              -- property_name : TBasicType TUTF8
+    Word64 ->                               -- timestamp : TBasicType TUInt64
+    Word64 ->                               -- interval : TBasicType TUInt64
+    Word32 ->                               -- n_values : TBasicType TUInt32
+    Ptr () ->                               -- values : TBasicType TVoid
+    IO CInt
+
+
+objectGetValueArray ::
+    (MonadIO m, ObjectK a) =>
+    a                                       -- _obj
+    -> T.Text                               -- propertyName
+    -> Word64                               -- timestamp
+    -> Word64                               -- interval
+    -> Word32                               -- nValues
+    -> Ptr ()                               -- values
+    -> m Bool                               -- result
+objectGetValueArray _obj propertyName timestamp interval nValues values = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    propertyName' <- textToCString propertyName
+    result <- gst_object_get_value_array _obj' propertyName' timestamp interval nValues values
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    freeMem propertyName'
+    return result'
+
+data ObjectGetValueArrayMethodInfo
+instance (signature ~ (T.Text -> Word64 -> Word64 -> Word32 -> Ptr () -> m Bool), MonadIO m, ObjectK a) => MethodInfo ObjectGetValueArrayMethodInfo a signature where
+    overloadedMethod _ = objectGetValueArray
+
+-- method Object::has_active_control_bindings
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_object_has_active_control_bindings" gst_object_has_active_control_bindings :: 
+    Ptr Object ->                           -- _obj : TInterface "Gst" "Object"
+    IO CInt
+
+
+objectHasActiveControlBindings ::
+    (MonadIO m, ObjectK a) =>
+    a                                       -- _obj
+    -> m Bool                               -- result
+objectHasActiveControlBindings _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_object_has_active_control_bindings _obj'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data ObjectHasActiveControlBindingsMethodInfo
+instance (signature ~ (m Bool), MonadIO m, ObjectK a) => MethodInfo ObjectHasActiveControlBindingsMethodInfo a signature where
+    overloadedMethod _ = objectHasActiveControlBindings
+
+-- method Object::has_ancestor
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "ancestor", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_object_has_ancestor" gst_object_has_ancestor :: 
+    Ptr Object ->                           -- _obj : TInterface "Gst" "Object"
+    Ptr Object ->                           -- ancestor : TInterface "Gst" "Object"
+    IO CInt
+
+{-# DEPRECATED objectHasAncestor ["Use gst_object_has_as_ancestor() instead.","","MT safe. Grabs and releases @object's locks."]#-}
+objectHasAncestor ::
+    (MonadIO m, ObjectK a, ObjectK b) =>
+    a                                       -- _obj
+    -> b                                    -- ancestor
+    -> m Bool                               -- result
+objectHasAncestor _obj ancestor = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let ancestor' = unsafeManagedPtrCastPtr ancestor
+    result <- gst_object_has_ancestor _obj' ancestor'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    touchManagedPtr ancestor
+    return result'
+
+data ObjectHasAncestorMethodInfo
+instance (signature ~ (b -> m Bool), MonadIO m, ObjectK a, ObjectK b) => MethodInfo ObjectHasAncestorMethodInfo a signature where
+    overloadedMethod _ = objectHasAncestor
+
+-- method Object::has_as_ancestor
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "ancestor", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_object_has_as_ancestor" gst_object_has_as_ancestor :: 
+    Ptr Object ->                           -- _obj : TInterface "Gst" "Object"
+    Ptr Object ->                           -- ancestor : TInterface "Gst" "Object"
+    IO CInt
+
+
+objectHasAsAncestor ::
+    (MonadIO m, ObjectK a, ObjectK b) =>
+    a                                       -- _obj
+    -> b                                    -- ancestor
+    -> m Bool                               -- result
+objectHasAsAncestor _obj ancestor = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let ancestor' = unsafeManagedPtrCastPtr ancestor
+    result <- gst_object_has_as_ancestor _obj' ancestor'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    touchManagedPtr ancestor
+    return result'
+
+data ObjectHasAsAncestorMethodInfo
+instance (signature ~ (b -> m Bool), MonadIO m, ObjectK a, ObjectK b) => MethodInfo ObjectHasAsAncestorMethodInfo a signature where
+    overloadedMethod _ = objectHasAsAncestor
+
+-- method Object::has_as_parent
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "parent", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_object_has_as_parent" gst_object_has_as_parent :: 
+    Ptr Object ->                           -- _obj : TInterface "Gst" "Object"
+    Ptr Object ->                           -- parent : TInterface "Gst" "Object"
+    IO CInt
+
+
+objectHasAsParent ::
+    (MonadIO m, ObjectK a, ObjectK b) =>
+    a                                       -- _obj
+    -> b                                    -- parent
+    -> m Bool                               -- result
+objectHasAsParent _obj parent = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let parent' = unsafeManagedPtrCastPtr parent
+    result <- gst_object_has_as_parent _obj' parent'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    touchManagedPtr parent
+    return result'
+
+data ObjectHasAsParentMethodInfo
+instance (signature ~ (b -> m Bool), MonadIO m, ObjectK a, ObjectK b) => MethodInfo ObjectHasAsParentMethodInfo a signature where
+    overloadedMethod _ = objectHasAsParent
+
+-- method Object::ref
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Object"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_object_ref" gst_object_ref :: 
+    Ptr Object ->                           -- _obj : TInterface "Gst" "Object"
+    IO (Ptr Object)
+
+
+objectRef ::
+    (MonadIO m, ObjectK a) =>
+    a                                       -- _obj
+    -> m Object                             -- result
+objectRef _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_object_ref _obj'
+    checkUnexpectedReturnNULL "gst_object_ref" result
+    result' <- (wrapObject Object) result
+    touchManagedPtr _obj
+    return result'
+
+data ObjectRefMethodInfo
+instance (signature ~ (m Object), MonadIO m, ObjectK a) => MethodInfo ObjectRefMethodInfo a signature where
+    overloadedMethod _ = objectRef
+
+-- method Object::remove_control_binding
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "binding", argType = TInterface "Gst" "ControlBinding", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_object_remove_control_binding" gst_object_remove_control_binding :: 
+    Ptr Object ->                           -- _obj : TInterface "Gst" "Object"
+    Ptr ControlBinding ->                   -- binding : TInterface "Gst" "ControlBinding"
+    IO CInt
+
+
+objectRemoveControlBinding ::
+    (MonadIO m, ObjectK a, ControlBindingK b) =>
+    a                                       -- _obj
+    -> b                                    -- binding
+    -> m Bool                               -- result
+objectRemoveControlBinding _obj binding = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let binding' = unsafeManagedPtrCastPtr binding
+    result <- gst_object_remove_control_binding _obj' binding'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    touchManagedPtr binding
+    return result'
+
+data ObjectRemoveControlBindingMethodInfo
+instance (signature ~ (b -> m Bool), MonadIO m, ObjectK a, ControlBindingK b) => MethodInfo ObjectRemoveControlBindingMethodInfo a signature where
+    overloadedMethod _ = objectRemoveControlBinding
+
+-- method Object::set_control_binding_disabled
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "property_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "disabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_object_set_control_binding_disabled" gst_object_set_control_binding_disabled :: 
+    Ptr Object ->                           -- _obj : TInterface "Gst" "Object"
+    CString ->                              -- property_name : TBasicType TUTF8
+    CInt ->                                 -- disabled : TBasicType TBoolean
+    IO ()
+
+
+objectSetControlBindingDisabled ::
+    (MonadIO m, ObjectK a) =>
+    a                                       -- _obj
+    -> T.Text                               -- propertyName
+    -> Bool                                 -- disabled
+    -> m ()                                 -- result
+objectSetControlBindingDisabled _obj propertyName disabled = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    propertyName' <- textToCString propertyName
+    let disabled' = (fromIntegral . fromEnum) disabled
+    gst_object_set_control_binding_disabled _obj' propertyName' disabled'
+    touchManagedPtr _obj
+    freeMem propertyName'
+    return ()
+
+data ObjectSetControlBindingDisabledMethodInfo
+instance (signature ~ (T.Text -> Bool -> m ()), MonadIO m, ObjectK a) => MethodInfo ObjectSetControlBindingDisabledMethodInfo a signature where
+    overloadedMethod _ = objectSetControlBindingDisabled
+
+-- method Object::set_control_bindings_disabled
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "disabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_object_set_control_bindings_disabled" gst_object_set_control_bindings_disabled :: 
+    Ptr Object ->                           -- _obj : TInterface "Gst" "Object"
+    CInt ->                                 -- disabled : TBasicType TBoolean
+    IO ()
+
+
+objectSetControlBindingsDisabled ::
+    (MonadIO m, ObjectK a) =>
+    a                                       -- _obj
+    -> Bool                                 -- disabled
+    -> m ()                                 -- result
+objectSetControlBindingsDisabled _obj disabled = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let disabled' = (fromIntegral . fromEnum) disabled
+    gst_object_set_control_bindings_disabled _obj' disabled'
+    touchManagedPtr _obj
+    return ()
+
+data ObjectSetControlBindingsDisabledMethodInfo
+instance (signature ~ (Bool -> m ()), MonadIO m, ObjectK a) => MethodInfo ObjectSetControlBindingsDisabledMethodInfo a signature where
+    overloadedMethod _ = objectSetControlBindingsDisabled
+
+-- method Object::set_control_rate
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "control_rate", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_object_set_control_rate" gst_object_set_control_rate :: 
+    Ptr Object ->                           -- _obj : TInterface "Gst" "Object"
+    Word64 ->                               -- control_rate : TBasicType TUInt64
+    IO ()
+
+
+objectSetControlRate ::
+    (MonadIO m, ObjectK a) =>
+    a                                       -- _obj
+    -> Word64                               -- controlRate
+    -> m ()                                 -- result
+objectSetControlRate _obj controlRate = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    gst_object_set_control_rate _obj' controlRate
+    touchManagedPtr _obj
+    return ()
+
+data ObjectSetControlRateMethodInfo
+instance (signature ~ (Word64 -> m ()), MonadIO m, ObjectK a) => MethodInfo ObjectSetControlRateMethodInfo a signature where
+    overloadedMethod _ = objectSetControlRate
+
+-- method Object::set_name
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_object_set_name" gst_object_set_name :: 
+    Ptr Object ->                           -- _obj : TInterface "Gst" "Object"
+    CString ->                              -- name : TBasicType TUTF8
+    IO CInt
+
+
+objectSetName ::
+    (MonadIO m, ObjectK a) =>
+    a                                       -- _obj
+    -> Maybe (T.Text)                       -- name
+    -> m Bool                               -- result
+objectSetName _obj name = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    maybeName <- case name of
+        Nothing -> return nullPtr
+        Just jName -> do
+            jName' <- textToCString jName
+            return jName'
+    result <- gst_object_set_name _obj' maybeName
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    freeMem maybeName
+    return result'
+
+data ObjectSetNameMethodInfo
+instance (signature ~ (Maybe (T.Text) -> m Bool), MonadIO m, ObjectK a) => MethodInfo ObjectSetNameMethodInfo a signature where
+    overloadedMethod _ = objectSetName
+
+-- method Object::set_parent
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "parent", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_object_set_parent" gst_object_set_parent :: 
+    Ptr Object ->                           -- _obj : TInterface "Gst" "Object"
+    Ptr Object ->                           -- parent : TInterface "Gst" "Object"
+    IO CInt
+
+
+objectSetParent ::
+    (MonadIO m, ObjectK a, ObjectK b) =>
+    a                                       -- _obj
+    -> b                                    -- parent
+    -> m Bool                               -- result
+objectSetParent _obj parent = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let parent' = unsafeManagedPtrCastPtr parent
+    result <- gst_object_set_parent _obj' parent'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    touchManagedPtr parent
+    return result'
+
+data ObjectSetParentMethodInfo
+instance (signature ~ (b -> m Bool), MonadIO m, ObjectK a, ObjectK b) => MethodInfo ObjectSetParentMethodInfo a signature where
+    overloadedMethod _ = objectSetParent
+
+-- method Object::suggest_next_sync
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUInt64
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_object_suggest_next_sync" gst_object_suggest_next_sync :: 
+    Ptr Object ->                           -- _obj : TInterface "Gst" "Object"
+    IO Word64
+
+
+objectSuggestNextSync ::
+    (MonadIO m, ObjectK a) =>
+    a                                       -- _obj
+    -> m Word64                             -- result
+objectSuggestNextSync _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_object_suggest_next_sync _obj'
+    touchManagedPtr _obj
+    return result
+
+data ObjectSuggestNextSyncMethodInfo
+instance (signature ~ (m Word64), MonadIO m, ObjectK a) => MethodInfo ObjectSuggestNextSyncMethodInfo a signature where
+    overloadedMethod _ = objectSuggestNextSync
+
+-- method Object::sync_values
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "timestamp", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_object_sync_values" gst_object_sync_values :: 
+    Ptr Object ->                           -- _obj : TInterface "Gst" "Object"
+    Word64 ->                               -- timestamp : TBasicType TUInt64
+    IO CInt
+
+
+objectSyncValues ::
+    (MonadIO m, ObjectK a) =>
+    a                                       -- _obj
+    -> Word64                               -- timestamp
+    -> m Bool                               -- result
+objectSyncValues _obj timestamp = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_object_sync_values _obj' timestamp
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data ObjectSyncValuesMethodInfo
+instance (signature ~ (Word64 -> m Bool), MonadIO m, ObjectK a) => MethodInfo ObjectSyncValuesMethodInfo a signature where
+    overloadedMethod _ = objectSyncValues
+
+-- method Object::unparent
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_object_unparent" gst_object_unparent :: 
+    Ptr Object ->                           -- _obj : TInterface "Gst" "Object"
+    IO ()
+
+
+objectUnparent ::
+    (MonadIO m, ObjectK a) =>
+    a                                       -- _obj
+    -> m ()                                 -- result
+objectUnparent _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    gst_object_unparent _obj'
+    touchManagedPtr _obj
+    return ()
+
+data ObjectUnparentMethodInfo
+instance (signature ~ (m ()), MonadIO m, ObjectK a) => MethodInfo ObjectUnparentMethodInfo a signature where
+    overloadedMethod _ = objectUnparent
+
+-- method Object::unref
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_object_unref" gst_object_unref :: 
+    Ptr Object ->                           -- _obj : TInterface "Gst" "Object"
+    IO ()
+
+
+objectUnref ::
+    (MonadIO m, ObjectK a) =>
+    a                                       -- _obj
+    -> m ()                                 -- result
+objectUnref _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    gst_object_unref _obj'
+    touchManagedPtr _obj
+    return ()
+
+data ObjectUnrefMethodInfo
+instance (signature ~ (m ()), MonadIO m, ObjectK a) => MethodInfo ObjectUnrefMethodInfo a signature where
+    overloadedMethod _ = objectUnref
+
+-- method Object::check_uniqueness
+-- method type : MemberFunction
+-- Args : [Arg {argCName = "list", argType = TGList (TInterface "Gst" "Object"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_object_check_uniqueness" gst_object_check_uniqueness :: 
+    Ptr (GList (Ptr Object)) ->             -- list : TGList (TInterface "Gst" "Object")
+    CString ->                              -- name : TBasicType TUTF8
+    IO CInt
+
+
+objectCheckUniqueness ::
+    (MonadIO m, ObjectK a) =>
+    [a]                                     -- list
+    -> T.Text                               -- name
+    -> m Bool                               -- result
+objectCheckUniqueness list name = liftIO $ do
+    let list' = map unsafeManagedPtrCastPtr list
+    list'' <- packGList list'
+    name' <- textToCString name
+    result <- gst_object_check_uniqueness list'' name'
+    let result' = (/= 0) result
+    mapM_ touchManagedPtr list
+    g_list_free list''
+    freeMem name'
+    return result'
+
+-- method Object::default_deep_notify
+-- method type : MemberFunction
+-- Args : [Arg {argCName = "object", argType = TInterface "GObject" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "orig", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pspec", argType = TParamSpec, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "excluded_props", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_object_default_deep_notify" gst_object_default_deep_notify :: 
+    Ptr GObject.Object ->                   -- object : TInterface "GObject" "Object"
+    Ptr Object ->                           -- orig : TInterface "Gst" "Object"
+    Ptr GParamSpec ->                       -- pspec : TParamSpec
+    Ptr CString ->                          -- excluded_props : TCArray True (-1) (-1) (TBasicType TUTF8)
+    IO ()
+
+
+objectDefaultDeepNotify ::
+    (MonadIO m, GObject.ObjectK a, ObjectK b) =>
+    a                                       -- object
+    -> b                                    -- orig
+    -> GParamSpec                           -- pspec
+    -> Maybe ([T.Text])                     -- excludedProps
+    -> m ()                                 -- result
+objectDefaultDeepNotify object orig pspec excludedProps = liftIO $ do
+    let object' = unsafeManagedPtrCastPtr object
+    let orig' = unsafeManagedPtrCastPtr orig
+    let pspec' = unsafeManagedPtrGetPtr pspec
+    maybeExcludedProps <- case excludedProps of
+        Nothing -> return nullPtr
+        Just jExcludedProps -> do
+            jExcludedProps' <- packZeroTerminatedUTF8CArray jExcludedProps
+            return jExcludedProps'
+    gst_object_default_deep_notify object' orig' pspec' maybeExcludedProps
+    touchManagedPtr object
+    touchManagedPtr orig
+    mapZeroTerminatedCArray freeMem maybeExcludedProps
+    freeMem maybeExcludedProps
+    return ()
+
+-- method Object::replace
+-- method type : MemberFunction
+-- Args : [Arg {argCName = "oldobj", argType = TInterface "Gst" "Object", direction = DirectionInout, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "newobj", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_object_replace" gst_object_replace :: 
+    Ptr (Ptr Object) ->                     -- oldobj : TInterface "Gst" "Object"
+    Ptr Object ->                           -- newobj : TInterface "Gst" "Object"
+    IO CInt
+
+
+objectReplace ::
+    (MonadIO m, ObjectK a, ObjectK b) =>
+    Maybe (a)                               -- oldobj
+    -> Maybe (b)                            -- newobj
+    -> m (Bool,(Maybe Object))              -- result
+objectReplace oldobj newobj = liftIO $ do
+    maybeOldobj <- case oldobj of
+        Nothing -> return nullPtr
+        Just jOldobj -> do
+            jOldobj' <- refObject jOldobj
+            return jOldobj'
+    maybeOldobj' <- allocMem :: IO (Ptr (Ptr Object))
+    poke maybeOldobj' maybeOldobj
+    maybeNewobj <- case newobj of
+        Nothing -> return nullPtr
+        Just jNewobj -> do
+            let jNewobj' = unsafeManagedPtrCastPtr jNewobj
+            return jNewobj'
+    result <- gst_object_replace maybeOldobj' maybeNewobj
+    let result' = (/= 0) result
+    maybeOldobj'' <- peek maybeOldobj'
+    maybeMaybeOldobj'' <- convertIfNonNull maybeOldobj'' $ \maybeOldobj''' -> do
+        maybeOldobj'''' <- (wrapObject Object) maybeOldobj'''
+        return maybeOldobj''''
+    whenJust oldobj touchManagedPtr
+    whenJust newobj touchManagedPtr
+    freeMem maybeOldobj'
+    return (result', maybeMaybeOldobj'')
+
+
diff --git a/GI/Gst/Objects/Object.hs-boot b/GI/Gst/Objects/Object.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Objects/Object.hs-boot
@@ -0,0 +1,41 @@
+module GI.Gst.Objects.Object where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+newtype Object = Object (ForeignPtr Object)
+instance GObject Object where
+class GObject o => ObjectK o
+instance (GObject o, IsDescendantOf Object o) => ObjectK o
+data ObjectNamePropertyInfo
+data ObjectParentPropertyInfo
+data ObjectDeepNotifySignalInfo
+data ObjectAddControlBindingMethodInfo
+data ObjectDefaultErrorMethodInfo
+data ObjectGetControlBindingMethodInfo
+data ObjectGetControlRateMethodInfo
+data ObjectGetGValueArrayMethodInfo
+data ObjectGetNameMethodInfo
+data ObjectGetParentMethodInfo
+data ObjectGetPathStringMethodInfo
+data ObjectGetValueMethodInfo
+data ObjectGetValueArrayMethodInfo
+data ObjectHasActiveControlBindingsMethodInfo
+data ObjectHasAncestorMethodInfo
+data ObjectHasAsAncestorMethodInfo
+data ObjectHasAsParentMethodInfo
+data ObjectRefMethodInfo
+data ObjectRemoveControlBindingMethodInfo
+data ObjectSetControlBindingDisabledMethodInfo
+data ObjectSetControlBindingsDisabledMethodInfo
+data ObjectSetControlRateMethodInfo
+data ObjectSetNameMethodInfo
+data ObjectSetParentMethodInfo
+data ObjectSuggestNextSyncMethodInfo
+data ObjectSyncValuesMethodInfo
+data ObjectUnparentMethodInfo
+data ObjectUnrefMethodInfo
diff --git a/GI/Gst/Objects/Pad.hs b/GI/Gst/Objects/Pad.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Objects/Pad.hs
@@ -0,0 +1,3315 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+-}
+
+module GI.Gst.Objects.Pad
+    ( 
+
+-- * Exported types
+    Pad(..)                                 ,
+    PadK                                    ,
+    toPad                                   ,
+    noPad                                   ,
+
+
+ -- * Methods
+-- ** padActivateMode
+    PadActivateModeMethodInfo               ,
+    padActivateMode                         ,
+
+
+-- ** padAddProbe
+    PadAddProbeMethodInfo                   ,
+    padAddProbe                             ,
+
+
+-- ** padCanLink
+    PadCanLinkMethodInfo                    ,
+    padCanLink                              ,
+
+
+-- ** padChain
+    PadChainMethodInfo                      ,
+    padChain                                ,
+
+
+-- ** padChainList
+    PadChainListMethodInfo                  ,
+    padChainList                            ,
+
+
+-- ** padCheckReconfigure
+    PadCheckReconfigureMethodInfo           ,
+    padCheckReconfigure                     ,
+
+
+-- ** padCreateStreamId
+    PadCreateStreamIdMethodInfo             ,
+    padCreateStreamId                       ,
+
+
+-- ** padEventDefault
+    PadEventDefaultMethodInfo               ,
+    padEventDefault                         ,
+
+
+-- ** padForward
+    PadForwardMethodInfo                    ,
+    padForward                              ,
+
+
+-- ** padGetAllowedCaps
+    PadGetAllowedCapsMethodInfo             ,
+    padGetAllowedCaps                       ,
+
+
+-- ** padGetCurrentCaps
+    PadGetCurrentCapsMethodInfo             ,
+    padGetCurrentCaps                       ,
+
+
+-- ** padGetDirection
+    PadGetDirectionMethodInfo               ,
+    padGetDirection                         ,
+
+
+-- ** padGetElementPrivate
+    PadGetElementPrivateMethodInfo          ,
+    padGetElementPrivate                    ,
+
+
+-- ** padGetLastFlowReturn
+    PadGetLastFlowReturnMethodInfo          ,
+    padGetLastFlowReturn                    ,
+
+
+-- ** padGetOffset
+    PadGetOffsetMethodInfo                  ,
+    padGetOffset                            ,
+
+
+-- ** padGetPadTemplate
+    PadGetPadTemplateMethodInfo             ,
+    padGetPadTemplate                       ,
+
+
+-- ** padGetPadTemplateCaps
+    PadGetPadTemplateCapsMethodInfo         ,
+    padGetPadTemplateCaps                   ,
+
+
+-- ** padGetParentElement
+    PadGetParentElementMethodInfo           ,
+    padGetParentElement                     ,
+
+
+-- ** padGetPeer
+    PadGetPeerMethodInfo                    ,
+    padGetPeer                              ,
+
+
+-- ** padGetRange
+    PadGetRangeMethodInfo                   ,
+    padGetRange                             ,
+
+
+-- ** padGetStickyEvent
+    PadGetStickyEventMethodInfo             ,
+    padGetStickyEvent                       ,
+
+
+-- ** padGetStreamId
+    PadGetStreamIdMethodInfo                ,
+    padGetStreamId                          ,
+
+
+-- ** padHasCurrentCaps
+    PadHasCurrentCapsMethodInfo             ,
+    padHasCurrentCaps                       ,
+
+
+-- ** padIsActive
+    PadIsActiveMethodInfo                   ,
+    padIsActive                             ,
+
+
+-- ** padIsBlocked
+    PadIsBlockedMethodInfo                  ,
+    padIsBlocked                            ,
+
+
+-- ** padIsBlocking
+    PadIsBlockingMethodInfo                 ,
+    padIsBlocking                           ,
+
+
+-- ** padIsLinked
+    PadIsLinkedMethodInfo                   ,
+    padIsLinked                             ,
+
+
+-- ** padIterateInternalLinks
+    PadIterateInternalLinksMethodInfo       ,
+    padIterateInternalLinks                 ,
+
+
+-- ** padIterateInternalLinksDefault
+    PadIterateInternalLinksDefaultMethodInfo,
+    padIterateInternalLinksDefault          ,
+
+
+-- ** padLink
+    PadLinkMethodInfo                       ,
+    padLink                                 ,
+
+
+-- ** padLinkFull
+    PadLinkFullMethodInfo                   ,
+    padLinkFull                             ,
+
+
+-- ** padLinkGetName
+    padLinkGetName                          ,
+
+
+-- ** padMarkReconfigure
+    PadMarkReconfigureMethodInfo            ,
+    padMarkReconfigure                      ,
+
+
+-- ** padNeedsReconfigure
+    PadNeedsReconfigureMethodInfo           ,
+    padNeedsReconfigure                     ,
+
+
+-- ** padNew
+    padNew                                  ,
+
+
+-- ** padNewFromStaticTemplate
+    padNewFromStaticTemplate                ,
+
+
+-- ** padNewFromTemplate
+    padNewFromTemplate                      ,
+
+
+-- ** padPauseTask
+    PadPauseTaskMethodInfo                  ,
+    padPauseTask                            ,
+
+
+-- ** padPeerQuery
+    PadPeerQueryMethodInfo                  ,
+    padPeerQuery                            ,
+
+
+-- ** padPeerQueryAcceptCaps
+    PadPeerQueryAcceptCapsMethodInfo        ,
+    padPeerQueryAcceptCaps                  ,
+
+
+-- ** padPeerQueryCaps
+    PadPeerQueryCapsMethodInfo              ,
+    padPeerQueryCaps                        ,
+
+
+-- ** padPeerQueryConvert
+    PadPeerQueryConvertMethodInfo           ,
+    padPeerQueryConvert                     ,
+
+
+-- ** padPeerQueryDuration
+    PadPeerQueryDurationMethodInfo          ,
+    padPeerQueryDuration                    ,
+
+
+-- ** padPeerQueryPosition
+    PadPeerQueryPositionMethodInfo          ,
+    padPeerQueryPosition                    ,
+
+
+-- ** padProxyQueryAcceptCaps
+    PadProxyQueryAcceptCapsMethodInfo       ,
+    padProxyQueryAcceptCaps                 ,
+
+
+-- ** padProxyQueryCaps
+    PadProxyQueryCapsMethodInfo             ,
+    padProxyQueryCaps                       ,
+
+
+-- ** padPullRange
+    PadPullRangeMethodInfo                  ,
+    padPullRange                            ,
+
+
+-- ** padPush
+    PadPushMethodInfo                       ,
+    padPush                                 ,
+
+
+-- ** padPushEvent
+    PadPushEventMethodInfo                  ,
+    padPushEvent                            ,
+
+
+-- ** padPushList
+    PadPushListMethodInfo                   ,
+    padPushList                             ,
+
+
+-- ** padQuery
+    PadQueryMethodInfo                      ,
+    padQuery                                ,
+
+
+-- ** padQueryAcceptCaps
+    PadQueryAcceptCapsMethodInfo            ,
+    padQueryAcceptCaps                      ,
+
+
+-- ** padQueryCaps
+    PadQueryCapsMethodInfo                  ,
+    padQueryCaps                            ,
+
+
+-- ** padQueryConvert
+    PadQueryConvertMethodInfo               ,
+    padQueryConvert                         ,
+
+
+-- ** padQueryDefault
+    PadQueryDefaultMethodInfo               ,
+    padQueryDefault                         ,
+
+
+-- ** padQueryDuration
+    PadQueryDurationMethodInfo              ,
+    padQueryDuration                        ,
+
+
+-- ** padQueryPosition
+    PadQueryPositionMethodInfo              ,
+    padQueryPosition                        ,
+
+
+-- ** padRemoveProbe
+    PadRemoveProbeMethodInfo                ,
+    padRemoveProbe                          ,
+
+
+-- ** padSendEvent
+    PadSendEventMethodInfo                  ,
+    padSendEvent                            ,
+
+
+-- ** padSetActivateFunctionFull
+    PadSetActivateFunctionFullMethodInfo    ,
+    padSetActivateFunctionFull              ,
+
+
+-- ** padSetActivatemodeFunctionFull
+    PadSetActivatemodeFunctionFullMethodInfo,
+    padSetActivatemodeFunctionFull          ,
+
+
+-- ** padSetActive
+    PadSetActiveMethodInfo                  ,
+    padSetActive                            ,
+
+
+-- ** padSetChainFunctionFull
+    PadSetChainFunctionFullMethodInfo       ,
+    padSetChainFunctionFull                 ,
+
+
+-- ** padSetChainListFunctionFull
+    PadSetChainListFunctionFullMethodInfo   ,
+    padSetChainListFunctionFull             ,
+
+
+-- ** padSetElementPrivate
+    PadSetElementPrivateMethodInfo          ,
+    padSetElementPrivate                    ,
+
+
+-- ** padSetEventFunctionFull
+    PadSetEventFunctionFullMethodInfo       ,
+    padSetEventFunctionFull                 ,
+
+
+-- ** padSetGetrangeFunctionFull
+    PadSetGetrangeFunctionFullMethodInfo    ,
+    padSetGetrangeFunctionFull              ,
+
+
+-- ** padSetIterateInternalLinksFunctionFull
+    PadSetIterateInternalLinksFunctionFullMethodInfo,
+    padSetIterateInternalLinksFunctionFull  ,
+
+
+-- ** padSetLinkFunctionFull
+    PadSetLinkFunctionFullMethodInfo        ,
+    padSetLinkFunctionFull                  ,
+
+
+-- ** padSetOffset
+    PadSetOffsetMethodInfo                  ,
+    padSetOffset                            ,
+
+
+-- ** padSetQueryFunctionFull
+    PadSetQueryFunctionFullMethodInfo       ,
+    padSetQueryFunctionFull                 ,
+
+
+-- ** padSetUnlinkFunctionFull
+    PadSetUnlinkFunctionFullMethodInfo      ,
+    padSetUnlinkFunctionFull                ,
+
+
+-- ** padStartTask
+    PadStartTaskMethodInfo                  ,
+    padStartTask                            ,
+
+
+-- ** padStickyEventsForeach
+    PadStickyEventsForeachMethodInfo        ,
+    padStickyEventsForeach                  ,
+
+
+-- ** padStopTask
+    PadStopTaskMethodInfo                   ,
+    padStopTask                             ,
+
+
+-- ** padStoreStickyEvent
+    PadStoreStickyEventMethodInfo           ,
+    padStoreStickyEvent                     ,
+
+
+-- ** padUnlink
+    PadUnlinkMethodInfo                     ,
+    padUnlink                               ,
+
+
+-- ** padUseFixedCaps
+    PadUseFixedCapsMethodInfo               ,
+    padUseFixedCaps                         ,
+
+
+
+
+ -- * Properties
+-- ** Caps
+    PadCapsPropertyInfo                     ,
+    getPadCaps                              ,
+
+
+-- ** Direction
+    PadDirectionPropertyInfo                ,
+    constructPadDirection                   ,
+    getPadDirection                         ,
+
+
+-- ** Offset
+    PadOffsetPropertyInfo                   ,
+    constructPadOffset                      ,
+    getPadOffset                            ,
+    setPadOffset                            ,
+
+
+-- ** Template
+    PadTemplatePropertyInfo                 ,
+    constructPadTemplate                    ,
+    getPadTemplate                          ,
+    setPadTemplate                          ,
+
+
+
+
+ -- * Signals
+-- ** Linked
+    PadLinkedCallback                       ,
+    PadLinkedCallbackC                      ,
+    PadLinkedSignalInfo                     ,
+    afterPadLinked                          ,
+    mkPadLinkedCallback                     ,
+    noPadLinkedCallback                     ,
+    onPadLinked                             ,
+    padLinkedCallbackWrapper                ,
+    padLinkedClosure                        ,
+
+
+-- ** Unlinked
+    PadUnlinkedCallback                     ,
+    PadUnlinkedCallbackC                    ,
+    PadUnlinkedSignalInfo                   ,
+    afterPadUnlinked                        ,
+    mkPadUnlinkedCallback                   ,
+    noPadUnlinkedCallback                   ,
+    onPadUnlinked                           ,
+    padUnlinkedCallbackWrapper              ,
+    padUnlinkedClosure                      ,
+
+
+
+
+    ) where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+import GI.Gst.Callbacks
+import qualified GI.GLib as GLib
+import qualified GI.GObject as GObject
+
+newtype Pad = Pad (ForeignPtr Pad)
+foreign import ccall "gst_pad_get_type"
+    c_gst_pad_get_type :: IO GType
+
+type instance ParentTypes Pad = PadParentTypes
+type PadParentTypes = '[Object, GObject.Object]
+
+instance GObject Pad where
+    gobjectIsInitiallyUnowned _ = True
+    gobjectType _ = c_gst_pad_get_type
+    
+
+class GObject o => PadK o
+instance (GObject o, IsDescendantOf Pad o) => PadK o
+
+toPad :: PadK o => o -> IO Pad
+toPad = unsafeCastTo Pad
+
+noPad :: Maybe Pad
+noPad = Nothing
+
+type family ResolvePadMethod (t :: Symbol) (o :: *) :: * where
+    ResolvePadMethod "activateMode" o = PadActivateModeMethodInfo
+    ResolvePadMethod "addControlBinding" o = ObjectAddControlBindingMethodInfo
+    ResolvePadMethod "addProbe" o = PadAddProbeMethodInfo
+    ResolvePadMethod "bindProperty" o = GObject.ObjectBindPropertyMethodInfo
+    ResolvePadMethod "bindPropertyFull" o = GObject.ObjectBindPropertyFullMethodInfo
+    ResolvePadMethod "canLink" o = PadCanLinkMethodInfo
+    ResolvePadMethod "chain" o = PadChainMethodInfo
+    ResolvePadMethod "chainList" o = PadChainListMethodInfo
+    ResolvePadMethod "checkReconfigure" o = PadCheckReconfigureMethodInfo
+    ResolvePadMethod "createStreamId" o = PadCreateStreamIdMethodInfo
+    ResolvePadMethod "defaultError" o = ObjectDefaultErrorMethodInfo
+    ResolvePadMethod "eventDefault" o = PadEventDefaultMethodInfo
+    ResolvePadMethod "forceFloating" o = GObject.ObjectForceFloatingMethodInfo
+    ResolvePadMethod "forward" o = PadForwardMethodInfo
+    ResolvePadMethod "freezeNotify" o = GObject.ObjectFreezeNotifyMethodInfo
+    ResolvePadMethod "hasActiveControlBindings" o = ObjectHasActiveControlBindingsMethodInfo
+    ResolvePadMethod "hasAncestor" o = ObjectHasAncestorMethodInfo
+    ResolvePadMethod "hasAsAncestor" o = ObjectHasAsAncestorMethodInfo
+    ResolvePadMethod "hasAsParent" o = ObjectHasAsParentMethodInfo
+    ResolvePadMethod "hasCurrentCaps" o = PadHasCurrentCapsMethodInfo
+    ResolvePadMethod "isActive" o = PadIsActiveMethodInfo
+    ResolvePadMethod "isBlocked" o = PadIsBlockedMethodInfo
+    ResolvePadMethod "isBlocking" o = PadIsBlockingMethodInfo
+    ResolvePadMethod "isFloating" o = GObject.ObjectIsFloatingMethodInfo
+    ResolvePadMethod "isLinked" o = PadIsLinkedMethodInfo
+    ResolvePadMethod "iterateInternalLinks" o = PadIterateInternalLinksMethodInfo
+    ResolvePadMethod "iterateInternalLinksDefault" o = PadIterateInternalLinksDefaultMethodInfo
+    ResolvePadMethod "link" o = PadLinkMethodInfo
+    ResolvePadMethod "linkFull" o = PadLinkFullMethodInfo
+    ResolvePadMethod "markReconfigure" o = PadMarkReconfigureMethodInfo
+    ResolvePadMethod "needsReconfigure" o = PadNeedsReconfigureMethodInfo
+    ResolvePadMethod "notify" o = GObject.ObjectNotifyMethodInfo
+    ResolvePadMethod "notifyByPspec" o = GObject.ObjectNotifyByPspecMethodInfo
+    ResolvePadMethod "pauseTask" o = PadPauseTaskMethodInfo
+    ResolvePadMethod "peerQuery" o = PadPeerQueryMethodInfo
+    ResolvePadMethod "peerQueryAcceptCaps" o = PadPeerQueryAcceptCapsMethodInfo
+    ResolvePadMethod "peerQueryCaps" o = PadPeerQueryCapsMethodInfo
+    ResolvePadMethod "peerQueryConvert" o = PadPeerQueryConvertMethodInfo
+    ResolvePadMethod "peerQueryDuration" o = PadPeerQueryDurationMethodInfo
+    ResolvePadMethod "peerQueryPosition" o = PadPeerQueryPositionMethodInfo
+    ResolvePadMethod "proxyQueryAcceptCaps" o = PadProxyQueryAcceptCapsMethodInfo
+    ResolvePadMethod "proxyQueryCaps" o = PadProxyQueryCapsMethodInfo
+    ResolvePadMethod "pullRange" o = PadPullRangeMethodInfo
+    ResolvePadMethod "push" o = PadPushMethodInfo
+    ResolvePadMethod "pushEvent" o = PadPushEventMethodInfo
+    ResolvePadMethod "pushList" o = PadPushListMethodInfo
+    ResolvePadMethod "query" o = PadQueryMethodInfo
+    ResolvePadMethod "queryAcceptCaps" o = PadQueryAcceptCapsMethodInfo
+    ResolvePadMethod "queryCaps" o = PadQueryCapsMethodInfo
+    ResolvePadMethod "queryConvert" o = PadQueryConvertMethodInfo
+    ResolvePadMethod "queryDefault" o = PadQueryDefaultMethodInfo
+    ResolvePadMethod "queryDuration" o = PadQueryDurationMethodInfo
+    ResolvePadMethod "queryPosition" o = PadQueryPositionMethodInfo
+    ResolvePadMethod "refSink" o = GObject.ObjectRefSinkMethodInfo
+    ResolvePadMethod "removeControlBinding" o = ObjectRemoveControlBindingMethodInfo
+    ResolvePadMethod "removeProbe" o = PadRemoveProbeMethodInfo
+    ResolvePadMethod "replaceData" o = GObject.ObjectReplaceDataMethodInfo
+    ResolvePadMethod "replaceQdata" o = GObject.ObjectReplaceQdataMethodInfo
+    ResolvePadMethod "runDispose" o = GObject.ObjectRunDisposeMethodInfo
+    ResolvePadMethod "sendEvent" o = PadSendEventMethodInfo
+    ResolvePadMethod "startTask" o = PadStartTaskMethodInfo
+    ResolvePadMethod "stealData" o = GObject.ObjectStealDataMethodInfo
+    ResolvePadMethod "stealQdata" o = GObject.ObjectStealQdataMethodInfo
+    ResolvePadMethod "stickyEventsForeach" o = PadStickyEventsForeachMethodInfo
+    ResolvePadMethod "stopTask" o = PadStopTaskMethodInfo
+    ResolvePadMethod "storeStickyEvent" o = PadStoreStickyEventMethodInfo
+    ResolvePadMethod "suggestNextSync" o = ObjectSuggestNextSyncMethodInfo
+    ResolvePadMethod "syncValues" o = ObjectSyncValuesMethodInfo
+    ResolvePadMethod "thawNotify" o = GObject.ObjectThawNotifyMethodInfo
+    ResolvePadMethod "unlink" o = PadUnlinkMethodInfo
+    ResolvePadMethod "unparent" o = ObjectUnparentMethodInfo
+    ResolvePadMethod "useFixedCaps" o = PadUseFixedCapsMethodInfo
+    ResolvePadMethod "watchClosure" o = GObject.ObjectWatchClosureMethodInfo
+    ResolvePadMethod "getAllowedCaps" o = PadGetAllowedCapsMethodInfo
+    ResolvePadMethod "getControlBinding" o = ObjectGetControlBindingMethodInfo
+    ResolvePadMethod "getControlRate" o = ObjectGetControlRateMethodInfo
+    ResolvePadMethod "getCurrentCaps" o = PadGetCurrentCapsMethodInfo
+    ResolvePadMethod "getData" o = GObject.ObjectGetDataMethodInfo
+    ResolvePadMethod "getDirection" o = PadGetDirectionMethodInfo
+    ResolvePadMethod "getElementPrivate" o = PadGetElementPrivateMethodInfo
+    ResolvePadMethod "getGValueArray" o = ObjectGetGValueArrayMethodInfo
+    ResolvePadMethod "getLastFlowReturn" o = PadGetLastFlowReturnMethodInfo
+    ResolvePadMethod "getName" o = ObjectGetNameMethodInfo
+    ResolvePadMethod "getOffset" o = PadGetOffsetMethodInfo
+    ResolvePadMethod "getPadTemplate" o = PadGetPadTemplateMethodInfo
+    ResolvePadMethod "getPadTemplateCaps" o = PadGetPadTemplateCapsMethodInfo
+    ResolvePadMethod "getParent" o = ObjectGetParentMethodInfo
+    ResolvePadMethod "getParentElement" o = PadGetParentElementMethodInfo
+    ResolvePadMethod "getPathString" o = ObjectGetPathStringMethodInfo
+    ResolvePadMethod "getPeer" o = PadGetPeerMethodInfo
+    ResolvePadMethod "getProperty" o = GObject.ObjectGetPropertyMethodInfo
+    ResolvePadMethod "getQdata" o = GObject.ObjectGetQdataMethodInfo
+    ResolvePadMethod "getRange" o = PadGetRangeMethodInfo
+    ResolvePadMethod "getStickyEvent" o = PadGetStickyEventMethodInfo
+    ResolvePadMethod "getStreamId" o = PadGetStreamIdMethodInfo
+    ResolvePadMethod "getValue" o = ObjectGetValueMethodInfo
+    ResolvePadMethod "getValueArray" o = ObjectGetValueArrayMethodInfo
+    ResolvePadMethod "setActivateFunctionFull" o = PadSetActivateFunctionFullMethodInfo
+    ResolvePadMethod "setActivatemodeFunctionFull" o = PadSetActivatemodeFunctionFullMethodInfo
+    ResolvePadMethod "setActive" o = PadSetActiveMethodInfo
+    ResolvePadMethod "setChainFunctionFull" o = PadSetChainFunctionFullMethodInfo
+    ResolvePadMethod "setChainListFunctionFull" o = PadSetChainListFunctionFullMethodInfo
+    ResolvePadMethod "setControlBindingDisabled" o = ObjectSetControlBindingDisabledMethodInfo
+    ResolvePadMethod "setControlBindingsDisabled" o = ObjectSetControlBindingsDisabledMethodInfo
+    ResolvePadMethod "setControlRate" o = ObjectSetControlRateMethodInfo
+    ResolvePadMethod "setData" o = GObject.ObjectSetDataMethodInfo
+    ResolvePadMethod "setElementPrivate" o = PadSetElementPrivateMethodInfo
+    ResolvePadMethod "setEventFunctionFull" o = PadSetEventFunctionFullMethodInfo
+    ResolvePadMethod "setGetrangeFunctionFull" o = PadSetGetrangeFunctionFullMethodInfo
+    ResolvePadMethod "setIterateInternalLinksFunctionFull" o = PadSetIterateInternalLinksFunctionFullMethodInfo
+    ResolvePadMethod "setLinkFunctionFull" o = PadSetLinkFunctionFullMethodInfo
+    ResolvePadMethod "setName" o = ObjectSetNameMethodInfo
+    ResolvePadMethod "setOffset" o = PadSetOffsetMethodInfo
+    ResolvePadMethod "setParent" o = ObjectSetParentMethodInfo
+    ResolvePadMethod "setProperty" o = GObject.ObjectSetPropertyMethodInfo
+    ResolvePadMethod "setQueryFunctionFull" o = PadSetQueryFunctionFullMethodInfo
+    ResolvePadMethod "setUnlinkFunctionFull" o = PadSetUnlinkFunctionFullMethodInfo
+    ResolvePadMethod l o = MethodResolutionFailed l o
+
+instance (info ~ ResolvePadMethod t Pad, MethodInfo info Pad p) => IsLabelProxy t (Pad -> p) where
+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)
+
+#if MIN_VERSION_base(4,9,0)
+instance (info ~ ResolvePadMethod t Pad, MethodInfo info Pad p) => IsLabel t (Pad -> p) where
+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)
+#endif
+
+-- signal Pad::linked
+type PadLinkedCallback =
+    Pad ->
+    IO ()
+
+noPadLinkedCallback :: Maybe PadLinkedCallback
+noPadLinkedCallback = Nothing
+
+type PadLinkedCallbackC =
+    Ptr () ->                               -- object
+    Ptr Pad ->
+    Ptr () ->                               -- user_data
+    IO ()
+
+foreign import ccall "wrapper"
+    mkPadLinkedCallback :: PadLinkedCallbackC -> IO (FunPtr PadLinkedCallbackC)
+
+padLinkedClosure :: PadLinkedCallback -> IO Closure
+padLinkedClosure cb = newCClosure =<< mkPadLinkedCallback wrapped
+    where wrapped = padLinkedCallbackWrapper cb
+
+padLinkedCallbackWrapper ::
+    PadLinkedCallback ->
+    Ptr () ->
+    Ptr Pad ->
+    Ptr () ->
+    IO ()
+padLinkedCallbackWrapper _cb _ peer _ = do
+    peer' <- (newObject Pad) peer
+    _cb  peer'
+
+onPadLinked :: (GObject a, MonadIO m) => a -> PadLinkedCallback -> m SignalHandlerId
+onPadLinked obj cb = liftIO $ connectPadLinked obj cb SignalConnectBefore
+afterPadLinked :: (GObject a, MonadIO m) => a -> PadLinkedCallback -> m SignalHandlerId
+afterPadLinked obj cb = connectPadLinked obj cb SignalConnectAfter
+
+connectPadLinked :: (GObject a, MonadIO m) =>
+                    a -> PadLinkedCallback -> SignalConnectMode -> m SignalHandlerId
+connectPadLinked obj cb after = liftIO $ do
+    cb' <- mkPadLinkedCallback (padLinkedCallbackWrapper cb)
+    connectSignalFunPtr obj "linked" cb' after
+
+-- signal Pad::unlinked
+type PadUnlinkedCallback =
+    Pad ->
+    IO ()
+
+noPadUnlinkedCallback :: Maybe PadUnlinkedCallback
+noPadUnlinkedCallback = Nothing
+
+type PadUnlinkedCallbackC =
+    Ptr () ->                               -- object
+    Ptr Pad ->
+    Ptr () ->                               -- user_data
+    IO ()
+
+foreign import ccall "wrapper"
+    mkPadUnlinkedCallback :: PadUnlinkedCallbackC -> IO (FunPtr PadUnlinkedCallbackC)
+
+padUnlinkedClosure :: PadUnlinkedCallback -> IO Closure
+padUnlinkedClosure cb = newCClosure =<< mkPadUnlinkedCallback wrapped
+    where wrapped = padUnlinkedCallbackWrapper cb
+
+padUnlinkedCallbackWrapper ::
+    PadUnlinkedCallback ->
+    Ptr () ->
+    Ptr Pad ->
+    Ptr () ->
+    IO ()
+padUnlinkedCallbackWrapper _cb _ peer _ = do
+    peer' <- (newObject Pad) peer
+    _cb  peer'
+
+onPadUnlinked :: (GObject a, MonadIO m) => a -> PadUnlinkedCallback -> m SignalHandlerId
+onPadUnlinked obj cb = liftIO $ connectPadUnlinked obj cb SignalConnectBefore
+afterPadUnlinked :: (GObject a, MonadIO m) => a -> PadUnlinkedCallback -> m SignalHandlerId
+afterPadUnlinked obj cb = connectPadUnlinked obj cb SignalConnectAfter
+
+connectPadUnlinked :: (GObject a, MonadIO m) =>
+                      a -> PadUnlinkedCallback -> SignalConnectMode -> m SignalHandlerId
+connectPadUnlinked obj cb after = liftIO $ do
+    cb' <- mkPadUnlinkedCallback (padUnlinkedCallbackWrapper cb)
+    connectSignalFunPtr obj "unlinked" cb' after
+
+-- VVV Prop "caps"
+   -- Type: TInterface "Gst" "Caps"
+   -- Flags: [PropertyReadable]
+
+getPadCaps :: (MonadIO m, PadK o) => o -> m Caps
+getPadCaps obj = liftIO $ getObjectPropertyBoxed obj "caps" Caps
+
+data PadCapsPropertyInfo
+instance AttrInfo PadCapsPropertyInfo where
+    type AttrAllowedOps PadCapsPropertyInfo = '[ 'AttrGet]
+    type AttrSetTypeConstraint PadCapsPropertyInfo = (~) ()
+    type AttrBaseTypeConstraint PadCapsPropertyInfo = PadK
+    type AttrGetType PadCapsPropertyInfo = Caps
+    type AttrLabel PadCapsPropertyInfo = "caps"
+    attrGet _ = getPadCaps
+    attrSet _ = undefined
+    attrConstruct _ = undefined
+
+-- VVV Prop "direction"
+   -- Type: TInterface "Gst" "PadDirection"
+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
+
+getPadDirection :: (MonadIO m, PadK o) => o -> m PadDirection
+getPadDirection obj = liftIO $ getObjectPropertyEnum obj "direction"
+
+constructPadDirection :: PadDirection -> IO ([Char], GValue)
+constructPadDirection val = constructObjectPropertyEnum "direction" val
+
+data PadDirectionPropertyInfo
+instance AttrInfo PadDirectionPropertyInfo where
+    type AttrAllowedOps PadDirectionPropertyInfo = '[ 'AttrConstruct, 'AttrGet]
+    type AttrSetTypeConstraint PadDirectionPropertyInfo = (~) PadDirection
+    type AttrBaseTypeConstraint PadDirectionPropertyInfo = PadK
+    type AttrGetType PadDirectionPropertyInfo = PadDirection
+    type AttrLabel PadDirectionPropertyInfo = "direction"
+    attrGet _ = getPadDirection
+    attrSet _ = undefined
+    attrConstruct _ = constructPadDirection
+
+-- VVV Prop "offset"
+   -- Type: TBasicType TInt64
+   -- Flags: [PropertyReadable,PropertyWritable]
+
+getPadOffset :: (MonadIO m, PadK o) => o -> m Int64
+getPadOffset obj = liftIO $ getObjectPropertyInt64 obj "offset"
+
+setPadOffset :: (MonadIO m, PadK o) => o -> Int64 -> m ()
+setPadOffset obj val = liftIO $ setObjectPropertyInt64 obj "offset" val
+
+constructPadOffset :: Int64 -> IO ([Char], GValue)
+constructPadOffset val = constructObjectPropertyInt64 "offset" val
+
+data PadOffsetPropertyInfo
+instance AttrInfo PadOffsetPropertyInfo where
+    type AttrAllowedOps PadOffsetPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
+    type AttrSetTypeConstraint PadOffsetPropertyInfo = (~) Int64
+    type AttrBaseTypeConstraint PadOffsetPropertyInfo = PadK
+    type AttrGetType PadOffsetPropertyInfo = Int64
+    type AttrLabel PadOffsetPropertyInfo = "offset"
+    attrGet _ = getPadOffset
+    attrSet _ = setPadOffset
+    attrConstruct _ = constructPadOffset
+
+-- VVV Prop "template"
+   -- Type: TInterface "Gst" "PadTemplate"
+   -- Flags: [PropertyReadable,PropertyWritable]
+
+getPadTemplate :: (MonadIO m, PadK o) => o -> m PadTemplate
+getPadTemplate obj = liftIO $ getObjectPropertyObject obj "template" PadTemplate
+
+setPadTemplate :: (MonadIO m, PadK o, PadTemplateK a) => o -> a -> m ()
+setPadTemplate obj val = liftIO $ setObjectPropertyObject obj "template" val
+
+constructPadTemplate :: (PadTemplateK a) => a -> IO ([Char], GValue)
+constructPadTemplate val = constructObjectPropertyObject "template" val
+
+data PadTemplatePropertyInfo
+instance AttrInfo PadTemplatePropertyInfo where
+    type AttrAllowedOps PadTemplatePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
+    type AttrSetTypeConstraint PadTemplatePropertyInfo = PadTemplateK
+    type AttrBaseTypeConstraint PadTemplatePropertyInfo = PadK
+    type AttrGetType PadTemplatePropertyInfo = PadTemplate
+    type AttrLabel PadTemplatePropertyInfo = "template"
+    attrGet _ = getPadTemplate
+    attrSet _ = setPadTemplate
+    attrConstruct _ = constructPadTemplate
+
+type instance AttributeList Pad = PadAttributeList
+type PadAttributeList = ('[ '("caps", PadCapsPropertyInfo), '("direction", PadDirectionPropertyInfo), '("name", ObjectNamePropertyInfo), '("offset", PadOffsetPropertyInfo), '("parent", ObjectParentPropertyInfo), '("template", PadTemplatePropertyInfo)] :: [(Symbol, *)])
+
+data PadLinkedSignalInfo
+instance SignalInfo PadLinkedSignalInfo where
+    type HaskellCallbackType PadLinkedSignalInfo = PadLinkedCallback
+    connectSignal _ = connectPadLinked
+
+data PadUnlinkedSignalInfo
+instance SignalInfo PadUnlinkedSignalInfo where
+    type HaskellCallbackType PadUnlinkedSignalInfo = PadUnlinkedCallback
+    connectSignal _ = connectPadUnlinked
+
+type instance SignalList Pad = PadSignalList
+type PadSignalList = ('[ '("deepNotify", ObjectDeepNotifySignalInfo), '("linked", PadLinkedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("unlinked", PadUnlinkedSignalInfo)] :: [(Symbol, *)])
+
+-- method Pad::new
+-- method type : Constructor
+-- Args : [Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "direction", argType = TInterface "Gst" "PadDirection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Pad"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_new" gst_pad_new :: 
+    CString ->                              -- name : TBasicType TUTF8
+    CUInt ->                                -- direction : TInterface "Gst" "PadDirection"
+    IO (Ptr Pad)
+
+
+padNew ::
+    (MonadIO m) =>
+    Maybe (T.Text)                          -- name
+    -> PadDirection                         -- direction
+    -> m Pad                                -- result
+padNew name direction = liftIO $ do
+    maybeName <- case name of
+        Nothing -> return nullPtr
+        Just jName -> do
+            jName' <- textToCString jName
+            return jName'
+    let direction' = (fromIntegral . fromEnum) direction
+    result <- gst_pad_new maybeName direction'
+    checkUnexpectedReturnNULL "gst_pad_new" result
+    result' <- (newObject Pad) result
+    freeMem maybeName
+    return result'
+
+-- method Pad::new_from_static_template
+-- method type : Constructor
+-- Args : [Arg {argCName = "templ", argType = TInterface "Gst" "StaticPadTemplate", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Pad"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_new_from_static_template" gst_pad_new_from_static_template :: 
+    Ptr StaticPadTemplate ->                -- templ : TInterface "Gst" "StaticPadTemplate"
+    CString ->                              -- name : TBasicType TUTF8
+    IO (Ptr Pad)
+
+
+padNewFromStaticTemplate ::
+    (MonadIO m) =>
+    StaticPadTemplate                       -- templ
+    -> T.Text                               -- name
+    -> m Pad                                -- result
+padNewFromStaticTemplate templ name = liftIO $ do
+    let templ' = unsafeManagedPtrGetPtr templ
+    name' <- textToCString name
+    result <- gst_pad_new_from_static_template templ' name'
+    checkUnexpectedReturnNULL "gst_pad_new_from_static_template" result
+    result' <- (newObject Pad) result
+    touchManagedPtr templ
+    freeMem name'
+    return result'
+
+-- method Pad::new_from_template
+-- method type : Constructor
+-- Args : [Arg {argCName = "templ", argType = TInterface "Gst" "PadTemplate", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Pad"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_new_from_template" gst_pad_new_from_template :: 
+    Ptr PadTemplate ->                      -- templ : TInterface "Gst" "PadTemplate"
+    CString ->                              -- name : TBasicType TUTF8
+    IO (Ptr Pad)
+
+
+padNewFromTemplate ::
+    (MonadIO m, PadTemplateK a) =>
+    a                                       -- templ
+    -> Maybe (T.Text)                       -- name
+    -> m Pad                                -- result
+padNewFromTemplate templ name = liftIO $ do
+    let templ' = unsafeManagedPtrCastPtr templ
+    maybeName <- case name of
+        Nothing -> return nullPtr
+        Just jName -> do
+            jName' <- textToCString jName
+            return jName'
+    result <- gst_pad_new_from_template templ' maybeName
+    checkUnexpectedReturnNULL "gst_pad_new_from_template" result
+    result' <- (newObject Pad) result
+    touchManagedPtr templ
+    freeMem maybeName
+    return result'
+
+-- method Pad::activate_mode
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mode", argType = TInterface "Gst" "PadMode", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "active", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_activate_mode" gst_pad_activate_mode :: 
+    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"
+    CUInt ->                                -- mode : TInterface "Gst" "PadMode"
+    CInt ->                                 -- active : TBasicType TBoolean
+    IO CInt
+
+
+padActivateMode ::
+    (MonadIO m, PadK a) =>
+    a                                       -- _obj
+    -> PadMode                              -- mode
+    -> Bool                                 -- active
+    -> m Bool                               -- result
+padActivateMode _obj mode active = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let mode' = (fromIntegral . fromEnum) mode
+    let active' = (fromIntegral . fromEnum) active
+    result <- gst_pad_activate_mode _obj' mode' active'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data PadActivateModeMethodInfo
+instance (signature ~ (PadMode -> Bool -> m Bool), MonadIO m, PadK a) => MethodInfo PadActivateModeMethodInfo a signature where
+    overloadedMethod _ = padActivateMode
+
+-- method Pad::add_probe
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mask", argType = TInterface "Gst" "PadProbeType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface "Gst" "PadProbeCallback", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeNotified, argClosure = 3, argDestroy = 4, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "destroy_data", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUInt64
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_add_probe" gst_pad_add_probe :: 
+    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"
+    CUInt ->                                -- mask : TInterface "Gst" "PadProbeType"
+    FunPtr PadProbeCallbackC ->             -- callback : TInterface "Gst" "PadProbeCallback"
+    Ptr () ->                               -- user_data : TBasicType TVoid
+    FunPtr GLib.DestroyNotifyC ->           -- destroy_data : TInterface "GLib" "DestroyNotify"
+    IO Word64
+
+
+padAddProbe ::
+    (MonadIO m, PadK a) =>
+    a                                       -- _obj
+    -> [PadProbeType]                       -- mask
+    -> PadProbeCallback                     -- callback
+    -> m Word64                             -- result
+padAddProbe _obj mask callback = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let mask' = gflagsToWord mask
+    callback' <- mkPadProbeCallback (padProbeCallbackWrapper Nothing callback)
+    let userData = castFunPtrToPtr callback'
+    let destroyData = safeFreeFunPtrPtr
+    result <- gst_pad_add_probe _obj' mask' callback' userData destroyData
+    touchManagedPtr _obj
+    return result
+
+data PadAddProbeMethodInfo
+instance (signature ~ ([PadProbeType] -> PadProbeCallback -> m Word64), MonadIO m, PadK a) => MethodInfo PadAddProbeMethodInfo a signature where
+    overloadedMethod _ = padAddProbe
+
+-- method Pad::can_link
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "sinkpad", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_can_link" gst_pad_can_link :: 
+    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"
+    Ptr Pad ->                              -- sinkpad : TInterface "Gst" "Pad"
+    IO CInt
+
+
+padCanLink ::
+    (MonadIO m, PadK a, PadK b) =>
+    a                                       -- _obj
+    -> b                                    -- sinkpad
+    -> m Bool                               -- result
+padCanLink _obj sinkpad = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let sinkpad' = unsafeManagedPtrCastPtr sinkpad
+    result <- gst_pad_can_link _obj' sinkpad'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    touchManagedPtr sinkpad
+    return result'
+
+data PadCanLinkMethodInfo
+instance (signature ~ (b -> m Bool), MonadIO m, PadK a, PadK b) => MethodInfo PadCanLinkMethodInfo a signature where
+    overloadedMethod _ = padCanLink
+
+-- method Pad::chain
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "buffer", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "FlowReturn"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_chain" gst_pad_chain :: 
+    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"
+    Ptr Buffer ->                           -- buffer : TInterface "Gst" "Buffer"
+    IO CUInt
+
+
+padChain ::
+    (MonadIO m, PadK a) =>
+    a                                       -- _obj
+    -> Buffer                               -- buffer
+    -> m FlowReturn                         -- result
+padChain _obj buffer = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    buffer' <- copyBoxed buffer
+    result <- gst_pad_chain _obj' buffer'
+    let result' = (toEnum . fromIntegral) result
+    touchManagedPtr _obj
+    touchManagedPtr buffer
+    return result'
+
+data PadChainMethodInfo
+instance (signature ~ (Buffer -> m FlowReturn), MonadIO m, PadK a) => MethodInfo PadChainMethodInfo a signature where
+    overloadedMethod _ = padChain
+
+-- method Pad::chain_list
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "list", argType = TInterface "Gst" "BufferList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "FlowReturn"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_chain_list" gst_pad_chain_list :: 
+    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"
+    Ptr BufferList ->                       -- list : TInterface "Gst" "BufferList"
+    IO CUInt
+
+
+padChainList ::
+    (MonadIO m, PadK a) =>
+    a                                       -- _obj
+    -> BufferList                           -- list
+    -> m FlowReturn                         -- result
+padChainList _obj list = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    list' <- copyBoxed list
+    result <- gst_pad_chain_list _obj' list'
+    let result' = (toEnum . fromIntegral) result
+    touchManagedPtr _obj
+    touchManagedPtr list
+    return result'
+
+data PadChainListMethodInfo
+instance (signature ~ (BufferList -> m FlowReturn), MonadIO m, PadK a) => MethodInfo PadChainListMethodInfo a signature where
+    overloadedMethod _ = padChainList
+
+-- method Pad::check_reconfigure
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_check_reconfigure" gst_pad_check_reconfigure :: 
+    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"
+    IO CInt
+
+
+padCheckReconfigure ::
+    (MonadIO m, PadK a) =>
+    a                                       -- _obj
+    -> m Bool                               -- result
+padCheckReconfigure _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_pad_check_reconfigure _obj'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data PadCheckReconfigureMethodInfo
+instance (signature ~ (m Bool), MonadIO m, PadK a) => MethodInfo PadCheckReconfigureMethodInfo a signature where
+    overloadedMethod _ = padCheckReconfigure
+
+-- method Pad::create_stream_id
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "parent", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stream_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUTF8
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_create_stream_id" gst_pad_create_stream_id :: 
+    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"
+    Ptr Element ->                          -- parent : TInterface "Gst" "Element"
+    CString ->                              -- stream_id : TBasicType TUTF8
+    IO CString
+
+
+padCreateStreamId ::
+    (MonadIO m, PadK a, ElementK b) =>
+    a                                       -- _obj
+    -> b                                    -- parent
+    -> Maybe (T.Text)                       -- streamId
+    -> m T.Text                             -- result
+padCreateStreamId _obj parent streamId = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let parent' = unsafeManagedPtrCastPtr parent
+    maybeStreamId <- case streamId of
+        Nothing -> return nullPtr
+        Just jStreamId -> do
+            jStreamId' <- textToCString jStreamId
+            return jStreamId'
+    result <- gst_pad_create_stream_id _obj' parent' maybeStreamId
+    checkUnexpectedReturnNULL "gst_pad_create_stream_id" result
+    result' <- cstringToText result
+    freeMem result
+    touchManagedPtr _obj
+    touchManagedPtr parent
+    freeMem maybeStreamId
+    return result'
+
+data PadCreateStreamIdMethodInfo
+instance (signature ~ (b -> Maybe (T.Text) -> m T.Text), MonadIO m, PadK a, ElementK b) => MethodInfo PadCreateStreamIdMethodInfo a signature where
+    overloadedMethod _ = padCreateStreamId
+
+-- method Pad::event_default
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "parent", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "event", argType = TInterface "Gst" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_event_default" gst_pad_event_default :: 
+    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"
+    Ptr Object ->                           -- parent : TInterface "Gst" "Object"
+    Ptr Event ->                            -- event : TInterface "Gst" "Event"
+    IO CInt
+
+
+padEventDefault ::
+    (MonadIO m, PadK a, ObjectK b) =>
+    a                                       -- _obj
+    -> Maybe (b)                            -- parent
+    -> Event                                -- event
+    -> m Bool                               -- result
+padEventDefault _obj parent event = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    maybeParent <- case parent of
+        Nothing -> return nullPtr
+        Just jParent -> do
+            let jParent' = unsafeManagedPtrCastPtr jParent
+            return jParent'
+    event' <- copyBoxed event
+    result <- gst_pad_event_default _obj' maybeParent event'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    whenJust parent touchManagedPtr
+    touchManagedPtr event
+    return result'
+
+data PadEventDefaultMethodInfo
+instance (signature ~ (Maybe (b) -> Event -> m Bool), MonadIO m, PadK a, ObjectK b) => MethodInfo PadEventDefaultMethodInfo a signature where
+    overloadedMethod _ = padEventDefault
+
+-- method Pad::forward
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "forward", argType = TInterface "Gst" "PadForwardFunction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_forward" gst_pad_forward :: 
+    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"
+    FunPtr PadForwardFunctionC ->           -- forward : TInterface "Gst" "PadForwardFunction"
+    Ptr () ->                               -- user_data : TBasicType TVoid
+    IO CInt
+
+
+padForward ::
+    (MonadIO m, PadK a) =>
+    a                                       -- _obj
+    -> PadForwardFunction                   -- forward
+    -> m Bool                               -- result
+padForward _obj forward = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    forward' <- mkPadForwardFunction (padForwardFunctionWrapper Nothing forward)
+    let userData = nullPtr
+    result <- gst_pad_forward _obj' forward' userData
+    let result' = (/= 0) result
+    safeFreeFunPtr $ castFunPtrToPtr forward'
+    touchManagedPtr _obj
+    return result'
+
+data PadForwardMethodInfo
+instance (signature ~ (PadForwardFunction -> m Bool), MonadIO m, PadK a) => MethodInfo PadForwardMethodInfo a signature where
+    overloadedMethod _ = padForward
+
+-- method Pad::get_allowed_caps
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Caps"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_get_allowed_caps" gst_pad_get_allowed_caps :: 
+    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"
+    IO (Ptr Caps)
+
+
+padGetAllowedCaps ::
+    (MonadIO m, PadK a) =>
+    a                                       -- _obj
+    -> m Caps                               -- result
+padGetAllowedCaps _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_pad_get_allowed_caps _obj'
+    checkUnexpectedReturnNULL "gst_pad_get_allowed_caps" result
+    result' <- (wrapBoxed Caps) result
+    touchManagedPtr _obj
+    return result'
+
+data PadGetAllowedCapsMethodInfo
+instance (signature ~ (m Caps), MonadIO m, PadK a) => MethodInfo PadGetAllowedCapsMethodInfo a signature where
+    overloadedMethod _ = padGetAllowedCaps
+
+-- method Pad::get_current_caps
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Caps"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_get_current_caps" gst_pad_get_current_caps :: 
+    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"
+    IO (Ptr Caps)
+
+
+padGetCurrentCaps ::
+    (MonadIO m, PadK a) =>
+    a                                       -- _obj
+    -> m Caps                               -- result
+padGetCurrentCaps _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_pad_get_current_caps _obj'
+    checkUnexpectedReturnNULL "gst_pad_get_current_caps" result
+    result' <- (wrapBoxed Caps) result
+    touchManagedPtr _obj
+    return result'
+
+data PadGetCurrentCapsMethodInfo
+instance (signature ~ (m Caps), MonadIO m, PadK a) => MethodInfo PadGetCurrentCapsMethodInfo a signature where
+    overloadedMethod _ = padGetCurrentCaps
+
+-- method Pad::get_direction
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "PadDirection"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_get_direction" gst_pad_get_direction :: 
+    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"
+    IO CUInt
+
+
+padGetDirection ::
+    (MonadIO m, PadK a) =>
+    a                                       -- _obj
+    -> m PadDirection                       -- result
+padGetDirection _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_pad_get_direction _obj'
+    let result' = (toEnum . fromIntegral) result
+    touchManagedPtr _obj
+    return result'
+
+data PadGetDirectionMethodInfo
+instance (signature ~ (m PadDirection), MonadIO m, PadK a) => MethodInfo PadGetDirectionMethodInfo a signature where
+    overloadedMethod _ = padGetDirection
+
+-- method Pad::get_element_private
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_get_element_private" gst_pad_get_element_private :: 
+    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"
+    IO ()
+
+
+padGetElementPrivate ::
+    (MonadIO m, PadK a) =>
+    a                                       -- _obj
+    -> m ()                                 -- result
+padGetElementPrivate _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    gst_pad_get_element_private _obj'
+    touchManagedPtr _obj
+    return ()
+
+data PadGetElementPrivateMethodInfo
+instance (signature ~ (m ()), MonadIO m, PadK a) => MethodInfo PadGetElementPrivateMethodInfo a signature where
+    overloadedMethod _ = padGetElementPrivate
+
+-- method Pad::get_last_flow_return
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "FlowReturn"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_get_last_flow_return" gst_pad_get_last_flow_return :: 
+    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"
+    IO CUInt
+
+
+padGetLastFlowReturn ::
+    (MonadIO m, PadK a) =>
+    a                                       -- _obj
+    -> m FlowReturn                         -- result
+padGetLastFlowReturn _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_pad_get_last_flow_return _obj'
+    let result' = (toEnum . fromIntegral) result
+    touchManagedPtr _obj
+    return result'
+
+data PadGetLastFlowReturnMethodInfo
+instance (signature ~ (m FlowReturn), MonadIO m, PadK a) => MethodInfo PadGetLastFlowReturnMethodInfo a signature where
+    overloadedMethod _ = padGetLastFlowReturn
+
+-- method Pad::get_offset
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TInt64
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_get_offset" gst_pad_get_offset :: 
+    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"
+    IO Int64
+
+
+padGetOffset ::
+    (MonadIO m, PadK a) =>
+    a                                       -- _obj
+    -> m Int64                              -- result
+padGetOffset _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_pad_get_offset _obj'
+    touchManagedPtr _obj
+    return result
+
+data PadGetOffsetMethodInfo
+instance (signature ~ (m Int64), MonadIO m, PadK a) => MethodInfo PadGetOffsetMethodInfo a signature where
+    overloadedMethod _ = padGetOffset
+
+-- method Pad::get_pad_template
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "PadTemplate"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_get_pad_template" gst_pad_get_pad_template :: 
+    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"
+    IO (Ptr PadTemplate)
+
+
+padGetPadTemplate ::
+    (MonadIO m, PadK a) =>
+    a                                       -- _obj
+    -> m PadTemplate                        -- result
+padGetPadTemplate _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_pad_get_pad_template _obj'
+    checkUnexpectedReturnNULL "gst_pad_get_pad_template" result
+    result' <- (wrapObject PadTemplate) result
+    touchManagedPtr _obj
+    return result'
+
+data PadGetPadTemplateMethodInfo
+instance (signature ~ (m PadTemplate), MonadIO m, PadK a) => MethodInfo PadGetPadTemplateMethodInfo a signature where
+    overloadedMethod _ = padGetPadTemplate
+
+-- method Pad::get_pad_template_caps
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Caps"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_get_pad_template_caps" gst_pad_get_pad_template_caps :: 
+    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"
+    IO (Ptr Caps)
+
+
+padGetPadTemplateCaps ::
+    (MonadIO m, PadK a) =>
+    a                                       -- _obj
+    -> m Caps                               -- result
+padGetPadTemplateCaps _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_pad_get_pad_template_caps _obj'
+    checkUnexpectedReturnNULL "gst_pad_get_pad_template_caps" result
+    result' <- (wrapBoxed Caps) result
+    touchManagedPtr _obj
+    return result'
+
+data PadGetPadTemplateCapsMethodInfo
+instance (signature ~ (m Caps), MonadIO m, PadK a) => MethodInfo PadGetPadTemplateCapsMethodInfo a signature where
+    overloadedMethod _ = padGetPadTemplateCaps
+
+-- method Pad::get_parent_element
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Element"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_get_parent_element" gst_pad_get_parent_element :: 
+    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"
+    IO (Ptr Element)
+
+
+padGetParentElement ::
+    (MonadIO m, PadK a) =>
+    a                                       -- _obj
+    -> m Element                            -- result
+padGetParentElement _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_pad_get_parent_element _obj'
+    checkUnexpectedReturnNULL "gst_pad_get_parent_element" result
+    result' <- (wrapObject Element) result
+    touchManagedPtr _obj
+    return result'
+
+data PadGetParentElementMethodInfo
+instance (signature ~ (m Element), MonadIO m, PadK a) => MethodInfo PadGetParentElementMethodInfo a signature where
+    overloadedMethod _ = padGetParentElement
+
+-- method Pad::get_peer
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Pad"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_get_peer" gst_pad_get_peer :: 
+    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"
+    IO (Ptr Pad)
+
+
+padGetPeer ::
+    (MonadIO m, PadK a) =>
+    a                                       -- _obj
+    -> m Pad                                -- result
+padGetPeer _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_pad_get_peer _obj'
+    checkUnexpectedReturnNULL "gst_pad_get_peer" result
+    result' <- (wrapObject Pad) result
+    touchManagedPtr _obj
+    return result'
+
+data PadGetPeerMethodInfo
+instance (signature ~ (m Pad), MonadIO m, PadK a) => MethodInfo PadGetPeerMethodInfo a signature where
+    overloadedMethod _ = padGetPeer
+
+-- method Pad::get_range
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "buffer", argType = TInterface "Gst" "Buffer", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "FlowReturn"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_get_range" gst_pad_get_range :: 
+    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"
+    Word64 ->                               -- offset : TBasicType TUInt64
+    Word32 ->                               -- size : TBasicType TUInt32
+    Ptr Buffer ->                           -- buffer : TInterface "Gst" "Buffer"
+    IO CUInt
+
+
+padGetRange ::
+    (MonadIO m, PadK a) =>
+    a                                       -- _obj
+    -> Word64                               -- offset
+    -> Word32                               -- size
+    -> m (FlowReturn,Buffer)                -- result
+padGetRange _obj offset size = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    buffer <- callocBoxedBytes 112 :: IO (Ptr Buffer)
+    result <- gst_pad_get_range _obj' offset size buffer
+    let result' = (toEnum . fromIntegral) result
+    buffer' <- (wrapBoxed Buffer) buffer
+    touchManagedPtr _obj
+    return (result', buffer')
+
+data PadGetRangeMethodInfo
+instance (signature ~ (Word64 -> Word32 -> m (FlowReturn,Buffer)), MonadIO m, PadK a) => MethodInfo PadGetRangeMethodInfo a signature where
+    overloadedMethod _ = padGetRange
+
+-- method Pad::get_sticky_event
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "event_type", argType = TInterface "Gst" "EventType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "idx", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Event"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_get_sticky_event" gst_pad_get_sticky_event :: 
+    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"
+    CUInt ->                                -- event_type : TInterface "Gst" "EventType"
+    Word32 ->                               -- idx : TBasicType TUInt32
+    IO (Ptr Event)
+
+
+padGetStickyEvent ::
+    (MonadIO m, PadK a) =>
+    a                                       -- _obj
+    -> EventType                            -- eventType
+    -> Word32                               -- idx
+    -> m Event                              -- result
+padGetStickyEvent _obj eventType idx = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let eventType' = (fromIntegral . fromEnum) eventType
+    result <- gst_pad_get_sticky_event _obj' eventType' idx
+    checkUnexpectedReturnNULL "gst_pad_get_sticky_event" result
+    result' <- (wrapBoxed Event) result
+    touchManagedPtr _obj
+    return result'
+
+data PadGetStickyEventMethodInfo
+instance (signature ~ (EventType -> Word32 -> m Event), MonadIO m, PadK a) => MethodInfo PadGetStickyEventMethodInfo a signature where
+    overloadedMethod _ = padGetStickyEvent
+
+-- method Pad::get_stream_id
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUTF8
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_get_stream_id" gst_pad_get_stream_id :: 
+    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"
+    IO CString
+
+
+padGetStreamId ::
+    (MonadIO m, PadK a) =>
+    a                                       -- _obj
+    -> m T.Text                             -- result
+padGetStreamId _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_pad_get_stream_id _obj'
+    checkUnexpectedReturnNULL "gst_pad_get_stream_id" result
+    result' <- cstringToText result
+    freeMem result
+    touchManagedPtr _obj
+    return result'
+
+data PadGetStreamIdMethodInfo
+instance (signature ~ (m T.Text), MonadIO m, PadK a) => MethodInfo PadGetStreamIdMethodInfo a signature where
+    overloadedMethod _ = padGetStreamId
+
+-- method Pad::has_current_caps
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_has_current_caps" gst_pad_has_current_caps :: 
+    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"
+    IO CInt
+
+
+padHasCurrentCaps ::
+    (MonadIO m, PadK a) =>
+    a                                       -- _obj
+    -> m Bool                               -- result
+padHasCurrentCaps _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_pad_has_current_caps _obj'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data PadHasCurrentCapsMethodInfo
+instance (signature ~ (m Bool), MonadIO m, PadK a) => MethodInfo PadHasCurrentCapsMethodInfo a signature where
+    overloadedMethod _ = padHasCurrentCaps
+
+-- method Pad::is_active
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_is_active" gst_pad_is_active :: 
+    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"
+    IO CInt
+
+
+padIsActive ::
+    (MonadIO m, PadK a) =>
+    a                                       -- _obj
+    -> m Bool                               -- result
+padIsActive _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_pad_is_active _obj'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data PadIsActiveMethodInfo
+instance (signature ~ (m Bool), MonadIO m, PadK a) => MethodInfo PadIsActiveMethodInfo a signature where
+    overloadedMethod _ = padIsActive
+
+-- method Pad::is_blocked
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_is_blocked" gst_pad_is_blocked :: 
+    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"
+    IO CInt
+
+
+padIsBlocked ::
+    (MonadIO m, PadK a) =>
+    a                                       -- _obj
+    -> m Bool                               -- result
+padIsBlocked _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_pad_is_blocked _obj'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data PadIsBlockedMethodInfo
+instance (signature ~ (m Bool), MonadIO m, PadK a) => MethodInfo PadIsBlockedMethodInfo a signature where
+    overloadedMethod _ = padIsBlocked
+
+-- method Pad::is_blocking
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_is_blocking" gst_pad_is_blocking :: 
+    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"
+    IO CInt
+
+
+padIsBlocking ::
+    (MonadIO m, PadK a) =>
+    a                                       -- _obj
+    -> m Bool                               -- result
+padIsBlocking _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_pad_is_blocking _obj'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data PadIsBlockingMethodInfo
+instance (signature ~ (m Bool), MonadIO m, PadK a) => MethodInfo PadIsBlockingMethodInfo a signature where
+    overloadedMethod _ = padIsBlocking
+
+-- method Pad::is_linked
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_is_linked" gst_pad_is_linked :: 
+    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"
+    IO CInt
+
+
+padIsLinked ::
+    (MonadIO m, PadK a) =>
+    a                                       -- _obj
+    -> m Bool                               -- result
+padIsLinked _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_pad_is_linked _obj'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data PadIsLinkedMethodInfo
+instance (signature ~ (m Bool), MonadIO m, PadK a) => MethodInfo PadIsLinkedMethodInfo a signature where
+    overloadedMethod _ = padIsLinked
+
+-- method Pad::iterate_internal_links
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Iterator"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_iterate_internal_links" gst_pad_iterate_internal_links :: 
+    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"
+    IO (Ptr Iterator)
+
+
+padIterateInternalLinks ::
+    (MonadIO m, PadK a) =>
+    a                                       -- _obj
+    -> m Iterator                           -- result
+padIterateInternalLinks _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_pad_iterate_internal_links _obj'
+    checkUnexpectedReturnNULL "gst_pad_iterate_internal_links" result
+    result' <- (wrapBoxed Iterator) result
+    touchManagedPtr _obj
+    return result'
+
+data PadIterateInternalLinksMethodInfo
+instance (signature ~ (m Iterator), MonadIO m, PadK a) => MethodInfo PadIterateInternalLinksMethodInfo a signature where
+    overloadedMethod _ = padIterateInternalLinks
+
+-- method Pad::iterate_internal_links_default
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "parent", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Iterator"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_iterate_internal_links_default" gst_pad_iterate_internal_links_default :: 
+    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"
+    Ptr Object ->                           -- parent : TInterface "Gst" "Object"
+    IO (Ptr Iterator)
+
+
+padIterateInternalLinksDefault ::
+    (MonadIO m, PadK a, ObjectK b) =>
+    a                                       -- _obj
+    -> Maybe (b)                            -- parent
+    -> m Iterator                           -- result
+padIterateInternalLinksDefault _obj parent = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    maybeParent <- case parent of
+        Nothing -> return nullPtr
+        Just jParent -> do
+            let jParent' = unsafeManagedPtrCastPtr jParent
+            return jParent'
+    result <- gst_pad_iterate_internal_links_default _obj' maybeParent
+    checkUnexpectedReturnNULL "gst_pad_iterate_internal_links_default" result
+    result' <- (wrapBoxed Iterator) result
+    touchManagedPtr _obj
+    whenJust parent touchManagedPtr
+    return result'
+
+data PadIterateInternalLinksDefaultMethodInfo
+instance (signature ~ (Maybe (b) -> m Iterator), MonadIO m, PadK a, ObjectK b) => MethodInfo PadIterateInternalLinksDefaultMethodInfo a signature where
+    overloadedMethod _ = padIterateInternalLinksDefault
+
+-- method Pad::link
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "sinkpad", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "PadLinkReturn"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_link" gst_pad_link :: 
+    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"
+    Ptr Pad ->                              -- sinkpad : TInterface "Gst" "Pad"
+    IO CUInt
+
+
+padLink ::
+    (MonadIO m, PadK a, PadK b) =>
+    a                                       -- _obj
+    -> b                                    -- sinkpad
+    -> m PadLinkReturn                      -- result
+padLink _obj sinkpad = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let sinkpad' = unsafeManagedPtrCastPtr sinkpad
+    result <- gst_pad_link _obj' sinkpad'
+    let result' = (toEnum . fromIntegral) result
+    touchManagedPtr _obj
+    touchManagedPtr sinkpad
+    return result'
+
+data PadLinkMethodInfo
+instance (signature ~ (b -> m PadLinkReturn), MonadIO m, PadK a, PadK b) => MethodInfo PadLinkMethodInfo a signature where
+    overloadedMethod _ = padLink
+
+-- method Pad::link_full
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "sinkpad", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface "Gst" "PadLinkCheck", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "PadLinkReturn"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_link_full" gst_pad_link_full :: 
+    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"
+    Ptr Pad ->                              -- sinkpad : TInterface "Gst" "Pad"
+    CUInt ->                                -- flags : TInterface "Gst" "PadLinkCheck"
+    IO CUInt
+
+
+padLinkFull ::
+    (MonadIO m, PadK a, PadK b) =>
+    a                                       -- _obj
+    -> b                                    -- sinkpad
+    -> [PadLinkCheck]                       -- flags
+    -> m PadLinkReturn                      -- result
+padLinkFull _obj sinkpad flags = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let sinkpad' = unsafeManagedPtrCastPtr sinkpad
+    let flags' = gflagsToWord flags
+    result <- gst_pad_link_full _obj' sinkpad' flags'
+    let result' = (toEnum . fromIntegral) result
+    touchManagedPtr _obj
+    touchManagedPtr sinkpad
+    return result'
+
+data PadLinkFullMethodInfo
+instance (signature ~ (b -> [PadLinkCheck] -> m PadLinkReturn), MonadIO m, PadK a, PadK b) => MethodInfo PadLinkFullMethodInfo a signature where
+    overloadedMethod _ = padLinkFull
+
+-- method Pad::mark_reconfigure
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_mark_reconfigure" gst_pad_mark_reconfigure :: 
+    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"
+    IO ()
+
+
+padMarkReconfigure ::
+    (MonadIO m, PadK a) =>
+    a                                       -- _obj
+    -> m ()                                 -- result
+padMarkReconfigure _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    gst_pad_mark_reconfigure _obj'
+    touchManagedPtr _obj
+    return ()
+
+data PadMarkReconfigureMethodInfo
+instance (signature ~ (m ()), MonadIO m, PadK a) => MethodInfo PadMarkReconfigureMethodInfo a signature where
+    overloadedMethod _ = padMarkReconfigure
+
+-- method Pad::needs_reconfigure
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_needs_reconfigure" gst_pad_needs_reconfigure :: 
+    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"
+    IO CInt
+
+
+padNeedsReconfigure ::
+    (MonadIO m, PadK a) =>
+    a                                       -- _obj
+    -> m Bool                               -- result
+padNeedsReconfigure _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_pad_needs_reconfigure _obj'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data PadNeedsReconfigureMethodInfo
+instance (signature ~ (m Bool), MonadIO m, PadK a) => MethodInfo PadNeedsReconfigureMethodInfo a signature where
+    overloadedMethod _ = padNeedsReconfigure
+
+-- method Pad::pause_task
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_pause_task" gst_pad_pause_task :: 
+    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"
+    IO CInt
+
+
+padPauseTask ::
+    (MonadIO m, PadK a) =>
+    a                                       -- _obj
+    -> m Bool                               -- result
+padPauseTask _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_pad_pause_task _obj'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data PadPauseTaskMethodInfo
+instance (signature ~ (m Bool), MonadIO m, PadK a) => MethodInfo PadPauseTaskMethodInfo a signature where
+    overloadedMethod _ = padPauseTask
+
+-- method Pad::peer_query
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "query", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_peer_query" gst_pad_peer_query :: 
+    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"
+    Ptr Query ->                            -- query : TInterface "Gst" "Query"
+    IO CInt
+
+
+padPeerQuery ::
+    (MonadIO m, PadK a) =>
+    a                                       -- _obj
+    -> Query                                -- query
+    -> m Bool                               -- result
+padPeerQuery _obj query = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let query' = unsafeManagedPtrGetPtr query
+    result <- gst_pad_peer_query _obj' query'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    touchManagedPtr query
+    return result'
+
+data PadPeerQueryMethodInfo
+instance (signature ~ (Query -> m Bool), MonadIO m, PadK a) => MethodInfo PadPeerQueryMethodInfo a signature where
+    overloadedMethod _ = padPeerQuery
+
+-- method Pad::peer_query_accept_caps
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_peer_query_accept_caps" gst_pad_peer_query_accept_caps :: 
+    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"
+    Ptr Caps ->                             -- caps : TInterface "Gst" "Caps"
+    IO CInt
+
+
+padPeerQueryAcceptCaps ::
+    (MonadIO m, PadK a) =>
+    a                                       -- _obj
+    -> Caps                                 -- caps
+    -> m Bool                               -- result
+padPeerQueryAcceptCaps _obj caps = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let caps' = unsafeManagedPtrGetPtr caps
+    result <- gst_pad_peer_query_accept_caps _obj' caps'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    touchManagedPtr caps
+    return result'
+
+data PadPeerQueryAcceptCapsMethodInfo
+instance (signature ~ (Caps -> m Bool), MonadIO m, PadK a) => MethodInfo PadPeerQueryAcceptCapsMethodInfo a signature where
+    overloadedMethod _ = padPeerQueryAcceptCaps
+
+-- method Pad::peer_query_caps
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "filter", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Caps"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_peer_query_caps" gst_pad_peer_query_caps :: 
+    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"
+    Ptr Caps ->                             -- filter : TInterface "Gst" "Caps"
+    IO (Ptr Caps)
+
+
+padPeerQueryCaps ::
+    (MonadIO m, PadK a) =>
+    a                                       -- _obj
+    -> Maybe (Caps)                         -- filter
+    -> m Caps                               -- result
+padPeerQueryCaps _obj filter = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    maybeFilter <- case filter of
+        Nothing -> return nullPtr
+        Just jFilter -> do
+            let jFilter' = unsafeManagedPtrGetPtr jFilter
+            return jFilter'
+    result <- gst_pad_peer_query_caps _obj' maybeFilter
+    checkUnexpectedReturnNULL "gst_pad_peer_query_caps" result
+    result' <- (wrapBoxed Caps) result
+    touchManagedPtr _obj
+    whenJust filter touchManagedPtr
+    return result'
+
+data PadPeerQueryCapsMethodInfo
+instance (signature ~ (Maybe (Caps) -> m Caps), MonadIO m, PadK a) => MethodInfo PadPeerQueryCapsMethodInfo a signature where
+    overloadedMethod _ = padPeerQueryCaps
+
+-- method Pad::peer_query_convert
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "src_format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "src_val", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest_format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest_val", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_peer_query_convert" gst_pad_peer_query_convert :: 
+    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"
+    CUInt ->                                -- src_format : TInterface "Gst" "Format"
+    Int64 ->                                -- src_val : TBasicType TInt64
+    CUInt ->                                -- dest_format : TInterface "Gst" "Format"
+    Ptr Int64 ->                            -- dest_val : TBasicType TInt64
+    IO CInt
+
+
+padPeerQueryConvert ::
+    (MonadIO m, PadK a) =>
+    a                                       -- _obj
+    -> Format                               -- srcFormat
+    -> Int64                                -- srcVal
+    -> Format                               -- destFormat
+    -> m (Bool,Int64)                       -- result
+padPeerQueryConvert _obj srcFormat srcVal destFormat = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let srcFormat' = (fromIntegral . fromEnum) srcFormat
+    let destFormat' = (fromIntegral . fromEnum) destFormat
+    destVal <- allocMem :: IO (Ptr Int64)
+    result <- gst_pad_peer_query_convert _obj' srcFormat' srcVal destFormat' destVal
+    let result' = (/= 0) result
+    destVal' <- peek destVal
+    touchManagedPtr _obj
+    freeMem destVal
+    return (result', destVal')
+
+data PadPeerQueryConvertMethodInfo
+instance (signature ~ (Format -> Int64 -> Format -> m (Bool,Int64)), MonadIO m, PadK a) => MethodInfo PadPeerQueryConvertMethodInfo a signature where
+    overloadedMethod _ = padPeerQueryConvert
+
+-- method Pad::peer_query_duration
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "duration", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_peer_query_duration" gst_pad_peer_query_duration :: 
+    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"
+    CUInt ->                                -- format : TInterface "Gst" "Format"
+    Ptr Int64 ->                            -- duration : TBasicType TInt64
+    IO CInt
+
+
+padPeerQueryDuration ::
+    (MonadIO m, PadK a) =>
+    a                                       -- _obj
+    -> Format                               -- format
+    -> m (Bool,Int64)                       -- result
+padPeerQueryDuration _obj format = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let format' = (fromIntegral . fromEnum) format
+    duration <- allocMem :: IO (Ptr Int64)
+    result <- gst_pad_peer_query_duration _obj' format' duration
+    let result' = (/= 0) result
+    duration' <- peek duration
+    touchManagedPtr _obj
+    freeMem duration
+    return (result', duration')
+
+data PadPeerQueryDurationMethodInfo
+instance (signature ~ (Format -> m (Bool,Int64)), MonadIO m, PadK a) => MethodInfo PadPeerQueryDurationMethodInfo a signature where
+    overloadedMethod _ = padPeerQueryDuration
+
+-- method Pad::peer_query_position
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cur", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_peer_query_position" gst_pad_peer_query_position :: 
+    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"
+    CUInt ->                                -- format : TInterface "Gst" "Format"
+    Ptr Int64 ->                            -- cur : TBasicType TInt64
+    IO CInt
+
+
+padPeerQueryPosition ::
+    (MonadIO m, PadK a) =>
+    a                                       -- _obj
+    -> Format                               -- format
+    -> m (Bool,Int64)                       -- result
+padPeerQueryPosition _obj format = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let format' = (fromIntegral . fromEnum) format
+    cur <- allocMem :: IO (Ptr Int64)
+    result <- gst_pad_peer_query_position _obj' format' cur
+    let result' = (/= 0) result
+    cur' <- peek cur
+    touchManagedPtr _obj
+    freeMem cur
+    return (result', cur')
+
+data PadPeerQueryPositionMethodInfo
+instance (signature ~ (Format -> m (Bool,Int64)), MonadIO m, PadK a) => MethodInfo PadPeerQueryPositionMethodInfo a signature where
+    overloadedMethod _ = padPeerQueryPosition
+
+-- method Pad::proxy_query_accept_caps
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "query", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_proxy_query_accept_caps" gst_pad_proxy_query_accept_caps :: 
+    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"
+    Ptr Query ->                            -- query : TInterface "Gst" "Query"
+    IO CInt
+
+
+padProxyQueryAcceptCaps ::
+    (MonadIO m, PadK a) =>
+    a                                       -- _obj
+    -> Query                                -- query
+    -> m Bool                               -- result
+padProxyQueryAcceptCaps _obj query = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let query' = unsafeManagedPtrGetPtr query
+    result <- gst_pad_proxy_query_accept_caps _obj' query'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    touchManagedPtr query
+    return result'
+
+data PadProxyQueryAcceptCapsMethodInfo
+instance (signature ~ (Query -> m Bool), MonadIO m, PadK a) => MethodInfo PadProxyQueryAcceptCapsMethodInfo a signature where
+    overloadedMethod _ = padProxyQueryAcceptCaps
+
+-- method Pad::proxy_query_caps
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "query", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_proxy_query_caps" gst_pad_proxy_query_caps :: 
+    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"
+    Ptr Query ->                            -- query : TInterface "Gst" "Query"
+    IO CInt
+
+
+padProxyQueryCaps ::
+    (MonadIO m, PadK a) =>
+    a                                       -- _obj
+    -> Query                                -- query
+    -> m Bool                               -- result
+padProxyQueryCaps _obj query = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let query' = unsafeManagedPtrGetPtr query
+    result <- gst_pad_proxy_query_caps _obj' query'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    touchManagedPtr query
+    return result'
+
+data PadProxyQueryCapsMethodInfo
+instance (signature ~ (Query -> m Bool), MonadIO m, PadK a) => MethodInfo PadProxyQueryCapsMethodInfo a signature where
+    overloadedMethod _ = padProxyQueryCaps
+
+-- method Pad::pull_range
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "buffer", argType = TInterface "Gst" "Buffer", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "FlowReturn"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_pull_range" gst_pad_pull_range :: 
+    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"
+    Word64 ->                               -- offset : TBasicType TUInt64
+    Word32 ->                               -- size : TBasicType TUInt32
+    Ptr Buffer ->                           -- buffer : TInterface "Gst" "Buffer"
+    IO CUInt
+
+
+padPullRange ::
+    (MonadIO m, PadK a) =>
+    a                                       -- _obj
+    -> Word64                               -- offset
+    -> Word32                               -- size
+    -> m (FlowReturn,Buffer)                -- result
+padPullRange _obj offset size = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    buffer <- callocBoxedBytes 112 :: IO (Ptr Buffer)
+    result <- gst_pad_pull_range _obj' offset size buffer
+    let result' = (toEnum . fromIntegral) result
+    buffer' <- (wrapBoxed Buffer) buffer
+    touchManagedPtr _obj
+    return (result', buffer')
+
+data PadPullRangeMethodInfo
+instance (signature ~ (Word64 -> Word32 -> m (FlowReturn,Buffer)), MonadIO m, PadK a) => MethodInfo PadPullRangeMethodInfo a signature where
+    overloadedMethod _ = padPullRange
+
+-- method Pad::push
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "buffer", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "FlowReturn"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_push" gst_pad_push :: 
+    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"
+    Ptr Buffer ->                           -- buffer : TInterface "Gst" "Buffer"
+    IO CUInt
+
+
+padPush ::
+    (MonadIO m, PadK a) =>
+    a                                       -- _obj
+    -> Buffer                               -- buffer
+    -> m FlowReturn                         -- result
+padPush _obj buffer = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    buffer' <- copyBoxed buffer
+    result <- gst_pad_push _obj' buffer'
+    let result' = (toEnum . fromIntegral) result
+    touchManagedPtr _obj
+    touchManagedPtr buffer
+    return result'
+
+data PadPushMethodInfo
+instance (signature ~ (Buffer -> m FlowReturn), MonadIO m, PadK a) => MethodInfo PadPushMethodInfo a signature where
+    overloadedMethod _ = padPush
+
+-- method Pad::push_event
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "event", argType = TInterface "Gst" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_push_event" gst_pad_push_event :: 
+    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"
+    Ptr Event ->                            -- event : TInterface "Gst" "Event"
+    IO CInt
+
+
+padPushEvent ::
+    (MonadIO m, PadK a) =>
+    a                                       -- _obj
+    -> Event                                -- event
+    -> m Bool                               -- result
+padPushEvent _obj event = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    event' <- copyBoxed event
+    result <- gst_pad_push_event _obj' event'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    touchManagedPtr event
+    return result'
+
+data PadPushEventMethodInfo
+instance (signature ~ (Event -> m Bool), MonadIO m, PadK a) => MethodInfo PadPushEventMethodInfo a signature where
+    overloadedMethod _ = padPushEvent
+
+-- method Pad::push_list
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "list", argType = TInterface "Gst" "BufferList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "FlowReturn"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_push_list" gst_pad_push_list :: 
+    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"
+    Ptr BufferList ->                       -- list : TInterface "Gst" "BufferList"
+    IO CUInt
+
+
+padPushList ::
+    (MonadIO m, PadK a) =>
+    a                                       -- _obj
+    -> BufferList                           -- list
+    -> m FlowReturn                         -- result
+padPushList _obj list = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    list' <- copyBoxed list
+    result <- gst_pad_push_list _obj' list'
+    let result' = (toEnum . fromIntegral) result
+    touchManagedPtr _obj
+    touchManagedPtr list
+    return result'
+
+data PadPushListMethodInfo
+instance (signature ~ (BufferList -> m FlowReturn), MonadIO m, PadK a) => MethodInfo PadPushListMethodInfo a signature where
+    overloadedMethod _ = padPushList
+
+-- method Pad::query
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "query", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_query" gst_pad_query :: 
+    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"
+    Ptr Query ->                            -- query : TInterface "Gst" "Query"
+    IO CInt
+
+
+padQuery ::
+    (MonadIO m, PadK a) =>
+    a                                       -- _obj
+    -> Query                                -- query
+    -> m Bool                               -- result
+padQuery _obj query = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let query' = unsafeManagedPtrGetPtr query
+    result <- gst_pad_query _obj' query'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    touchManagedPtr query
+    return result'
+
+data PadQueryMethodInfo
+instance (signature ~ (Query -> m Bool), MonadIO m, PadK a) => MethodInfo PadQueryMethodInfo a signature where
+    overloadedMethod _ = padQuery
+
+-- method Pad::query_accept_caps
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_query_accept_caps" gst_pad_query_accept_caps :: 
+    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"
+    Ptr Caps ->                             -- caps : TInterface "Gst" "Caps"
+    IO CInt
+
+
+padQueryAcceptCaps ::
+    (MonadIO m, PadK a) =>
+    a                                       -- _obj
+    -> Caps                                 -- caps
+    -> m Bool                               -- result
+padQueryAcceptCaps _obj caps = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let caps' = unsafeManagedPtrGetPtr caps
+    result <- gst_pad_query_accept_caps _obj' caps'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    touchManagedPtr caps
+    return result'
+
+data PadQueryAcceptCapsMethodInfo
+instance (signature ~ (Caps -> m Bool), MonadIO m, PadK a) => MethodInfo PadQueryAcceptCapsMethodInfo a signature where
+    overloadedMethod _ = padQueryAcceptCaps
+
+-- method Pad::query_caps
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "filter", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Caps"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_query_caps" gst_pad_query_caps :: 
+    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"
+    Ptr Caps ->                             -- filter : TInterface "Gst" "Caps"
+    IO (Ptr Caps)
+
+
+padQueryCaps ::
+    (MonadIO m, PadK a) =>
+    a                                       -- _obj
+    -> Maybe (Caps)                         -- filter
+    -> m Caps                               -- result
+padQueryCaps _obj filter = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    maybeFilter <- case filter of
+        Nothing -> return nullPtr
+        Just jFilter -> do
+            let jFilter' = unsafeManagedPtrGetPtr jFilter
+            return jFilter'
+    result <- gst_pad_query_caps _obj' maybeFilter
+    checkUnexpectedReturnNULL "gst_pad_query_caps" result
+    result' <- (wrapBoxed Caps) result
+    touchManagedPtr _obj
+    whenJust filter touchManagedPtr
+    return result'
+
+data PadQueryCapsMethodInfo
+instance (signature ~ (Maybe (Caps) -> m Caps), MonadIO m, PadK a) => MethodInfo PadQueryCapsMethodInfo a signature where
+    overloadedMethod _ = padQueryCaps
+
+-- method Pad::query_convert
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "src_format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "src_val", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest_format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest_val", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_query_convert" gst_pad_query_convert :: 
+    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"
+    CUInt ->                                -- src_format : TInterface "Gst" "Format"
+    Int64 ->                                -- src_val : TBasicType TInt64
+    CUInt ->                                -- dest_format : TInterface "Gst" "Format"
+    Ptr Int64 ->                            -- dest_val : TBasicType TInt64
+    IO CInt
+
+
+padQueryConvert ::
+    (MonadIO m, PadK a) =>
+    a                                       -- _obj
+    -> Format                               -- srcFormat
+    -> Int64                                -- srcVal
+    -> Format                               -- destFormat
+    -> m (Bool,Int64)                       -- result
+padQueryConvert _obj srcFormat srcVal destFormat = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let srcFormat' = (fromIntegral . fromEnum) srcFormat
+    let destFormat' = (fromIntegral . fromEnum) destFormat
+    destVal <- allocMem :: IO (Ptr Int64)
+    result <- gst_pad_query_convert _obj' srcFormat' srcVal destFormat' destVal
+    let result' = (/= 0) result
+    destVal' <- peek destVal
+    touchManagedPtr _obj
+    freeMem destVal
+    return (result', destVal')
+
+data PadQueryConvertMethodInfo
+instance (signature ~ (Format -> Int64 -> Format -> m (Bool,Int64)), MonadIO m, PadK a) => MethodInfo PadQueryConvertMethodInfo a signature where
+    overloadedMethod _ = padQueryConvert
+
+-- method Pad::query_default
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "parent", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "query", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_query_default" gst_pad_query_default :: 
+    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"
+    Ptr Object ->                           -- parent : TInterface "Gst" "Object"
+    Ptr Query ->                            -- query : TInterface "Gst" "Query"
+    IO CInt
+
+
+padQueryDefault ::
+    (MonadIO m, PadK a, ObjectK b) =>
+    a                                       -- _obj
+    -> Maybe (b)                            -- parent
+    -> Query                                -- query
+    -> m Bool                               -- result
+padQueryDefault _obj parent query = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    maybeParent <- case parent of
+        Nothing -> return nullPtr
+        Just jParent -> do
+            let jParent' = unsafeManagedPtrCastPtr jParent
+            return jParent'
+    let query' = unsafeManagedPtrGetPtr query
+    result <- gst_pad_query_default _obj' maybeParent query'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    whenJust parent touchManagedPtr
+    touchManagedPtr query
+    return result'
+
+data PadQueryDefaultMethodInfo
+instance (signature ~ (Maybe (b) -> Query -> m Bool), MonadIO m, PadK a, ObjectK b) => MethodInfo PadQueryDefaultMethodInfo a signature where
+    overloadedMethod _ = padQueryDefault
+
+-- method Pad::query_duration
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "duration", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_query_duration" gst_pad_query_duration :: 
+    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"
+    CUInt ->                                -- format : TInterface "Gst" "Format"
+    Ptr Int64 ->                            -- duration : TBasicType TInt64
+    IO CInt
+
+
+padQueryDuration ::
+    (MonadIO m, PadK a) =>
+    a                                       -- _obj
+    -> Format                               -- format
+    -> m (Bool,Int64)                       -- result
+padQueryDuration _obj format = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let format' = (fromIntegral . fromEnum) format
+    duration <- allocMem :: IO (Ptr Int64)
+    result <- gst_pad_query_duration _obj' format' duration
+    let result' = (/= 0) result
+    duration' <- peek duration
+    touchManagedPtr _obj
+    freeMem duration
+    return (result', duration')
+
+data PadQueryDurationMethodInfo
+instance (signature ~ (Format -> m (Bool,Int64)), MonadIO m, PadK a) => MethodInfo PadQueryDurationMethodInfo a signature where
+    overloadedMethod _ = padQueryDuration
+
+-- method Pad::query_position
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cur", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_query_position" gst_pad_query_position :: 
+    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"
+    CUInt ->                                -- format : TInterface "Gst" "Format"
+    Ptr Int64 ->                            -- cur : TBasicType TInt64
+    IO CInt
+
+
+padQueryPosition ::
+    (MonadIO m, PadK a) =>
+    a                                       -- _obj
+    -> Format                               -- format
+    -> m (Bool,Int64)                       -- result
+padQueryPosition _obj format = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let format' = (fromIntegral . fromEnum) format
+    cur <- allocMem :: IO (Ptr Int64)
+    result <- gst_pad_query_position _obj' format' cur
+    let result' = (/= 0) result
+    cur' <- peek cur
+    touchManagedPtr _obj
+    freeMem cur
+    return (result', cur')
+
+data PadQueryPositionMethodInfo
+instance (signature ~ (Format -> m (Bool,Int64)), MonadIO m, PadK a) => MethodInfo PadQueryPositionMethodInfo a signature where
+    overloadedMethod _ = padQueryPosition
+
+-- method Pad::remove_probe
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "id", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_remove_probe" gst_pad_remove_probe :: 
+    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"
+    Word64 ->                               -- id : TBasicType TUInt64
+    IO ()
+
+
+padRemoveProbe ::
+    (MonadIO m, PadK a) =>
+    a                                       -- _obj
+    -> Word64                               -- id
+    -> m ()                                 -- result
+padRemoveProbe _obj id = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    gst_pad_remove_probe _obj' id
+    touchManagedPtr _obj
+    return ()
+
+data PadRemoveProbeMethodInfo
+instance (signature ~ (Word64 -> m ()), MonadIO m, PadK a) => MethodInfo PadRemoveProbeMethodInfo a signature where
+    overloadedMethod _ = padRemoveProbe
+
+-- method Pad::send_event
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "event", argType = TInterface "Gst" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_send_event" gst_pad_send_event :: 
+    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"
+    Ptr Event ->                            -- event : TInterface "Gst" "Event"
+    IO CInt
+
+
+padSendEvent ::
+    (MonadIO m, PadK a) =>
+    a                                       -- _obj
+    -> Event                                -- event
+    -> m Bool                               -- result
+padSendEvent _obj event = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    event' <- copyBoxed event
+    result <- gst_pad_send_event _obj' event'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    touchManagedPtr event
+    return result'
+
+data PadSendEventMethodInfo
+instance (signature ~ (Event -> m Bool), MonadIO m, PadK a) => MethodInfo PadSendEventMethodInfo a signature where
+    overloadedMethod _ = padSendEvent
+
+-- method Pad::set_activate_function_full
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "activate", argType = TInterface "Gst" "PadActivateFunction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "notify", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_set_activate_function_full" gst_pad_set_activate_function_full :: 
+    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"
+    FunPtr PadActivateFunctionC ->          -- activate : TInterface "Gst" "PadActivateFunction"
+    Ptr () ->                               -- user_data : TBasicType TVoid
+    FunPtr GLib.DestroyNotifyC ->           -- notify : TInterface "GLib" "DestroyNotify"
+    IO ()
+
+
+padSetActivateFunctionFull ::
+    (MonadIO m, PadK a) =>
+    a                                       -- _obj
+    -> PadActivateFunction                  -- activate
+    -> m ()                                 -- result
+padSetActivateFunctionFull _obj activate = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    activate' <- mkPadActivateFunction (padActivateFunctionWrapper Nothing activate)
+    let userData = castFunPtrToPtr activate'
+    let notify = safeFreeFunPtrPtr
+    gst_pad_set_activate_function_full _obj' activate' userData notify
+    touchManagedPtr _obj
+    return ()
+
+data PadSetActivateFunctionFullMethodInfo
+instance (signature ~ (PadActivateFunction -> m ()), MonadIO m, PadK a) => MethodInfo PadSetActivateFunctionFullMethodInfo a signature where
+    overloadedMethod _ = padSetActivateFunctionFull
+
+-- method Pad::set_activatemode_function_full
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "activatemode", argType = TInterface "Gst" "PadActivateModeFunction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "notify", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_set_activatemode_function_full" gst_pad_set_activatemode_function_full :: 
+    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"
+    FunPtr PadActivateModeFunctionC ->      -- activatemode : TInterface "Gst" "PadActivateModeFunction"
+    Ptr () ->                               -- user_data : TBasicType TVoid
+    FunPtr GLib.DestroyNotifyC ->           -- notify : TInterface "GLib" "DestroyNotify"
+    IO ()
+
+
+padSetActivatemodeFunctionFull ::
+    (MonadIO m, PadK a) =>
+    a                                       -- _obj
+    -> PadActivateModeFunction              -- activatemode
+    -> m ()                                 -- result
+padSetActivatemodeFunctionFull _obj activatemode = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    activatemode' <- mkPadActivateModeFunction (padActivateModeFunctionWrapper Nothing activatemode)
+    let userData = castFunPtrToPtr activatemode'
+    let notify = safeFreeFunPtrPtr
+    gst_pad_set_activatemode_function_full _obj' activatemode' userData notify
+    touchManagedPtr _obj
+    return ()
+
+data PadSetActivatemodeFunctionFullMethodInfo
+instance (signature ~ (PadActivateModeFunction -> m ()), MonadIO m, PadK a) => MethodInfo PadSetActivatemodeFunctionFullMethodInfo a signature where
+    overloadedMethod _ = padSetActivatemodeFunctionFull
+
+-- method Pad::set_active
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "active", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_set_active" gst_pad_set_active :: 
+    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"
+    CInt ->                                 -- active : TBasicType TBoolean
+    IO CInt
+
+
+padSetActive ::
+    (MonadIO m, PadK a) =>
+    a                                       -- _obj
+    -> Bool                                 -- active
+    -> m Bool                               -- result
+padSetActive _obj active = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let active' = (fromIntegral . fromEnum) active
+    result <- gst_pad_set_active _obj' active'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data PadSetActiveMethodInfo
+instance (signature ~ (Bool -> m Bool), MonadIO m, PadK a) => MethodInfo PadSetActiveMethodInfo a signature where
+    overloadedMethod _ = padSetActive
+
+-- method Pad::set_chain_function_full
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "chain", argType = TInterface "Gst" "PadChainFunction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "notify", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_set_chain_function_full" gst_pad_set_chain_function_full :: 
+    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"
+    FunPtr PadChainFunctionC ->             -- chain : TInterface "Gst" "PadChainFunction"
+    Ptr () ->                               -- user_data : TBasicType TVoid
+    FunPtr GLib.DestroyNotifyC ->           -- notify : TInterface "GLib" "DestroyNotify"
+    IO ()
+
+
+padSetChainFunctionFull ::
+    (MonadIO m, PadK a) =>
+    a                                       -- _obj
+    -> PadChainFunction                     -- chain
+    -> m ()                                 -- result
+padSetChainFunctionFull _obj chain = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    chain' <- mkPadChainFunction (padChainFunctionWrapper Nothing chain)
+    let userData = castFunPtrToPtr chain'
+    let notify = safeFreeFunPtrPtr
+    gst_pad_set_chain_function_full _obj' chain' userData notify
+    touchManagedPtr _obj
+    return ()
+
+data PadSetChainFunctionFullMethodInfo
+instance (signature ~ (PadChainFunction -> m ()), MonadIO m, PadK a) => MethodInfo PadSetChainFunctionFullMethodInfo a signature where
+    overloadedMethod _ = padSetChainFunctionFull
+
+-- method Pad::set_chain_list_function_full
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "chainlist", argType = TInterface "Gst" "PadChainListFunction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "notify", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_set_chain_list_function_full" gst_pad_set_chain_list_function_full :: 
+    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"
+    FunPtr PadChainListFunctionC ->         -- chainlist : TInterface "Gst" "PadChainListFunction"
+    Ptr () ->                               -- user_data : TBasicType TVoid
+    FunPtr GLib.DestroyNotifyC ->           -- notify : TInterface "GLib" "DestroyNotify"
+    IO ()
+
+
+padSetChainListFunctionFull ::
+    (MonadIO m, PadK a) =>
+    a                                       -- _obj
+    -> PadChainListFunction                 -- chainlist
+    -> m ()                                 -- result
+padSetChainListFunctionFull _obj chainlist = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    chainlist' <- mkPadChainListFunction (padChainListFunctionWrapper Nothing chainlist)
+    let userData = castFunPtrToPtr chainlist'
+    let notify = safeFreeFunPtrPtr
+    gst_pad_set_chain_list_function_full _obj' chainlist' userData notify
+    touchManagedPtr _obj
+    return ()
+
+data PadSetChainListFunctionFullMethodInfo
+instance (signature ~ (PadChainListFunction -> m ()), MonadIO m, PadK a) => MethodInfo PadSetChainListFunctionFullMethodInfo a signature where
+    overloadedMethod _ = padSetChainListFunctionFull
+
+-- method Pad::set_element_private
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "priv", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_set_element_private" gst_pad_set_element_private :: 
+    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"
+    Ptr () ->                               -- priv : TBasicType TVoid
+    IO ()
+
+
+padSetElementPrivate ::
+    (MonadIO m, PadK a) =>
+    a                                       -- _obj
+    -> Ptr ()                               -- priv
+    -> m ()                                 -- result
+padSetElementPrivate _obj priv = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    gst_pad_set_element_private _obj' priv
+    touchManagedPtr _obj
+    return ()
+
+data PadSetElementPrivateMethodInfo
+instance (signature ~ (Ptr () -> m ()), MonadIO m, PadK a) => MethodInfo PadSetElementPrivateMethodInfo a signature where
+    overloadedMethod _ = padSetElementPrivate
+
+-- method Pad::set_event_function_full
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "event", argType = TInterface "Gst" "PadEventFunction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "notify", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_set_event_function_full" gst_pad_set_event_function_full :: 
+    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"
+    FunPtr PadEventFunctionC ->             -- event : TInterface "Gst" "PadEventFunction"
+    Ptr () ->                               -- user_data : TBasicType TVoid
+    FunPtr GLib.DestroyNotifyC ->           -- notify : TInterface "GLib" "DestroyNotify"
+    IO ()
+
+
+padSetEventFunctionFull ::
+    (MonadIO m, PadK a) =>
+    a                                       -- _obj
+    -> PadEventFunction                     -- event
+    -> m ()                                 -- result
+padSetEventFunctionFull _obj event = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    event' <- mkPadEventFunction (padEventFunctionWrapper Nothing event)
+    let userData = castFunPtrToPtr event'
+    let notify = safeFreeFunPtrPtr
+    gst_pad_set_event_function_full _obj' event' userData notify
+    touchManagedPtr _obj
+    return ()
+
+data PadSetEventFunctionFullMethodInfo
+instance (signature ~ (PadEventFunction -> m ()), MonadIO m, PadK a) => MethodInfo PadSetEventFunctionFullMethodInfo a signature where
+    overloadedMethod _ = padSetEventFunctionFull
+
+-- method Pad::set_getrange_function_full
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "get", argType = TInterface "Gst" "PadGetRangeFunction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "notify", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_set_getrange_function_full" gst_pad_set_getrange_function_full :: 
+    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"
+    FunPtr PadGetRangeFunctionC ->          -- get : TInterface "Gst" "PadGetRangeFunction"
+    Ptr () ->                               -- user_data : TBasicType TVoid
+    FunPtr GLib.DestroyNotifyC ->           -- notify : TInterface "GLib" "DestroyNotify"
+    IO ()
+
+
+padSetGetrangeFunctionFull ::
+    (MonadIO m, PadK a) =>
+    a                                       -- _obj
+    -> PadGetRangeFunction                  -- get
+    -> m ()                                 -- result
+padSetGetrangeFunctionFull _obj get = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    get' <- mkPadGetRangeFunction (padGetRangeFunctionWrapper Nothing get)
+    let userData = castFunPtrToPtr get'
+    let notify = safeFreeFunPtrPtr
+    gst_pad_set_getrange_function_full _obj' get' userData notify
+    touchManagedPtr _obj
+    return ()
+
+data PadSetGetrangeFunctionFullMethodInfo
+instance (signature ~ (PadGetRangeFunction -> m ()), MonadIO m, PadK a) => MethodInfo PadSetGetrangeFunctionFullMethodInfo a signature where
+    overloadedMethod _ = padSetGetrangeFunctionFull
+
+-- method Pad::set_iterate_internal_links_function_full
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "iterintlink", argType = TInterface "Gst" "PadIterIntLinkFunction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "notify", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_set_iterate_internal_links_function_full" gst_pad_set_iterate_internal_links_function_full :: 
+    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"
+    FunPtr PadIterIntLinkFunctionC ->       -- iterintlink : TInterface "Gst" "PadIterIntLinkFunction"
+    Ptr () ->                               -- user_data : TBasicType TVoid
+    FunPtr GLib.DestroyNotifyC ->           -- notify : TInterface "GLib" "DestroyNotify"
+    IO ()
+
+
+padSetIterateInternalLinksFunctionFull ::
+    (MonadIO m, PadK a) =>
+    a                                       -- _obj
+    -> PadIterIntLinkFunction               -- iterintlink
+    -> m ()                                 -- result
+padSetIterateInternalLinksFunctionFull _obj iterintlink = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    iterintlink' <- mkPadIterIntLinkFunction (padIterIntLinkFunctionWrapper Nothing iterintlink)
+    let userData = castFunPtrToPtr iterintlink'
+    let notify = safeFreeFunPtrPtr
+    gst_pad_set_iterate_internal_links_function_full _obj' iterintlink' userData notify
+    touchManagedPtr _obj
+    return ()
+
+data PadSetIterateInternalLinksFunctionFullMethodInfo
+instance (signature ~ (PadIterIntLinkFunction -> m ()), MonadIO m, PadK a) => MethodInfo PadSetIterateInternalLinksFunctionFullMethodInfo a signature where
+    overloadedMethod _ = padSetIterateInternalLinksFunctionFull
+
+-- method Pad::set_link_function_full
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "link", argType = TInterface "Gst" "PadLinkFunction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "notify", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_set_link_function_full" gst_pad_set_link_function_full :: 
+    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"
+    FunPtr PadLinkFunctionC ->              -- link : TInterface "Gst" "PadLinkFunction"
+    Ptr () ->                               -- user_data : TBasicType TVoid
+    FunPtr GLib.DestroyNotifyC ->           -- notify : TInterface "GLib" "DestroyNotify"
+    IO ()
+
+
+padSetLinkFunctionFull ::
+    (MonadIO m, PadK a) =>
+    a                                       -- _obj
+    -> PadLinkFunction                      -- link
+    -> m ()                                 -- result
+padSetLinkFunctionFull _obj link = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    link' <- mkPadLinkFunction (padLinkFunctionWrapper Nothing link)
+    let userData = castFunPtrToPtr link'
+    let notify = safeFreeFunPtrPtr
+    gst_pad_set_link_function_full _obj' link' userData notify
+    touchManagedPtr _obj
+    return ()
+
+data PadSetLinkFunctionFullMethodInfo
+instance (signature ~ (PadLinkFunction -> m ()), MonadIO m, PadK a) => MethodInfo PadSetLinkFunctionFullMethodInfo a signature where
+    overloadedMethod _ = padSetLinkFunctionFull
+
+-- method Pad::set_offset
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_set_offset" gst_pad_set_offset :: 
+    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"
+    Int64 ->                                -- offset : TBasicType TInt64
+    IO ()
+
+
+padSetOffset ::
+    (MonadIO m, PadK a) =>
+    a                                       -- _obj
+    -> Int64                                -- offset
+    -> m ()                                 -- result
+padSetOffset _obj offset = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    gst_pad_set_offset _obj' offset
+    touchManagedPtr _obj
+    return ()
+
+data PadSetOffsetMethodInfo
+instance (signature ~ (Int64 -> m ()), MonadIO m, PadK a) => MethodInfo PadSetOffsetMethodInfo a signature where
+    overloadedMethod _ = padSetOffset
+
+-- method Pad::set_query_function_full
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "query", argType = TInterface "Gst" "PadQueryFunction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "notify", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_set_query_function_full" gst_pad_set_query_function_full :: 
+    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"
+    FunPtr PadQueryFunctionC ->             -- query : TInterface "Gst" "PadQueryFunction"
+    Ptr () ->                               -- user_data : TBasicType TVoid
+    FunPtr GLib.DestroyNotifyC ->           -- notify : TInterface "GLib" "DestroyNotify"
+    IO ()
+
+
+padSetQueryFunctionFull ::
+    (MonadIO m, PadK a) =>
+    a                                       -- _obj
+    -> PadQueryFunction                     -- query
+    -> m ()                                 -- result
+padSetQueryFunctionFull _obj query = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    query' <- mkPadQueryFunction (padQueryFunctionWrapper Nothing query)
+    let userData = castFunPtrToPtr query'
+    let notify = safeFreeFunPtrPtr
+    gst_pad_set_query_function_full _obj' query' userData notify
+    touchManagedPtr _obj
+    return ()
+
+data PadSetQueryFunctionFullMethodInfo
+instance (signature ~ (PadQueryFunction -> m ()), MonadIO m, PadK a) => MethodInfo PadSetQueryFunctionFullMethodInfo a signature where
+    overloadedMethod _ = padSetQueryFunctionFull
+
+-- method Pad::set_unlink_function_full
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "unlink", argType = TInterface "Gst" "PadUnlinkFunction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "notify", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_set_unlink_function_full" gst_pad_set_unlink_function_full :: 
+    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"
+    FunPtr PadUnlinkFunctionC ->            -- unlink : TInterface "Gst" "PadUnlinkFunction"
+    Ptr () ->                               -- user_data : TBasicType TVoid
+    FunPtr GLib.DestroyNotifyC ->           -- notify : TInterface "GLib" "DestroyNotify"
+    IO ()
+
+
+padSetUnlinkFunctionFull ::
+    (MonadIO m, PadK a) =>
+    a                                       -- _obj
+    -> PadUnlinkFunction                    -- unlink
+    -> m ()                                 -- result
+padSetUnlinkFunctionFull _obj unlink = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    unlink' <- mkPadUnlinkFunction (padUnlinkFunctionWrapper Nothing unlink)
+    let userData = castFunPtrToPtr unlink'
+    let notify = safeFreeFunPtrPtr
+    gst_pad_set_unlink_function_full _obj' unlink' userData notify
+    touchManagedPtr _obj
+    return ()
+
+data PadSetUnlinkFunctionFullMethodInfo
+instance (signature ~ (PadUnlinkFunction -> m ()), MonadIO m, PadK a) => MethodInfo PadSetUnlinkFunctionFullMethodInfo a signature where
+    overloadedMethod _ = padSetUnlinkFunctionFull
+
+-- method Pad::start_task
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "func", argType = TInterface "Gst" "TaskFunction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "notify", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_start_task" gst_pad_start_task :: 
+    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"
+    FunPtr TaskFunctionC ->                 -- func : TInterface "Gst" "TaskFunction"
+    Ptr () ->                               -- user_data : TBasicType TVoid
+    FunPtr GLib.DestroyNotifyC ->           -- notify : TInterface "GLib" "DestroyNotify"
+    IO CInt
+
+
+padStartTask ::
+    (MonadIO m, PadK a) =>
+    a                                       -- _obj
+    -> TaskFunction                         -- func
+    -> m Bool                               -- result
+padStartTask _obj func = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    func' <- mkTaskFunction (taskFunctionWrapper Nothing func)
+    let userData = castFunPtrToPtr func'
+    let notify = safeFreeFunPtrPtr
+    result <- gst_pad_start_task _obj' func' userData notify
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data PadStartTaskMethodInfo
+instance (signature ~ (TaskFunction -> m Bool), MonadIO m, PadK a) => MethodInfo PadStartTaskMethodInfo a signature where
+    overloadedMethod _ = padStartTask
+
+-- method Pad::sticky_events_foreach
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "foreach_func", argType = TInterface "Gst" "PadStickyEventsForeachFunction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_sticky_events_foreach" gst_pad_sticky_events_foreach :: 
+    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"
+    FunPtr PadStickyEventsForeachFunctionC -> -- foreach_func : TInterface "Gst" "PadStickyEventsForeachFunction"
+    Ptr () ->                               -- user_data : TBasicType TVoid
+    IO ()
+
+
+padStickyEventsForeach ::
+    (MonadIO m, PadK a) =>
+    a                                       -- _obj
+    -> PadStickyEventsForeachFunction       -- foreachFunc
+    -> m ()                                 -- result
+padStickyEventsForeach _obj foreachFunc = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    foreachFunc' <- mkPadStickyEventsForeachFunction (padStickyEventsForeachFunctionWrapper Nothing foreachFunc)
+    let userData = nullPtr
+    gst_pad_sticky_events_foreach _obj' foreachFunc' userData
+    safeFreeFunPtr $ castFunPtrToPtr foreachFunc'
+    touchManagedPtr _obj
+    return ()
+
+data PadStickyEventsForeachMethodInfo
+instance (signature ~ (PadStickyEventsForeachFunction -> m ()), MonadIO m, PadK a) => MethodInfo PadStickyEventsForeachMethodInfo a signature where
+    overloadedMethod _ = padStickyEventsForeach
+
+-- method Pad::stop_task
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_stop_task" gst_pad_stop_task :: 
+    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"
+    IO CInt
+
+
+padStopTask ::
+    (MonadIO m, PadK a) =>
+    a                                       -- _obj
+    -> m Bool                               -- result
+padStopTask _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_pad_stop_task _obj'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data PadStopTaskMethodInfo
+instance (signature ~ (m Bool), MonadIO m, PadK a) => MethodInfo PadStopTaskMethodInfo a signature where
+    overloadedMethod _ = padStopTask
+
+-- method Pad::store_sticky_event
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "event", argType = TInterface "Gst" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "FlowReturn"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_store_sticky_event" gst_pad_store_sticky_event :: 
+    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"
+    Ptr Event ->                            -- event : TInterface "Gst" "Event"
+    IO CUInt
+
+
+padStoreStickyEvent ::
+    (MonadIO m, PadK a) =>
+    a                                       -- _obj
+    -> Event                                -- event
+    -> m FlowReturn                         -- result
+padStoreStickyEvent _obj event = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let event' = unsafeManagedPtrGetPtr event
+    result <- gst_pad_store_sticky_event _obj' event'
+    let result' = (toEnum . fromIntegral) result
+    touchManagedPtr _obj
+    touchManagedPtr event
+    return result'
+
+data PadStoreStickyEventMethodInfo
+instance (signature ~ (Event -> m FlowReturn), MonadIO m, PadK a) => MethodInfo PadStoreStickyEventMethodInfo a signature where
+    overloadedMethod _ = padStoreStickyEvent
+
+-- method Pad::unlink
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "sinkpad", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_unlink" gst_pad_unlink :: 
+    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"
+    Ptr Pad ->                              -- sinkpad : TInterface "Gst" "Pad"
+    IO CInt
+
+
+padUnlink ::
+    (MonadIO m, PadK a, PadK b) =>
+    a                                       -- _obj
+    -> b                                    -- sinkpad
+    -> m Bool                               -- result
+padUnlink _obj sinkpad = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let sinkpad' = unsafeManagedPtrCastPtr sinkpad
+    result <- gst_pad_unlink _obj' sinkpad'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    touchManagedPtr sinkpad
+    return result'
+
+data PadUnlinkMethodInfo
+instance (signature ~ (b -> m Bool), MonadIO m, PadK a, PadK b) => MethodInfo PadUnlinkMethodInfo a signature where
+    overloadedMethod _ = padUnlink
+
+-- method Pad::use_fixed_caps
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_use_fixed_caps" gst_pad_use_fixed_caps :: 
+    Ptr Pad ->                              -- _obj : TInterface "Gst" "Pad"
+    IO ()
+
+
+padUseFixedCaps ::
+    (MonadIO m, PadK a) =>
+    a                                       -- _obj
+    -> m ()                                 -- result
+padUseFixedCaps _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    gst_pad_use_fixed_caps _obj'
+    touchManagedPtr _obj
+    return ()
+
+data PadUseFixedCapsMethodInfo
+instance (signature ~ (m ()), MonadIO m, PadK a) => MethodInfo PadUseFixedCapsMethodInfo a signature where
+    overloadedMethod _ = padUseFixedCaps
+
+-- method Pad::link_get_name
+-- method type : MemberFunction
+-- Args : [Arg {argCName = "ret", argType = TInterface "Gst" "PadLinkReturn", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUTF8
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_link_get_name" gst_pad_link_get_name :: 
+    CUInt ->                                -- ret : TInterface "Gst" "PadLinkReturn"
+    IO CString
+
+
+padLinkGetName ::
+    (MonadIO m) =>
+    PadLinkReturn                           -- ret
+    -> m T.Text                             -- result
+padLinkGetName ret = liftIO $ do
+    let ret' = (fromIntegral . fromEnum) ret
+    result <- gst_pad_link_get_name ret'
+    checkUnexpectedReturnNULL "gst_pad_link_get_name" result
+    result' <- cstringToText result
+    return result'
+
+
diff --git a/GI/Gst/Objects/Pad.hs-boot b/GI/Gst/Objects/Pad.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Objects/Pad.hs-boot
@@ -0,0 +1,93 @@
+module GI.Gst.Objects.Pad where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+newtype Pad = Pad (ForeignPtr Pad)
+instance GObject Pad where
+class GObject o => PadK o
+instance (GObject o, IsDescendantOf Pad o) => PadK o
+data PadCapsPropertyInfo
+data PadDirectionPropertyInfo
+data PadOffsetPropertyInfo
+data PadTemplatePropertyInfo
+data PadLinkedSignalInfo
+data PadUnlinkedSignalInfo
+data PadActivateModeMethodInfo
+data PadAddProbeMethodInfo
+data PadCanLinkMethodInfo
+data PadChainMethodInfo
+data PadChainListMethodInfo
+data PadCheckReconfigureMethodInfo
+data PadCreateStreamIdMethodInfo
+data PadEventDefaultMethodInfo
+data PadForwardMethodInfo
+data PadGetAllowedCapsMethodInfo
+data PadGetCurrentCapsMethodInfo
+data PadGetDirectionMethodInfo
+data PadGetElementPrivateMethodInfo
+data PadGetLastFlowReturnMethodInfo
+data PadGetOffsetMethodInfo
+data PadGetPadTemplateMethodInfo
+data PadGetPadTemplateCapsMethodInfo
+data PadGetParentElementMethodInfo
+data PadGetPeerMethodInfo
+data PadGetRangeMethodInfo
+data PadGetStickyEventMethodInfo
+data PadGetStreamIdMethodInfo
+data PadHasCurrentCapsMethodInfo
+data PadIsActiveMethodInfo
+data PadIsBlockedMethodInfo
+data PadIsBlockingMethodInfo
+data PadIsLinkedMethodInfo
+data PadIterateInternalLinksMethodInfo
+data PadIterateInternalLinksDefaultMethodInfo
+data PadLinkMethodInfo
+data PadLinkFullMethodInfo
+data PadMarkReconfigureMethodInfo
+data PadNeedsReconfigureMethodInfo
+data PadPauseTaskMethodInfo
+data PadPeerQueryMethodInfo
+data PadPeerQueryAcceptCapsMethodInfo
+data PadPeerQueryCapsMethodInfo
+data PadPeerQueryConvertMethodInfo
+data PadPeerQueryDurationMethodInfo
+data PadPeerQueryPositionMethodInfo
+data PadProxyQueryAcceptCapsMethodInfo
+data PadProxyQueryCapsMethodInfo
+data PadPullRangeMethodInfo
+data PadPushMethodInfo
+data PadPushEventMethodInfo
+data PadPushListMethodInfo
+data PadQueryMethodInfo
+data PadQueryAcceptCapsMethodInfo
+data PadQueryCapsMethodInfo
+data PadQueryConvertMethodInfo
+data PadQueryDefaultMethodInfo
+data PadQueryDurationMethodInfo
+data PadQueryPositionMethodInfo
+data PadRemoveProbeMethodInfo
+data PadSendEventMethodInfo
+data PadSetActivateFunctionFullMethodInfo
+data PadSetActivatemodeFunctionFullMethodInfo
+data PadSetActiveMethodInfo
+data PadSetChainFunctionFullMethodInfo
+data PadSetChainListFunctionFullMethodInfo
+data PadSetElementPrivateMethodInfo
+data PadSetEventFunctionFullMethodInfo
+data PadSetGetrangeFunctionFullMethodInfo
+data PadSetIterateInternalLinksFunctionFullMethodInfo
+data PadSetLinkFunctionFullMethodInfo
+data PadSetOffsetMethodInfo
+data PadSetQueryFunctionFullMethodInfo
+data PadSetUnlinkFunctionFullMethodInfo
+data PadStartTaskMethodInfo
+data PadStickyEventsForeachMethodInfo
+data PadStopTaskMethodInfo
+data PadStoreStickyEventMethodInfo
+data PadUnlinkMethodInfo
+data PadUseFixedCapsMethodInfo
diff --git a/GI/Gst/Objects/PadTemplate.hs b/GI/Gst/Objects/PadTemplate.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Objects/PadTemplate.hs
@@ -0,0 +1,400 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+-}
+
+module GI.Gst.Objects.PadTemplate
+    ( 
+
+-- * Exported types
+    PadTemplate(..)                         ,
+    PadTemplateK                            ,
+    toPadTemplate                           ,
+    noPadTemplate                           ,
+
+
+ -- * Methods
+-- ** padTemplateGetCaps
+    PadTemplateGetCapsMethodInfo            ,
+    padTemplateGetCaps                      ,
+
+
+-- ** padTemplateNew
+    padTemplateNew                          ,
+
+
+-- ** padTemplatePadCreated
+    PadTemplatePadCreatedMethodInfo         ,
+    padTemplatePadCreated                   ,
+
+
+
+
+ -- * Properties
+-- ** Caps
+    PadTemplateCapsPropertyInfo             ,
+    constructPadTemplateCaps                ,
+    getPadTemplateCaps                      ,
+
+
+-- ** Direction
+    PadTemplateDirectionPropertyInfo        ,
+    constructPadTemplateDirection           ,
+    getPadTemplateDirection                 ,
+
+
+-- ** NameTemplate
+    PadTemplateNameTemplatePropertyInfo     ,
+    constructPadTemplateNameTemplate        ,
+    getPadTemplateNameTemplate              ,
+
+
+-- ** Presence
+    PadTemplatePresencePropertyInfo         ,
+    constructPadTemplatePresence            ,
+    getPadTemplatePresence                  ,
+
+
+
+
+ -- * Signals
+-- ** PadCreated
+    PadTemplatePadCreatedCallback           ,
+    PadTemplatePadCreatedCallbackC          ,
+    PadTemplatePadCreatedSignalInfo         ,
+    afterPadTemplatePadCreated              ,
+    mkPadTemplatePadCreatedCallback         ,
+    noPadTemplatePadCreatedCallback         ,
+    onPadTemplatePadCreated                 ,
+    padTemplatePadCreatedCallbackWrapper    ,
+    padTemplatePadCreatedClosure            ,
+
+
+
+
+    ) where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+import GI.Gst.Callbacks
+import qualified GI.GObject as GObject
+
+newtype PadTemplate = PadTemplate (ForeignPtr PadTemplate)
+foreign import ccall "gst_pad_template_get_type"
+    c_gst_pad_template_get_type :: IO GType
+
+type instance ParentTypes PadTemplate = PadTemplateParentTypes
+type PadTemplateParentTypes = '[Object, GObject.Object]
+
+instance GObject PadTemplate where
+    gobjectIsInitiallyUnowned _ = True
+    gobjectType _ = c_gst_pad_template_get_type
+    
+
+class GObject o => PadTemplateK o
+instance (GObject o, IsDescendantOf PadTemplate o) => PadTemplateK o
+
+toPadTemplate :: PadTemplateK o => o -> IO PadTemplate
+toPadTemplate = unsafeCastTo PadTemplate
+
+noPadTemplate :: Maybe PadTemplate
+noPadTemplate = Nothing
+
+type family ResolvePadTemplateMethod (t :: Symbol) (o :: *) :: * where
+    ResolvePadTemplateMethod "addControlBinding" o = ObjectAddControlBindingMethodInfo
+    ResolvePadTemplateMethod "bindProperty" o = GObject.ObjectBindPropertyMethodInfo
+    ResolvePadTemplateMethod "bindPropertyFull" o = GObject.ObjectBindPropertyFullMethodInfo
+    ResolvePadTemplateMethod "defaultError" o = ObjectDefaultErrorMethodInfo
+    ResolvePadTemplateMethod "forceFloating" o = GObject.ObjectForceFloatingMethodInfo
+    ResolvePadTemplateMethod "freezeNotify" o = GObject.ObjectFreezeNotifyMethodInfo
+    ResolvePadTemplateMethod "hasActiveControlBindings" o = ObjectHasActiveControlBindingsMethodInfo
+    ResolvePadTemplateMethod "hasAncestor" o = ObjectHasAncestorMethodInfo
+    ResolvePadTemplateMethod "hasAsAncestor" o = ObjectHasAsAncestorMethodInfo
+    ResolvePadTemplateMethod "hasAsParent" o = ObjectHasAsParentMethodInfo
+    ResolvePadTemplateMethod "isFloating" o = GObject.ObjectIsFloatingMethodInfo
+    ResolvePadTemplateMethod "notify" o = GObject.ObjectNotifyMethodInfo
+    ResolvePadTemplateMethod "notifyByPspec" o = GObject.ObjectNotifyByPspecMethodInfo
+    ResolvePadTemplateMethod "padCreated" o = PadTemplatePadCreatedMethodInfo
+    ResolvePadTemplateMethod "refSink" o = GObject.ObjectRefSinkMethodInfo
+    ResolvePadTemplateMethod "removeControlBinding" o = ObjectRemoveControlBindingMethodInfo
+    ResolvePadTemplateMethod "replaceData" o = GObject.ObjectReplaceDataMethodInfo
+    ResolvePadTemplateMethod "replaceQdata" o = GObject.ObjectReplaceQdataMethodInfo
+    ResolvePadTemplateMethod "runDispose" o = GObject.ObjectRunDisposeMethodInfo
+    ResolvePadTemplateMethod "stealData" o = GObject.ObjectStealDataMethodInfo
+    ResolvePadTemplateMethod "stealQdata" o = GObject.ObjectStealQdataMethodInfo
+    ResolvePadTemplateMethod "suggestNextSync" o = ObjectSuggestNextSyncMethodInfo
+    ResolvePadTemplateMethod "syncValues" o = ObjectSyncValuesMethodInfo
+    ResolvePadTemplateMethod "thawNotify" o = GObject.ObjectThawNotifyMethodInfo
+    ResolvePadTemplateMethod "unparent" o = ObjectUnparentMethodInfo
+    ResolvePadTemplateMethod "watchClosure" o = GObject.ObjectWatchClosureMethodInfo
+    ResolvePadTemplateMethod "getCaps" o = PadTemplateGetCapsMethodInfo
+    ResolvePadTemplateMethod "getControlBinding" o = ObjectGetControlBindingMethodInfo
+    ResolvePadTemplateMethod "getControlRate" o = ObjectGetControlRateMethodInfo
+    ResolvePadTemplateMethod "getData" o = GObject.ObjectGetDataMethodInfo
+    ResolvePadTemplateMethod "getGValueArray" o = ObjectGetGValueArrayMethodInfo
+    ResolvePadTemplateMethod "getName" o = ObjectGetNameMethodInfo
+    ResolvePadTemplateMethod "getParent" o = ObjectGetParentMethodInfo
+    ResolvePadTemplateMethod "getPathString" o = ObjectGetPathStringMethodInfo
+    ResolvePadTemplateMethod "getProperty" o = GObject.ObjectGetPropertyMethodInfo
+    ResolvePadTemplateMethod "getQdata" o = GObject.ObjectGetQdataMethodInfo
+    ResolvePadTemplateMethod "getValue" o = ObjectGetValueMethodInfo
+    ResolvePadTemplateMethod "getValueArray" o = ObjectGetValueArrayMethodInfo
+    ResolvePadTemplateMethod "setControlBindingDisabled" o = ObjectSetControlBindingDisabledMethodInfo
+    ResolvePadTemplateMethod "setControlBindingsDisabled" o = ObjectSetControlBindingsDisabledMethodInfo
+    ResolvePadTemplateMethod "setControlRate" o = ObjectSetControlRateMethodInfo
+    ResolvePadTemplateMethod "setData" o = GObject.ObjectSetDataMethodInfo
+    ResolvePadTemplateMethod "setName" o = ObjectSetNameMethodInfo
+    ResolvePadTemplateMethod "setParent" o = ObjectSetParentMethodInfo
+    ResolvePadTemplateMethod "setProperty" o = GObject.ObjectSetPropertyMethodInfo
+    ResolvePadTemplateMethod l o = MethodResolutionFailed l o
+
+instance (info ~ ResolvePadTemplateMethod t PadTemplate, MethodInfo info PadTemplate p) => IsLabelProxy t (PadTemplate -> p) where
+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)
+
+#if MIN_VERSION_base(4,9,0)
+instance (info ~ ResolvePadTemplateMethod t PadTemplate, MethodInfo info PadTemplate p) => IsLabel t (PadTemplate -> p) where
+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)
+#endif
+
+-- signal PadTemplate::pad-created
+type PadTemplatePadCreatedCallback =
+    Pad ->
+    IO ()
+
+noPadTemplatePadCreatedCallback :: Maybe PadTemplatePadCreatedCallback
+noPadTemplatePadCreatedCallback = Nothing
+
+type PadTemplatePadCreatedCallbackC =
+    Ptr () ->                               -- object
+    Ptr Pad ->
+    Ptr () ->                               -- user_data
+    IO ()
+
+foreign import ccall "wrapper"
+    mkPadTemplatePadCreatedCallback :: PadTemplatePadCreatedCallbackC -> IO (FunPtr PadTemplatePadCreatedCallbackC)
+
+padTemplatePadCreatedClosure :: PadTemplatePadCreatedCallback -> IO Closure
+padTemplatePadCreatedClosure cb = newCClosure =<< mkPadTemplatePadCreatedCallback wrapped
+    where wrapped = padTemplatePadCreatedCallbackWrapper cb
+
+padTemplatePadCreatedCallbackWrapper ::
+    PadTemplatePadCreatedCallback ->
+    Ptr () ->
+    Ptr Pad ->
+    Ptr () ->
+    IO ()
+padTemplatePadCreatedCallbackWrapper _cb _ pad _ = do
+    pad' <- (newObject Pad) pad
+    _cb  pad'
+
+onPadTemplatePadCreated :: (GObject a, MonadIO m) => a -> PadTemplatePadCreatedCallback -> m SignalHandlerId
+onPadTemplatePadCreated obj cb = liftIO $ connectPadTemplatePadCreated obj cb SignalConnectBefore
+afterPadTemplatePadCreated :: (GObject a, MonadIO m) => a -> PadTemplatePadCreatedCallback -> m SignalHandlerId
+afterPadTemplatePadCreated obj cb = connectPadTemplatePadCreated obj cb SignalConnectAfter
+
+connectPadTemplatePadCreated :: (GObject a, MonadIO m) =>
+                                a -> PadTemplatePadCreatedCallback -> SignalConnectMode -> m SignalHandlerId
+connectPadTemplatePadCreated obj cb after = liftIO $ do
+    cb' <- mkPadTemplatePadCreatedCallback (padTemplatePadCreatedCallbackWrapper cb)
+    connectSignalFunPtr obj "pad-created" cb' after
+
+-- VVV Prop "caps"
+   -- Type: TInterface "Gst" "Caps"
+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
+
+getPadTemplateCaps :: (MonadIO m, PadTemplateK o) => o -> m Caps
+getPadTemplateCaps obj = liftIO $ getObjectPropertyBoxed obj "caps" Caps
+
+constructPadTemplateCaps :: Caps -> IO ([Char], GValue)
+constructPadTemplateCaps val = constructObjectPropertyBoxed "caps" val
+
+data PadTemplateCapsPropertyInfo
+instance AttrInfo PadTemplateCapsPropertyInfo where
+    type AttrAllowedOps PadTemplateCapsPropertyInfo = '[ 'AttrConstruct, 'AttrGet]
+    type AttrSetTypeConstraint PadTemplateCapsPropertyInfo = (~) Caps
+    type AttrBaseTypeConstraint PadTemplateCapsPropertyInfo = PadTemplateK
+    type AttrGetType PadTemplateCapsPropertyInfo = Caps
+    type AttrLabel PadTemplateCapsPropertyInfo = "caps"
+    attrGet _ = getPadTemplateCaps
+    attrSet _ = undefined
+    attrConstruct _ = constructPadTemplateCaps
+
+-- VVV Prop "direction"
+   -- Type: TInterface "Gst" "PadDirection"
+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
+
+getPadTemplateDirection :: (MonadIO m, PadTemplateK o) => o -> m PadDirection
+getPadTemplateDirection obj = liftIO $ getObjectPropertyEnum obj "direction"
+
+constructPadTemplateDirection :: PadDirection -> IO ([Char], GValue)
+constructPadTemplateDirection val = constructObjectPropertyEnum "direction" val
+
+data PadTemplateDirectionPropertyInfo
+instance AttrInfo PadTemplateDirectionPropertyInfo where
+    type AttrAllowedOps PadTemplateDirectionPropertyInfo = '[ 'AttrConstruct, 'AttrGet]
+    type AttrSetTypeConstraint PadTemplateDirectionPropertyInfo = (~) PadDirection
+    type AttrBaseTypeConstraint PadTemplateDirectionPropertyInfo = PadTemplateK
+    type AttrGetType PadTemplateDirectionPropertyInfo = PadDirection
+    type AttrLabel PadTemplateDirectionPropertyInfo = "direction"
+    attrGet _ = getPadTemplateDirection
+    attrSet _ = undefined
+    attrConstruct _ = constructPadTemplateDirection
+
+-- VVV Prop "name-template"
+   -- Type: TBasicType TUTF8
+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
+
+getPadTemplateNameTemplate :: (MonadIO m, PadTemplateK o) => o -> m T.Text
+getPadTemplateNameTemplate obj = liftIO $ getObjectPropertyString obj "name-template"
+
+constructPadTemplateNameTemplate :: T.Text -> IO ([Char], GValue)
+constructPadTemplateNameTemplate val = constructObjectPropertyString "name-template" val
+
+data PadTemplateNameTemplatePropertyInfo
+instance AttrInfo PadTemplateNameTemplatePropertyInfo where
+    type AttrAllowedOps PadTemplateNameTemplatePropertyInfo = '[ 'AttrConstruct, 'AttrGet]
+    type AttrSetTypeConstraint PadTemplateNameTemplatePropertyInfo = (~) T.Text
+    type AttrBaseTypeConstraint PadTemplateNameTemplatePropertyInfo = PadTemplateK
+    type AttrGetType PadTemplateNameTemplatePropertyInfo = T.Text
+    type AttrLabel PadTemplateNameTemplatePropertyInfo = "name-template"
+    attrGet _ = getPadTemplateNameTemplate
+    attrSet _ = undefined
+    attrConstruct _ = constructPadTemplateNameTemplate
+
+-- VVV Prop "presence"
+   -- Type: TInterface "Gst" "PadPresence"
+   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
+
+getPadTemplatePresence :: (MonadIO m, PadTemplateK o) => o -> m PadPresence
+getPadTemplatePresence obj = liftIO $ getObjectPropertyEnum obj "presence"
+
+constructPadTemplatePresence :: PadPresence -> IO ([Char], GValue)
+constructPadTemplatePresence val = constructObjectPropertyEnum "presence" val
+
+data PadTemplatePresencePropertyInfo
+instance AttrInfo PadTemplatePresencePropertyInfo where
+    type AttrAllowedOps PadTemplatePresencePropertyInfo = '[ 'AttrConstruct, 'AttrGet]
+    type AttrSetTypeConstraint PadTemplatePresencePropertyInfo = (~) PadPresence
+    type AttrBaseTypeConstraint PadTemplatePresencePropertyInfo = PadTemplateK
+    type AttrGetType PadTemplatePresencePropertyInfo = PadPresence
+    type AttrLabel PadTemplatePresencePropertyInfo = "presence"
+    attrGet _ = getPadTemplatePresence
+    attrSet _ = undefined
+    attrConstruct _ = constructPadTemplatePresence
+
+type instance AttributeList PadTemplate = PadTemplateAttributeList
+type PadTemplateAttributeList = ('[ '("caps", PadTemplateCapsPropertyInfo), '("direction", PadTemplateDirectionPropertyInfo), '("name", ObjectNamePropertyInfo), '("nameTemplate", PadTemplateNameTemplatePropertyInfo), '("parent", ObjectParentPropertyInfo), '("presence", PadTemplatePresencePropertyInfo)] :: [(Symbol, *)])
+
+data PadTemplatePadCreatedSignalInfo
+instance SignalInfo PadTemplatePadCreatedSignalInfo where
+    type HaskellCallbackType PadTemplatePadCreatedSignalInfo = PadTemplatePadCreatedCallback
+    connectSignal _ = connectPadTemplatePadCreated
+
+type instance SignalList PadTemplate = PadTemplateSignalList
+type PadTemplateSignalList = ('[ '("deepNotify", ObjectDeepNotifySignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("padCreated", PadTemplatePadCreatedSignalInfo)] :: [(Symbol, *)])
+
+-- method PadTemplate::new
+-- method type : Constructor
+-- Args : [Arg {argCName = "name_template", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "direction", argType = TInterface "Gst" "PadDirection", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "presence", argType = TInterface "Gst" "PadPresence", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "PadTemplate"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_template_new" gst_pad_template_new :: 
+    CString ->                              -- name_template : TBasicType TUTF8
+    CUInt ->                                -- direction : TInterface "Gst" "PadDirection"
+    CUInt ->                                -- presence : TInterface "Gst" "PadPresence"
+    Ptr Caps ->                             -- caps : TInterface "Gst" "Caps"
+    IO (Ptr PadTemplate)
+
+
+padTemplateNew ::
+    (MonadIO m) =>
+    T.Text                                  -- nameTemplate
+    -> PadDirection                         -- direction
+    -> PadPresence                          -- presence
+    -> Caps                                 -- caps
+    -> m PadTemplate                        -- result
+padTemplateNew nameTemplate direction presence caps = liftIO $ do
+    nameTemplate' <- textToCString nameTemplate
+    let direction' = (fromIntegral . fromEnum) direction
+    let presence' = (fromIntegral . fromEnum) presence
+    let caps' = unsafeManagedPtrGetPtr caps
+    result <- gst_pad_template_new nameTemplate' direction' presence' caps'
+    checkUnexpectedReturnNULL "gst_pad_template_new" result
+    result' <- (newObject PadTemplate) result
+    touchManagedPtr caps
+    freeMem nameTemplate'
+    return result'
+
+-- method PadTemplate::get_caps
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "PadTemplate", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Caps"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_template_get_caps" gst_pad_template_get_caps :: 
+    Ptr PadTemplate ->                      -- _obj : TInterface "Gst" "PadTemplate"
+    IO (Ptr Caps)
+
+
+padTemplateGetCaps ::
+    (MonadIO m, PadTemplateK a) =>
+    a                                       -- _obj
+    -> m Caps                               -- result
+padTemplateGetCaps _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_pad_template_get_caps _obj'
+    checkUnexpectedReturnNULL "gst_pad_template_get_caps" result
+    result' <- (wrapBoxed Caps) result
+    touchManagedPtr _obj
+    return result'
+
+data PadTemplateGetCapsMethodInfo
+instance (signature ~ (m Caps), MonadIO m, PadTemplateK a) => MethodInfo PadTemplateGetCapsMethodInfo a signature where
+    overloadedMethod _ = padTemplateGetCaps
+
+-- method PadTemplate::pad_created
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "PadTemplate", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pad", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_template_pad_created" gst_pad_template_pad_created :: 
+    Ptr PadTemplate ->                      -- _obj : TInterface "Gst" "PadTemplate"
+    Ptr Pad ->                              -- pad : TInterface "Gst" "Pad"
+    IO ()
+
+
+padTemplatePadCreated ::
+    (MonadIO m, PadTemplateK a, PadK b) =>
+    a                                       -- _obj
+    -> b                                    -- pad
+    -> m ()                                 -- result
+padTemplatePadCreated _obj pad = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let pad' = unsafeManagedPtrCastPtr pad
+    gst_pad_template_pad_created _obj' pad'
+    touchManagedPtr _obj
+    touchManagedPtr pad
+    return ()
+
+data PadTemplatePadCreatedMethodInfo
+instance (signature ~ (b -> m ()), MonadIO m, PadTemplateK a, PadK b) => MethodInfo PadTemplatePadCreatedMethodInfo a signature where
+    overloadedMethod _ = padTemplatePadCreated
+
+
diff --git a/GI/Gst/Objects/PadTemplate.hs-boot b/GI/Gst/Objects/PadTemplate.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Objects/PadTemplate.hs-boot
@@ -0,0 +1,20 @@
+module GI.Gst.Objects.PadTemplate where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+newtype PadTemplate = PadTemplate (ForeignPtr PadTemplate)
+instance GObject PadTemplate where
+class GObject o => PadTemplateK o
+instance (GObject o, IsDescendantOf PadTemplate o) => PadTemplateK o
+data PadTemplateCapsPropertyInfo
+data PadTemplateDirectionPropertyInfo
+data PadTemplateNameTemplatePropertyInfo
+data PadTemplatePresencePropertyInfo
+data PadTemplatePadCreatedSignalInfo
+data PadTemplateGetCapsMethodInfo
+data PadTemplatePadCreatedMethodInfo
diff --git a/GI/Gst/Objects/Pipeline.hs b/GI/Gst/Objects/Pipeline.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Objects/Pipeline.hs
@@ -0,0 +1,660 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+-}
+
+module GI.Gst.Objects.Pipeline
+    ( 
+
+-- * Exported types
+    Pipeline(..)                            ,
+    PipelineK                               ,
+    toPipeline                              ,
+    noPipeline                              ,
+
+
+ -- * Methods
+-- ** pipelineAutoClock
+    PipelineAutoClockMethodInfo             ,
+    pipelineAutoClock                       ,
+
+
+-- ** pipelineGetAutoFlushBus
+    PipelineGetAutoFlushBusMethodInfo       ,
+    pipelineGetAutoFlushBus                 ,
+
+
+-- ** pipelineGetBus
+    PipelineGetBusMethodInfo                ,
+    pipelineGetBus                          ,
+
+
+-- ** pipelineGetDelay
+    PipelineGetDelayMethodInfo              ,
+    pipelineGetDelay                        ,
+
+
+-- ** pipelineGetLatency
+    PipelineGetLatencyMethodInfo            ,
+    pipelineGetLatency                      ,
+
+
+-- ** pipelineGetPipelineClock
+    PipelineGetPipelineClockMethodInfo      ,
+    pipelineGetPipelineClock                ,
+
+
+-- ** pipelineNew
+    pipelineNew                             ,
+
+
+-- ** pipelineSetAutoFlushBus
+    PipelineSetAutoFlushBusMethodInfo       ,
+    pipelineSetAutoFlushBus                 ,
+
+
+-- ** pipelineSetDelay
+    PipelineSetDelayMethodInfo              ,
+    pipelineSetDelay                        ,
+
+
+-- ** pipelineSetLatency
+    PipelineSetLatencyMethodInfo            ,
+    pipelineSetLatency                      ,
+
+
+-- ** pipelineUseClock
+    PipelineUseClockMethodInfo              ,
+    pipelineUseClock                        ,
+
+
+
+
+ -- * Properties
+-- ** AutoFlushBus
+    PipelineAutoFlushBusPropertyInfo        ,
+    constructPipelineAutoFlushBus           ,
+    getPipelineAutoFlushBus                 ,
+    setPipelineAutoFlushBus                 ,
+
+
+-- ** Delay
+    PipelineDelayPropertyInfo               ,
+    constructPipelineDelay                  ,
+    getPipelineDelay                        ,
+    setPipelineDelay                        ,
+
+
+-- ** Latency
+    PipelineLatencyPropertyInfo             ,
+    constructPipelineLatency                ,
+    getPipelineLatency                      ,
+    setPipelineLatency                      ,
+
+
+
+
+    ) where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+import GI.Gst.Callbacks
+import qualified GI.GObject as GObject
+
+newtype Pipeline = Pipeline (ForeignPtr Pipeline)
+foreign import ccall "gst_pipeline_get_type"
+    c_gst_pipeline_get_type :: IO GType
+
+type instance ParentTypes Pipeline = PipelineParentTypes
+type PipelineParentTypes = '[Bin, Element, Object, GObject.Object, ChildProxy]
+
+instance GObject Pipeline where
+    gobjectIsInitiallyUnowned _ = True
+    gobjectType _ = c_gst_pipeline_get_type
+    
+
+class GObject o => PipelineK o
+instance (GObject o, IsDescendantOf Pipeline o) => PipelineK o
+
+toPipeline :: PipelineK o => o -> IO Pipeline
+toPipeline = unsafeCastTo Pipeline
+
+noPipeline :: Maybe Pipeline
+noPipeline = Nothing
+
+type family ResolvePipelineMethod (t :: Symbol) (o :: *) :: * where
+    ResolvePipelineMethod "abortState" o = ElementAbortStateMethodInfo
+    ResolvePipelineMethod "add" o = BinAddMethodInfo
+    ResolvePipelineMethod "addControlBinding" o = ObjectAddControlBindingMethodInfo
+    ResolvePipelineMethod "addPad" o = ElementAddPadMethodInfo
+    ResolvePipelineMethod "autoClock" o = PipelineAutoClockMethodInfo
+    ResolvePipelineMethod "bindProperty" o = GObject.ObjectBindPropertyMethodInfo
+    ResolvePipelineMethod "bindPropertyFull" o = GObject.ObjectBindPropertyFullMethodInfo
+    ResolvePipelineMethod "changeState" o = ElementChangeStateMethodInfo
+    ResolvePipelineMethod "childAdded" o = ChildProxyChildAddedMethodInfo
+    ResolvePipelineMethod "childRemoved" o = ChildProxyChildRemovedMethodInfo
+    ResolvePipelineMethod "continueState" o = ElementContinueStateMethodInfo
+    ResolvePipelineMethod "createAllPads" o = ElementCreateAllPadsMethodInfo
+    ResolvePipelineMethod "defaultError" o = ObjectDefaultErrorMethodInfo
+    ResolvePipelineMethod "findUnlinkedPad" o = BinFindUnlinkedPadMethodInfo
+    ResolvePipelineMethod "forceFloating" o = GObject.ObjectForceFloatingMethodInfo
+    ResolvePipelineMethod "freezeNotify" o = GObject.ObjectFreezeNotifyMethodInfo
+    ResolvePipelineMethod "hasActiveControlBindings" o = ObjectHasActiveControlBindingsMethodInfo
+    ResolvePipelineMethod "hasAncestor" o = ObjectHasAncestorMethodInfo
+    ResolvePipelineMethod "hasAsAncestor" o = ObjectHasAsAncestorMethodInfo
+    ResolvePipelineMethod "hasAsParent" o = ObjectHasAsParentMethodInfo
+    ResolvePipelineMethod "isFloating" o = GObject.ObjectIsFloatingMethodInfo
+    ResolvePipelineMethod "isLockedState" o = ElementIsLockedStateMethodInfo
+    ResolvePipelineMethod "iterateAllByInterface" o = BinIterateAllByInterfaceMethodInfo
+    ResolvePipelineMethod "iterateElements" o = BinIterateElementsMethodInfo
+    ResolvePipelineMethod "iteratePads" o = ElementIteratePadsMethodInfo
+    ResolvePipelineMethod "iterateRecurse" o = BinIterateRecurseMethodInfo
+    ResolvePipelineMethod "iterateSinkPads" o = ElementIterateSinkPadsMethodInfo
+    ResolvePipelineMethod "iterateSinks" o = BinIterateSinksMethodInfo
+    ResolvePipelineMethod "iterateSorted" o = BinIterateSortedMethodInfo
+    ResolvePipelineMethod "iterateSources" o = BinIterateSourcesMethodInfo
+    ResolvePipelineMethod "iterateSrcPads" o = ElementIterateSrcPadsMethodInfo
+    ResolvePipelineMethod "link" o = ElementLinkMethodInfo
+    ResolvePipelineMethod "linkFiltered" o = ElementLinkFilteredMethodInfo
+    ResolvePipelineMethod "linkPads" o = ElementLinkPadsMethodInfo
+    ResolvePipelineMethod "linkPadsFiltered" o = ElementLinkPadsFilteredMethodInfo
+    ResolvePipelineMethod "linkPadsFull" o = ElementLinkPadsFullMethodInfo
+    ResolvePipelineMethod "lookup" o = ChildProxyLookupMethodInfo
+    ResolvePipelineMethod "lostState" o = ElementLostStateMethodInfo
+    ResolvePipelineMethod "messageFull" o = ElementMessageFullMethodInfo
+    ResolvePipelineMethod "noMorePads" o = ElementNoMorePadsMethodInfo
+    ResolvePipelineMethod "notify" o = GObject.ObjectNotifyMethodInfo
+    ResolvePipelineMethod "notifyByPspec" o = GObject.ObjectNotifyByPspecMethodInfo
+    ResolvePipelineMethod "postMessage" o = ElementPostMessageMethodInfo
+    ResolvePipelineMethod "provideClock" o = ElementProvideClockMethodInfo
+    ResolvePipelineMethod "query" o = ElementQueryMethodInfo
+    ResolvePipelineMethod "queryConvert" o = ElementQueryConvertMethodInfo
+    ResolvePipelineMethod "queryDuration" o = ElementQueryDurationMethodInfo
+    ResolvePipelineMethod "queryPosition" o = ElementQueryPositionMethodInfo
+    ResolvePipelineMethod "recalculateLatency" o = BinRecalculateLatencyMethodInfo
+    ResolvePipelineMethod "refSink" o = GObject.ObjectRefSinkMethodInfo
+    ResolvePipelineMethod "releaseRequestPad" o = ElementReleaseRequestPadMethodInfo
+    ResolvePipelineMethod "remove" o = BinRemoveMethodInfo
+    ResolvePipelineMethod "removeControlBinding" o = ObjectRemoveControlBindingMethodInfo
+    ResolvePipelineMethod "removePad" o = ElementRemovePadMethodInfo
+    ResolvePipelineMethod "replaceData" o = GObject.ObjectReplaceDataMethodInfo
+    ResolvePipelineMethod "replaceQdata" o = GObject.ObjectReplaceQdataMethodInfo
+    ResolvePipelineMethod "requestPad" o = ElementRequestPadMethodInfo
+    ResolvePipelineMethod "runDispose" o = GObject.ObjectRunDisposeMethodInfo
+    ResolvePipelineMethod "seek" o = ElementSeekMethodInfo
+    ResolvePipelineMethod "seekSimple" o = ElementSeekSimpleMethodInfo
+    ResolvePipelineMethod "sendEvent" o = ElementSendEventMethodInfo
+    ResolvePipelineMethod "stealData" o = GObject.ObjectStealDataMethodInfo
+    ResolvePipelineMethod "stealQdata" o = GObject.ObjectStealQdataMethodInfo
+    ResolvePipelineMethod "suggestNextSync" o = ObjectSuggestNextSyncMethodInfo
+    ResolvePipelineMethod "syncChildrenStates" o = BinSyncChildrenStatesMethodInfo
+    ResolvePipelineMethod "syncStateWithParent" o = ElementSyncStateWithParentMethodInfo
+    ResolvePipelineMethod "syncValues" o = ObjectSyncValuesMethodInfo
+    ResolvePipelineMethod "thawNotify" o = GObject.ObjectThawNotifyMethodInfo
+    ResolvePipelineMethod "unlink" o = ElementUnlinkMethodInfo
+    ResolvePipelineMethod "unlinkPads" o = ElementUnlinkPadsMethodInfo
+    ResolvePipelineMethod "unparent" o = ObjectUnparentMethodInfo
+    ResolvePipelineMethod "useClock" o = PipelineUseClockMethodInfo
+    ResolvePipelineMethod "watchClosure" o = GObject.ObjectWatchClosureMethodInfo
+    ResolvePipelineMethod "getAutoFlushBus" o = PipelineGetAutoFlushBusMethodInfo
+    ResolvePipelineMethod "getBaseTime" o = ElementGetBaseTimeMethodInfo
+    ResolvePipelineMethod "getByInterface" o = BinGetByInterfaceMethodInfo
+    ResolvePipelineMethod "getByName" o = BinGetByNameMethodInfo
+    ResolvePipelineMethod "getByNameRecurseUp" o = BinGetByNameRecurseUpMethodInfo
+    ResolvePipelineMethod "getChildByIndex" o = ChildProxyGetChildByIndexMethodInfo
+    ResolvePipelineMethod "getChildByName" o = ChildProxyGetChildByNameMethodInfo
+    ResolvePipelineMethod "getChildrenCount" o = ChildProxyGetChildrenCountMethodInfo
+    ResolvePipelineMethod "getClock" o = ElementGetClockMethodInfo
+    ResolvePipelineMethod "getCompatiblePad" o = ElementGetCompatiblePadMethodInfo
+    ResolvePipelineMethod "getCompatiblePadTemplate" o = ElementGetCompatiblePadTemplateMethodInfo
+    ResolvePipelineMethod "getControlBinding" o = ObjectGetControlBindingMethodInfo
+    ResolvePipelineMethod "getControlRate" o = ObjectGetControlRateMethodInfo
+    ResolvePipelineMethod "getData" o = GObject.ObjectGetDataMethodInfo
+    ResolvePipelineMethod "getDelay" o = PipelineGetDelayMethodInfo
+    ResolvePipelineMethod "getFactory" o = ElementGetFactoryMethodInfo
+    ResolvePipelineMethod "getGValueArray" o = ObjectGetGValueArrayMethodInfo
+    ResolvePipelineMethod "getLatency" o = PipelineGetLatencyMethodInfo
+    ResolvePipelineMethod "getName" o = ObjectGetNameMethodInfo
+    ResolvePipelineMethod "getParent" o = ObjectGetParentMethodInfo
+    ResolvePipelineMethod "getPathString" o = ObjectGetPathStringMethodInfo
+    ResolvePipelineMethod "getPipelineClock" o = PipelineGetPipelineClockMethodInfo
+    ResolvePipelineMethod "getQdata" o = GObject.ObjectGetQdataMethodInfo
+    ResolvePipelineMethod "getRequestPad" o = ElementGetRequestPadMethodInfo
+    ResolvePipelineMethod "getStartTime" o = ElementGetStartTimeMethodInfo
+    ResolvePipelineMethod "getState" o = ElementGetStateMethodInfo
+    ResolvePipelineMethod "getStaticPad" o = ElementGetStaticPadMethodInfo
+    ResolvePipelineMethod "getValue" o = ObjectGetValueMethodInfo
+    ResolvePipelineMethod "getValueArray" o = ObjectGetValueArrayMethodInfo
+    ResolvePipelineMethod "setAutoFlushBus" o = PipelineSetAutoFlushBusMethodInfo
+    ResolvePipelineMethod "setBaseTime" o = ElementSetBaseTimeMethodInfo
+    ResolvePipelineMethod "setBus" o = ElementSetBusMethodInfo
+    ResolvePipelineMethod "setClock" o = ElementSetClockMethodInfo
+    ResolvePipelineMethod "setContext" o = ElementSetContextMethodInfo
+    ResolvePipelineMethod "setControlBindingDisabled" o = ObjectSetControlBindingDisabledMethodInfo
+    ResolvePipelineMethod "setControlBindingsDisabled" o = ObjectSetControlBindingsDisabledMethodInfo
+    ResolvePipelineMethod "setControlRate" o = ObjectSetControlRateMethodInfo
+    ResolvePipelineMethod "setData" o = GObject.ObjectSetDataMethodInfo
+    ResolvePipelineMethod "setDelay" o = PipelineSetDelayMethodInfo
+    ResolvePipelineMethod "setLatency" o = PipelineSetLatencyMethodInfo
+    ResolvePipelineMethod "setLockedState" o = ElementSetLockedStateMethodInfo
+    ResolvePipelineMethod "setName" o = ObjectSetNameMethodInfo
+    ResolvePipelineMethod "setParent" o = ObjectSetParentMethodInfo
+    ResolvePipelineMethod "setStartTime" o = ElementSetStartTimeMethodInfo
+    ResolvePipelineMethod "setState" o = ElementSetStateMethodInfo
+    ResolvePipelineMethod l o = MethodResolutionFailed l o
+
+instance (info ~ ResolvePipelineMethod t Pipeline, MethodInfo info Pipeline p) => IsLabelProxy t (Pipeline -> p) where
+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)
+
+#if MIN_VERSION_base(4,9,0)
+instance (info ~ ResolvePipelineMethod t Pipeline, MethodInfo info Pipeline p) => IsLabel t (Pipeline -> p) where
+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)
+#endif
+
+-- VVV Prop "auto-flush-bus"
+   -- Type: TBasicType TBoolean
+   -- Flags: [PropertyReadable,PropertyWritable]
+
+getPipelineAutoFlushBus :: (MonadIO m, PipelineK o) => o -> m Bool
+getPipelineAutoFlushBus obj = liftIO $ getObjectPropertyBool obj "auto-flush-bus"
+
+setPipelineAutoFlushBus :: (MonadIO m, PipelineK o) => o -> Bool -> m ()
+setPipelineAutoFlushBus obj val = liftIO $ setObjectPropertyBool obj "auto-flush-bus" val
+
+constructPipelineAutoFlushBus :: Bool -> IO ([Char], GValue)
+constructPipelineAutoFlushBus val = constructObjectPropertyBool "auto-flush-bus" val
+
+data PipelineAutoFlushBusPropertyInfo
+instance AttrInfo PipelineAutoFlushBusPropertyInfo where
+    type AttrAllowedOps PipelineAutoFlushBusPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
+    type AttrSetTypeConstraint PipelineAutoFlushBusPropertyInfo = (~) Bool
+    type AttrBaseTypeConstraint PipelineAutoFlushBusPropertyInfo = PipelineK
+    type AttrGetType PipelineAutoFlushBusPropertyInfo = Bool
+    type AttrLabel PipelineAutoFlushBusPropertyInfo = "auto-flush-bus"
+    attrGet _ = getPipelineAutoFlushBus
+    attrSet _ = setPipelineAutoFlushBus
+    attrConstruct _ = constructPipelineAutoFlushBus
+
+-- VVV Prop "delay"
+   -- Type: TBasicType TUInt64
+   -- Flags: [PropertyReadable,PropertyWritable]
+
+getPipelineDelay :: (MonadIO m, PipelineK o) => o -> m Word64
+getPipelineDelay obj = liftIO $ getObjectPropertyUInt64 obj "delay"
+
+setPipelineDelay :: (MonadIO m, PipelineK o) => o -> Word64 -> m ()
+setPipelineDelay obj val = liftIO $ setObjectPropertyUInt64 obj "delay" val
+
+constructPipelineDelay :: Word64 -> IO ([Char], GValue)
+constructPipelineDelay val = constructObjectPropertyUInt64 "delay" val
+
+data PipelineDelayPropertyInfo
+instance AttrInfo PipelineDelayPropertyInfo where
+    type AttrAllowedOps PipelineDelayPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
+    type AttrSetTypeConstraint PipelineDelayPropertyInfo = (~) Word64
+    type AttrBaseTypeConstraint PipelineDelayPropertyInfo = PipelineK
+    type AttrGetType PipelineDelayPropertyInfo = Word64
+    type AttrLabel PipelineDelayPropertyInfo = "delay"
+    attrGet _ = getPipelineDelay
+    attrSet _ = setPipelineDelay
+    attrConstruct _ = constructPipelineDelay
+
+-- VVV Prop "latency"
+   -- Type: TBasicType TUInt64
+   -- Flags: [PropertyReadable,PropertyWritable]
+
+getPipelineLatency :: (MonadIO m, PipelineK o) => o -> m Word64
+getPipelineLatency obj = liftIO $ getObjectPropertyUInt64 obj "latency"
+
+setPipelineLatency :: (MonadIO m, PipelineK o) => o -> Word64 -> m ()
+setPipelineLatency obj val = liftIO $ setObjectPropertyUInt64 obj "latency" val
+
+constructPipelineLatency :: Word64 -> IO ([Char], GValue)
+constructPipelineLatency val = constructObjectPropertyUInt64 "latency" val
+
+data PipelineLatencyPropertyInfo
+instance AttrInfo PipelineLatencyPropertyInfo where
+    type AttrAllowedOps PipelineLatencyPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
+    type AttrSetTypeConstraint PipelineLatencyPropertyInfo = (~) Word64
+    type AttrBaseTypeConstraint PipelineLatencyPropertyInfo = PipelineK
+    type AttrGetType PipelineLatencyPropertyInfo = Word64
+    type AttrLabel PipelineLatencyPropertyInfo = "latency"
+    attrGet _ = getPipelineLatency
+    attrSet _ = setPipelineLatency
+    attrConstruct _ = constructPipelineLatency
+
+type instance AttributeList Pipeline = PipelineAttributeList
+type PipelineAttributeList = ('[ '("asyncHandling", BinAsyncHandlingPropertyInfo), '("autoFlushBus", PipelineAutoFlushBusPropertyInfo), '("delay", PipelineDelayPropertyInfo), '("latency", PipelineLatencyPropertyInfo), '("messageForward", BinMessageForwardPropertyInfo), '("name", ObjectNamePropertyInfo), '("parent", ObjectParentPropertyInfo)] :: [(Symbol, *)])
+
+type instance SignalList Pipeline = PipelineSignalList
+type PipelineSignalList = ('[ '("childAdded", ChildProxyChildAddedSignalInfo), '("childRemoved", ChildProxyChildRemovedSignalInfo), '("deepNotify", ObjectDeepNotifySignalInfo), '("doLatency", BinDoLatencySignalInfo), '("elementAdded", BinElementAddedSignalInfo), '("elementRemoved", BinElementRemovedSignalInfo), '("noMorePads", ElementNoMorePadsSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("padAdded", ElementPadAddedSignalInfo), '("padRemoved", ElementPadRemovedSignalInfo)] :: [(Symbol, *)])
+
+-- method Pipeline::new
+-- method type : Constructor
+-- Args : [Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Pipeline"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pipeline_new" gst_pipeline_new :: 
+    CString ->                              -- name : TBasicType TUTF8
+    IO (Ptr Pipeline)
+
+
+pipelineNew ::
+    (MonadIO m) =>
+    Maybe (T.Text)                          -- name
+    -> m Pipeline                           -- result
+pipelineNew name = liftIO $ do
+    maybeName <- case name of
+        Nothing -> return nullPtr
+        Just jName -> do
+            jName' <- textToCString jName
+            return jName'
+    result <- gst_pipeline_new maybeName
+    checkUnexpectedReturnNULL "gst_pipeline_new" result
+    result' <- (newObject Pipeline) result
+    freeMem maybeName
+    return result'
+
+-- method Pipeline::auto_clock
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pipeline", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pipeline_auto_clock" gst_pipeline_auto_clock :: 
+    Ptr Pipeline ->                         -- _obj : TInterface "Gst" "Pipeline"
+    IO ()
+
+
+pipelineAutoClock ::
+    (MonadIO m, PipelineK a) =>
+    a                                       -- _obj
+    -> m ()                                 -- result
+pipelineAutoClock _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    gst_pipeline_auto_clock _obj'
+    touchManagedPtr _obj
+    return ()
+
+data PipelineAutoClockMethodInfo
+instance (signature ~ (m ()), MonadIO m, PipelineK a) => MethodInfo PipelineAutoClockMethodInfo a signature where
+    overloadedMethod _ = pipelineAutoClock
+
+-- method Pipeline::get_auto_flush_bus
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pipeline", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pipeline_get_auto_flush_bus" gst_pipeline_get_auto_flush_bus :: 
+    Ptr Pipeline ->                         -- _obj : TInterface "Gst" "Pipeline"
+    IO CInt
+
+
+pipelineGetAutoFlushBus ::
+    (MonadIO m, PipelineK a) =>
+    a                                       -- _obj
+    -> m Bool                               -- result
+pipelineGetAutoFlushBus _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_pipeline_get_auto_flush_bus _obj'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data PipelineGetAutoFlushBusMethodInfo
+instance (signature ~ (m Bool), MonadIO m, PipelineK a) => MethodInfo PipelineGetAutoFlushBusMethodInfo a signature where
+    overloadedMethod _ = pipelineGetAutoFlushBus
+
+-- method Pipeline::get_bus
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pipeline", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Bus"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pipeline_get_bus" gst_pipeline_get_bus :: 
+    Ptr Pipeline ->                         -- _obj : TInterface "Gst" "Pipeline"
+    IO (Ptr Bus)
+
+
+pipelineGetBus ::
+    (MonadIO m, PipelineK a) =>
+    a                                       -- _obj
+    -> m Bus                                -- result
+pipelineGetBus _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_pipeline_get_bus _obj'
+    checkUnexpectedReturnNULL "gst_pipeline_get_bus" result
+    result' <- (wrapObject Bus) result
+    touchManagedPtr _obj
+    return result'
+
+data PipelineGetBusMethodInfo
+instance (signature ~ (m Bus), MonadIO m, PipelineK a) => MethodInfo PipelineGetBusMethodInfo a signature where
+    overloadedMethod _ = pipelineGetBus
+
+-- method Pipeline::get_delay
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pipeline", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUInt64
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pipeline_get_delay" gst_pipeline_get_delay :: 
+    Ptr Pipeline ->                         -- _obj : TInterface "Gst" "Pipeline"
+    IO Word64
+
+
+pipelineGetDelay ::
+    (MonadIO m, PipelineK a) =>
+    a                                       -- _obj
+    -> m Word64                             -- result
+pipelineGetDelay _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_pipeline_get_delay _obj'
+    touchManagedPtr _obj
+    return result
+
+data PipelineGetDelayMethodInfo
+instance (signature ~ (m Word64), MonadIO m, PipelineK a) => MethodInfo PipelineGetDelayMethodInfo a signature where
+    overloadedMethod _ = pipelineGetDelay
+
+-- method Pipeline::get_latency
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pipeline", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUInt64
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pipeline_get_latency" gst_pipeline_get_latency :: 
+    Ptr Pipeline ->                         -- _obj : TInterface "Gst" "Pipeline"
+    IO Word64
+
+
+pipelineGetLatency ::
+    (MonadIO m, PipelineK a) =>
+    a                                       -- _obj
+    -> m Word64                             -- result
+pipelineGetLatency _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_pipeline_get_latency _obj'
+    touchManagedPtr _obj
+    return result
+
+data PipelineGetLatencyMethodInfo
+instance (signature ~ (m Word64), MonadIO m, PipelineK a) => MethodInfo PipelineGetLatencyMethodInfo a signature where
+    overloadedMethod _ = pipelineGetLatency
+
+-- method Pipeline::get_pipeline_clock
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pipeline", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Clock"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pipeline_get_pipeline_clock" gst_pipeline_get_pipeline_clock :: 
+    Ptr Pipeline ->                         -- _obj : TInterface "Gst" "Pipeline"
+    IO (Ptr Clock)
+
+
+pipelineGetPipelineClock ::
+    (MonadIO m, PipelineK a) =>
+    a                                       -- _obj
+    -> m Clock                              -- result
+pipelineGetPipelineClock _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_pipeline_get_pipeline_clock _obj'
+    checkUnexpectedReturnNULL "gst_pipeline_get_pipeline_clock" result
+    result' <- (wrapObject Clock) result
+    touchManagedPtr _obj
+    return result'
+
+data PipelineGetPipelineClockMethodInfo
+instance (signature ~ (m Clock), MonadIO m, PipelineK a) => MethodInfo PipelineGetPipelineClockMethodInfo a signature where
+    overloadedMethod _ = pipelineGetPipelineClock
+
+-- method Pipeline::set_auto_flush_bus
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pipeline", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "auto_flush", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pipeline_set_auto_flush_bus" gst_pipeline_set_auto_flush_bus :: 
+    Ptr Pipeline ->                         -- _obj : TInterface "Gst" "Pipeline"
+    CInt ->                                 -- auto_flush : TBasicType TBoolean
+    IO ()
+
+
+pipelineSetAutoFlushBus ::
+    (MonadIO m, PipelineK a) =>
+    a                                       -- _obj
+    -> Bool                                 -- autoFlush
+    -> m ()                                 -- result
+pipelineSetAutoFlushBus _obj autoFlush = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let autoFlush' = (fromIntegral . fromEnum) autoFlush
+    gst_pipeline_set_auto_flush_bus _obj' autoFlush'
+    touchManagedPtr _obj
+    return ()
+
+data PipelineSetAutoFlushBusMethodInfo
+instance (signature ~ (Bool -> m ()), MonadIO m, PipelineK a) => MethodInfo PipelineSetAutoFlushBusMethodInfo a signature where
+    overloadedMethod _ = pipelineSetAutoFlushBus
+
+-- method Pipeline::set_delay
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pipeline", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "delay", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pipeline_set_delay" gst_pipeline_set_delay :: 
+    Ptr Pipeline ->                         -- _obj : TInterface "Gst" "Pipeline"
+    Word64 ->                               -- delay : TBasicType TUInt64
+    IO ()
+
+
+pipelineSetDelay ::
+    (MonadIO m, PipelineK a) =>
+    a                                       -- _obj
+    -> Word64                               -- delay
+    -> m ()                                 -- result
+pipelineSetDelay _obj delay = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    gst_pipeline_set_delay _obj' delay
+    touchManagedPtr _obj
+    return ()
+
+data PipelineSetDelayMethodInfo
+instance (signature ~ (Word64 -> m ()), MonadIO m, PipelineK a) => MethodInfo PipelineSetDelayMethodInfo a signature where
+    overloadedMethod _ = pipelineSetDelay
+
+-- method Pipeline::set_latency
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pipeline", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "latency", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pipeline_set_latency" gst_pipeline_set_latency :: 
+    Ptr Pipeline ->                         -- _obj : TInterface "Gst" "Pipeline"
+    Word64 ->                               -- latency : TBasicType TUInt64
+    IO ()
+
+
+pipelineSetLatency ::
+    (MonadIO m, PipelineK a) =>
+    a                                       -- _obj
+    -> Word64                               -- latency
+    -> m ()                                 -- result
+pipelineSetLatency _obj latency = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    gst_pipeline_set_latency _obj' latency
+    touchManagedPtr _obj
+    return ()
+
+data PipelineSetLatencyMethodInfo
+instance (signature ~ (Word64 -> m ()), MonadIO m, PipelineK a) => MethodInfo PipelineSetLatencyMethodInfo a signature where
+    overloadedMethod _ = pipelineSetLatency
+
+-- method Pipeline::use_clock
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Pipeline", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "clock", argType = TInterface "Gst" "Clock", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pipeline_use_clock" gst_pipeline_use_clock :: 
+    Ptr Pipeline ->                         -- _obj : TInterface "Gst" "Pipeline"
+    Ptr Clock ->                            -- clock : TInterface "Gst" "Clock"
+    IO ()
+
+
+pipelineUseClock ::
+    (MonadIO m, PipelineK a, ClockK b) =>
+    a                                       -- _obj
+    -> Maybe (b)                            -- clock
+    -> m ()                                 -- result
+pipelineUseClock _obj clock = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    maybeClock <- case clock of
+        Nothing -> return nullPtr
+        Just jClock -> do
+            let jClock' = unsafeManagedPtrCastPtr jClock
+            return jClock'
+    gst_pipeline_use_clock _obj' maybeClock
+    touchManagedPtr _obj
+    whenJust clock touchManagedPtr
+    return ()
+
+data PipelineUseClockMethodInfo
+instance (signature ~ (Maybe (b) -> m ()), MonadIO m, PipelineK a, ClockK b) => MethodInfo PipelineUseClockMethodInfo a signature where
+    overloadedMethod _ = pipelineUseClock
+
+
diff --git a/GI/Gst/Objects/Pipeline.hs-boot b/GI/Gst/Objects/Pipeline.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Objects/Pipeline.hs-boot
@@ -0,0 +1,26 @@
+module GI.Gst.Objects.Pipeline where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+newtype Pipeline = Pipeline (ForeignPtr Pipeline)
+instance GObject Pipeline where
+class GObject o => PipelineK o
+instance (GObject o, IsDescendantOf Pipeline o) => PipelineK o
+data PipelineAutoFlushBusPropertyInfo
+data PipelineDelayPropertyInfo
+data PipelineLatencyPropertyInfo
+data PipelineAutoClockMethodInfo
+data PipelineGetAutoFlushBusMethodInfo
+data PipelineGetBusMethodInfo
+data PipelineGetDelayMethodInfo
+data PipelineGetLatencyMethodInfo
+data PipelineGetPipelineClockMethodInfo
+data PipelineSetAutoFlushBusMethodInfo
+data PipelineSetDelayMethodInfo
+data PipelineSetLatencyMethodInfo
+data PipelineUseClockMethodInfo
diff --git a/GI/Gst/Objects/Plugin.hs b/GI/Gst/Objects/Plugin.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Objects/Plugin.hs
@@ -0,0 +1,903 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+-}
+
+module GI.Gst.Objects.Plugin
+    ( 
+
+-- * Exported types
+    Plugin(..)                              ,
+    PluginK                                 ,
+    toPlugin                                ,
+    noPlugin                                ,
+
+
+ -- * Methods
+-- ** pluginAddDependency
+    PluginAddDependencyMethodInfo           ,
+    pluginAddDependency                     ,
+
+
+-- ** pluginAddDependencySimple
+    PluginAddDependencySimpleMethodInfo     ,
+    pluginAddDependencySimple               ,
+
+
+-- ** pluginGetCacheData
+    PluginGetCacheDataMethodInfo            ,
+    pluginGetCacheData                      ,
+
+
+-- ** pluginGetDescription
+    PluginGetDescriptionMethodInfo          ,
+    pluginGetDescription                    ,
+
+
+-- ** pluginGetFilename
+    PluginGetFilenameMethodInfo             ,
+    pluginGetFilename                       ,
+
+
+-- ** pluginGetLicense
+    PluginGetLicenseMethodInfo              ,
+    pluginGetLicense                        ,
+
+
+-- ** pluginGetName
+    PluginGetNameMethodInfo                 ,
+    pluginGetName                           ,
+
+
+-- ** pluginGetOrigin
+    PluginGetOriginMethodInfo               ,
+    pluginGetOrigin                         ,
+
+
+-- ** pluginGetPackage
+    PluginGetPackageMethodInfo              ,
+    pluginGetPackage                        ,
+
+
+-- ** pluginGetReleaseDateString
+    PluginGetReleaseDateStringMethodInfo    ,
+    pluginGetReleaseDateString              ,
+
+
+-- ** pluginGetSource
+    PluginGetSourceMethodInfo               ,
+    pluginGetSource                         ,
+
+
+-- ** pluginGetVersion
+    PluginGetVersionMethodInfo              ,
+    pluginGetVersion                        ,
+
+
+-- ** pluginIsLoaded
+    PluginIsLoadedMethodInfo                ,
+    pluginIsLoaded                          ,
+
+
+-- ** pluginListFree
+    pluginListFree                          ,
+
+
+-- ** pluginLoad
+    PluginLoadMethodInfo                    ,
+    pluginLoad                              ,
+
+
+-- ** pluginLoadByName
+    pluginLoadByName                        ,
+
+
+-- ** pluginLoadFile
+    pluginLoadFile                          ,
+
+
+-- ** pluginRegisterStatic
+    pluginRegisterStatic                    ,
+
+
+-- ** pluginRegisterStaticFull
+    pluginRegisterStaticFull                ,
+
+
+-- ** pluginSetCacheData
+    PluginSetCacheDataMethodInfo            ,
+    pluginSetCacheData                      ,
+
+
+
+
+    ) where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+import GI.Gst.Callbacks
+import qualified GI.GObject as GObject
+
+newtype Plugin = Plugin (ForeignPtr Plugin)
+foreign import ccall "gst_plugin_get_type"
+    c_gst_plugin_get_type :: IO GType
+
+type instance ParentTypes Plugin = PluginParentTypes
+type PluginParentTypes = '[Object, GObject.Object]
+
+instance GObject Plugin where
+    gobjectIsInitiallyUnowned _ = True
+    gobjectType _ = c_gst_plugin_get_type
+    
+
+class GObject o => PluginK o
+instance (GObject o, IsDescendantOf Plugin o) => PluginK o
+
+toPlugin :: PluginK o => o -> IO Plugin
+toPlugin = unsafeCastTo Plugin
+
+noPlugin :: Maybe Plugin
+noPlugin = Nothing
+
+type family ResolvePluginMethod (t :: Symbol) (o :: *) :: * where
+    ResolvePluginMethod "addControlBinding" o = ObjectAddControlBindingMethodInfo
+    ResolvePluginMethod "addDependency" o = PluginAddDependencyMethodInfo
+    ResolvePluginMethod "addDependencySimple" o = PluginAddDependencySimpleMethodInfo
+    ResolvePluginMethod "bindProperty" o = GObject.ObjectBindPropertyMethodInfo
+    ResolvePluginMethod "bindPropertyFull" o = GObject.ObjectBindPropertyFullMethodInfo
+    ResolvePluginMethod "defaultError" o = ObjectDefaultErrorMethodInfo
+    ResolvePluginMethod "forceFloating" o = GObject.ObjectForceFloatingMethodInfo
+    ResolvePluginMethod "freezeNotify" o = GObject.ObjectFreezeNotifyMethodInfo
+    ResolvePluginMethod "hasActiveControlBindings" o = ObjectHasActiveControlBindingsMethodInfo
+    ResolvePluginMethod "hasAncestor" o = ObjectHasAncestorMethodInfo
+    ResolvePluginMethod "hasAsAncestor" o = ObjectHasAsAncestorMethodInfo
+    ResolvePluginMethod "hasAsParent" o = ObjectHasAsParentMethodInfo
+    ResolvePluginMethod "isFloating" o = GObject.ObjectIsFloatingMethodInfo
+    ResolvePluginMethod "isLoaded" o = PluginIsLoadedMethodInfo
+    ResolvePluginMethod "load" o = PluginLoadMethodInfo
+    ResolvePluginMethod "notify" o = GObject.ObjectNotifyMethodInfo
+    ResolvePluginMethod "notifyByPspec" o = GObject.ObjectNotifyByPspecMethodInfo
+    ResolvePluginMethod "refSink" o = GObject.ObjectRefSinkMethodInfo
+    ResolvePluginMethod "removeControlBinding" o = ObjectRemoveControlBindingMethodInfo
+    ResolvePluginMethod "replaceData" o = GObject.ObjectReplaceDataMethodInfo
+    ResolvePluginMethod "replaceQdata" o = GObject.ObjectReplaceQdataMethodInfo
+    ResolvePluginMethod "runDispose" o = GObject.ObjectRunDisposeMethodInfo
+    ResolvePluginMethod "stealData" o = GObject.ObjectStealDataMethodInfo
+    ResolvePluginMethod "stealQdata" o = GObject.ObjectStealQdataMethodInfo
+    ResolvePluginMethod "suggestNextSync" o = ObjectSuggestNextSyncMethodInfo
+    ResolvePluginMethod "syncValues" o = ObjectSyncValuesMethodInfo
+    ResolvePluginMethod "thawNotify" o = GObject.ObjectThawNotifyMethodInfo
+    ResolvePluginMethod "unparent" o = ObjectUnparentMethodInfo
+    ResolvePluginMethod "watchClosure" o = GObject.ObjectWatchClosureMethodInfo
+    ResolvePluginMethod "getCacheData" o = PluginGetCacheDataMethodInfo
+    ResolvePluginMethod "getControlBinding" o = ObjectGetControlBindingMethodInfo
+    ResolvePluginMethod "getControlRate" o = ObjectGetControlRateMethodInfo
+    ResolvePluginMethod "getData" o = GObject.ObjectGetDataMethodInfo
+    ResolvePluginMethod "getDescription" o = PluginGetDescriptionMethodInfo
+    ResolvePluginMethod "getFilename" o = PluginGetFilenameMethodInfo
+    ResolvePluginMethod "getGValueArray" o = ObjectGetGValueArrayMethodInfo
+    ResolvePluginMethod "getLicense" o = PluginGetLicenseMethodInfo
+    ResolvePluginMethod "getOrigin" o = PluginGetOriginMethodInfo
+    ResolvePluginMethod "getPackage" o = PluginGetPackageMethodInfo
+    ResolvePluginMethod "getParent" o = ObjectGetParentMethodInfo
+    ResolvePluginMethod "getPathString" o = ObjectGetPathStringMethodInfo
+    ResolvePluginMethod "getProperty" o = GObject.ObjectGetPropertyMethodInfo
+    ResolvePluginMethod "getQdata" o = GObject.ObjectGetQdataMethodInfo
+    ResolvePluginMethod "getReleaseDateString" o = PluginGetReleaseDateStringMethodInfo
+    ResolvePluginMethod "getSource" o = PluginGetSourceMethodInfo
+    ResolvePluginMethod "getValue" o = ObjectGetValueMethodInfo
+    ResolvePluginMethod "getValueArray" o = ObjectGetValueArrayMethodInfo
+    ResolvePluginMethod "getVersion" o = PluginGetVersionMethodInfo
+    ResolvePluginMethod "setCacheData" o = PluginSetCacheDataMethodInfo
+    ResolvePluginMethod "setControlBindingDisabled" o = ObjectSetControlBindingDisabledMethodInfo
+    ResolvePluginMethod "setControlBindingsDisabled" o = ObjectSetControlBindingsDisabledMethodInfo
+    ResolvePluginMethod "setControlRate" o = ObjectSetControlRateMethodInfo
+    ResolvePluginMethod "setData" o = GObject.ObjectSetDataMethodInfo
+    ResolvePluginMethod "setName" o = ObjectSetNameMethodInfo
+    ResolvePluginMethod "setParent" o = ObjectSetParentMethodInfo
+    ResolvePluginMethod "setProperty" o = GObject.ObjectSetPropertyMethodInfo
+    ResolvePluginMethod l o = MethodResolutionFailed l o
+
+instance (info ~ ResolvePluginMethod t Plugin, MethodInfo info Plugin p) => IsLabelProxy t (Plugin -> p) where
+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)
+
+#if MIN_VERSION_base(4,9,0)
+instance (info ~ ResolvePluginMethod t Plugin, MethodInfo info Plugin p) => IsLabel t (Plugin -> p) where
+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)
+#endif
+
+type instance AttributeList Plugin = PluginAttributeList
+type PluginAttributeList = ('[ '("name", ObjectNamePropertyInfo), '("parent", ObjectParentPropertyInfo)] :: [(Symbol, *)])
+
+type instance SignalList Plugin = PluginSignalList
+type PluginSignalList = ('[ '("deepNotify", ObjectDeepNotifySignalInfo), '("notify", GObject.ObjectNotifySignalInfo)] :: [(Symbol, *)])
+
+-- method Plugin::add_dependency
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Plugin", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "env_vars", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "paths", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "names", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface "Gst" "PluginDependencyFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_plugin_add_dependency" gst_plugin_add_dependency :: 
+    Ptr Plugin ->                           -- _obj : TInterface "Gst" "Plugin"
+    CString ->                              -- env_vars : TBasicType TUTF8
+    CString ->                              -- paths : TBasicType TUTF8
+    CString ->                              -- names : TBasicType TUTF8
+    CUInt ->                                -- flags : TInterface "Gst" "PluginDependencyFlags"
+    IO ()
+
+
+pluginAddDependency ::
+    (MonadIO m, PluginK a) =>
+    a                                       -- _obj
+    -> Maybe (T.Text)                       -- envVars
+    -> Maybe (T.Text)                       -- paths
+    -> Maybe (T.Text)                       -- names
+    -> [PluginDependencyFlags]              -- flags
+    -> m ()                                 -- result
+pluginAddDependency _obj envVars paths names flags = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    maybeEnvVars <- case envVars of
+        Nothing -> return nullPtr
+        Just jEnvVars -> do
+            jEnvVars' <- textToCString jEnvVars
+            return jEnvVars'
+    maybePaths <- case paths of
+        Nothing -> return nullPtr
+        Just jPaths -> do
+            jPaths' <- textToCString jPaths
+            return jPaths'
+    maybeNames <- case names of
+        Nothing -> return nullPtr
+        Just jNames -> do
+            jNames' <- textToCString jNames
+            return jNames'
+    let flags' = gflagsToWord flags
+    gst_plugin_add_dependency _obj' maybeEnvVars maybePaths maybeNames flags'
+    touchManagedPtr _obj
+    freeMem maybeEnvVars
+    freeMem maybePaths
+    freeMem maybeNames
+    return ()
+
+data PluginAddDependencyMethodInfo
+instance (signature ~ (Maybe (T.Text) -> Maybe (T.Text) -> Maybe (T.Text) -> [PluginDependencyFlags] -> m ()), MonadIO m, PluginK a) => MethodInfo PluginAddDependencyMethodInfo a signature where
+    overloadedMethod _ = pluginAddDependency
+
+-- method Plugin::add_dependency_simple
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Plugin", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "env_vars", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "paths", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "names", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface "Gst" "PluginDependencyFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_plugin_add_dependency_simple" gst_plugin_add_dependency_simple :: 
+    Ptr Plugin ->                           -- _obj : TInterface "Gst" "Plugin"
+    CString ->                              -- env_vars : TBasicType TUTF8
+    CString ->                              -- paths : TBasicType TUTF8
+    CString ->                              -- names : TBasicType TUTF8
+    CUInt ->                                -- flags : TInterface "Gst" "PluginDependencyFlags"
+    IO ()
+
+
+pluginAddDependencySimple ::
+    (MonadIO m, PluginK a) =>
+    a                                       -- _obj
+    -> Maybe (T.Text)                       -- envVars
+    -> Maybe (T.Text)                       -- paths
+    -> Maybe (T.Text)                       -- names
+    -> [PluginDependencyFlags]              -- flags
+    -> m ()                                 -- result
+pluginAddDependencySimple _obj envVars paths names flags = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    maybeEnvVars <- case envVars of
+        Nothing -> return nullPtr
+        Just jEnvVars -> do
+            jEnvVars' <- textToCString jEnvVars
+            return jEnvVars'
+    maybePaths <- case paths of
+        Nothing -> return nullPtr
+        Just jPaths -> do
+            jPaths' <- textToCString jPaths
+            return jPaths'
+    maybeNames <- case names of
+        Nothing -> return nullPtr
+        Just jNames -> do
+            jNames' <- textToCString jNames
+            return jNames'
+    let flags' = gflagsToWord flags
+    gst_plugin_add_dependency_simple _obj' maybeEnvVars maybePaths maybeNames flags'
+    touchManagedPtr _obj
+    freeMem maybeEnvVars
+    freeMem maybePaths
+    freeMem maybeNames
+    return ()
+
+data PluginAddDependencySimpleMethodInfo
+instance (signature ~ (Maybe (T.Text) -> Maybe (T.Text) -> Maybe (T.Text) -> [PluginDependencyFlags] -> m ()), MonadIO m, PluginK a) => MethodInfo PluginAddDependencySimpleMethodInfo a signature where
+    overloadedMethod _ = pluginAddDependencySimple
+
+-- method Plugin::get_cache_data
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Plugin", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Structure"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_plugin_get_cache_data" gst_plugin_get_cache_data :: 
+    Ptr Plugin ->                           -- _obj : TInterface "Gst" "Plugin"
+    IO (Ptr Structure)
+
+
+pluginGetCacheData ::
+    (MonadIO m, PluginK a) =>
+    a                                       -- _obj
+    -> m Structure                          -- result
+pluginGetCacheData _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_plugin_get_cache_data _obj'
+    checkUnexpectedReturnNULL "gst_plugin_get_cache_data" result
+    result' <- (newBoxed Structure) result
+    touchManagedPtr _obj
+    return result'
+
+data PluginGetCacheDataMethodInfo
+instance (signature ~ (m Structure), MonadIO m, PluginK a) => MethodInfo PluginGetCacheDataMethodInfo a signature where
+    overloadedMethod _ = pluginGetCacheData
+
+-- method Plugin::get_description
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Plugin", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUTF8
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_plugin_get_description" gst_plugin_get_description :: 
+    Ptr Plugin ->                           -- _obj : TInterface "Gst" "Plugin"
+    IO CString
+
+
+pluginGetDescription ::
+    (MonadIO m, PluginK a) =>
+    a                                       -- _obj
+    -> m T.Text                             -- result
+pluginGetDescription _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_plugin_get_description _obj'
+    checkUnexpectedReturnNULL "gst_plugin_get_description" result
+    result' <- cstringToText result
+    touchManagedPtr _obj
+    return result'
+
+data PluginGetDescriptionMethodInfo
+instance (signature ~ (m T.Text), MonadIO m, PluginK a) => MethodInfo PluginGetDescriptionMethodInfo a signature where
+    overloadedMethod _ = pluginGetDescription
+
+-- method Plugin::get_filename
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Plugin", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUTF8
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_plugin_get_filename" gst_plugin_get_filename :: 
+    Ptr Plugin ->                           -- _obj : TInterface "Gst" "Plugin"
+    IO CString
+
+
+pluginGetFilename ::
+    (MonadIO m, PluginK a) =>
+    a                                       -- _obj
+    -> m T.Text                             -- result
+pluginGetFilename _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_plugin_get_filename _obj'
+    checkUnexpectedReturnNULL "gst_plugin_get_filename" result
+    result' <- cstringToText result
+    touchManagedPtr _obj
+    return result'
+
+data PluginGetFilenameMethodInfo
+instance (signature ~ (m T.Text), MonadIO m, PluginK a) => MethodInfo PluginGetFilenameMethodInfo a signature where
+    overloadedMethod _ = pluginGetFilename
+
+-- method Plugin::get_license
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Plugin", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUTF8
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_plugin_get_license" gst_plugin_get_license :: 
+    Ptr Plugin ->                           -- _obj : TInterface "Gst" "Plugin"
+    IO CString
+
+
+pluginGetLicense ::
+    (MonadIO m, PluginK a) =>
+    a                                       -- _obj
+    -> m T.Text                             -- result
+pluginGetLicense _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_plugin_get_license _obj'
+    checkUnexpectedReturnNULL "gst_plugin_get_license" result
+    result' <- cstringToText result
+    touchManagedPtr _obj
+    return result'
+
+data PluginGetLicenseMethodInfo
+instance (signature ~ (m T.Text), MonadIO m, PluginK a) => MethodInfo PluginGetLicenseMethodInfo a signature where
+    overloadedMethod _ = pluginGetLicense
+
+-- method Plugin::get_name
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Plugin", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUTF8
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_plugin_get_name" gst_plugin_get_name :: 
+    Ptr Plugin ->                           -- _obj : TInterface "Gst" "Plugin"
+    IO CString
+
+
+pluginGetName ::
+    (MonadIO m, PluginK a) =>
+    a                                       -- _obj
+    -> m T.Text                             -- result
+pluginGetName _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_plugin_get_name _obj'
+    checkUnexpectedReturnNULL "gst_plugin_get_name" result
+    result' <- cstringToText result
+    touchManagedPtr _obj
+    return result'
+
+data PluginGetNameMethodInfo
+instance (signature ~ (m T.Text), MonadIO m, PluginK a) => MethodInfo PluginGetNameMethodInfo a signature where
+    overloadedMethod _ = pluginGetName
+
+-- method Plugin::get_origin
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Plugin", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUTF8
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_plugin_get_origin" gst_plugin_get_origin :: 
+    Ptr Plugin ->                           -- _obj : TInterface "Gst" "Plugin"
+    IO CString
+
+
+pluginGetOrigin ::
+    (MonadIO m, PluginK a) =>
+    a                                       -- _obj
+    -> m T.Text                             -- result
+pluginGetOrigin _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_plugin_get_origin _obj'
+    checkUnexpectedReturnNULL "gst_plugin_get_origin" result
+    result' <- cstringToText result
+    touchManagedPtr _obj
+    return result'
+
+data PluginGetOriginMethodInfo
+instance (signature ~ (m T.Text), MonadIO m, PluginK a) => MethodInfo PluginGetOriginMethodInfo a signature where
+    overloadedMethod _ = pluginGetOrigin
+
+-- method Plugin::get_package
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Plugin", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUTF8
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_plugin_get_package" gst_plugin_get_package :: 
+    Ptr Plugin ->                           -- _obj : TInterface "Gst" "Plugin"
+    IO CString
+
+
+pluginGetPackage ::
+    (MonadIO m, PluginK a) =>
+    a                                       -- _obj
+    -> m T.Text                             -- result
+pluginGetPackage _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_plugin_get_package _obj'
+    checkUnexpectedReturnNULL "gst_plugin_get_package" result
+    result' <- cstringToText result
+    touchManagedPtr _obj
+    return result'
+
+data PluginGetPackageMethodInfo
+instance (signature ~ (m T.Text), MonadIO m, PluginK a) => MethodInfo PluginGetPackageMethodInfo a signature where
+    overloadedMethod _ = pluginGetPackage
+
+-- method Plugin::get_release_date_string
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Plugin", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUTF8
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_plugin_get_release_date_string" gst_plugin_get_release_date_string :: 
+    Ptr Plugin ->                           -- _obj : TInterface "Gst" "Plugin"
+    IO CString
+
+
+pluginGetReleaseDateString ::
+    (MonadIO m, PluginK a) =>
+    a                                       -- _obj
+    -> m T.Text                             -- result
+pluginGetReleaseDateString _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_plugin_get_release_date_string _obj'
+    checkUnexpectedReturnNULL "gst_plugin_get_release_date_string" result
+    result' <- cstringToText result
+    touchManagedPtr _obj
+    return result'
+
+data PluginGetReleaseDateStringMethodInfo
+instance (signature ~ (m T.Text), MonadIO m, PluginK a) => MethodInfo PluginGetReleaseDateStringMethodInfo a signature where
+    overloadedMethod _ = pluginGetReleaseDateString
+
+-- method Plugin::get_source
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Plugin", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUTF8
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_plugin_get_source" gst_plugin_get_source :: 
+    Ptr Plugin ->                           -- _obj : TInterface "Gst" "Plugin"
+    IO CString
+
+
+pluginGetSource ::
+    (MonadIO m, PluginK a) =>
+    a                                       -- _obj
+    -> m T.Text                             -- result
+pluginGetSource _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_plugin_get_source _obj'
+    checkUnexpectedReturnNULL "gst_plugin_get_source" result
+    result' <- cstringToText result
+    touchManagedPtr _obj
+    return result'
+
+data PluginGetSourceMethodInfo
+instance (signature ~ (m T.Text), MonadIO m, PluginK a) => MethodInfo PluginGetSourceMethodInfo a signature where
+    overloadedMethod _ = pluginGetSource
+
+-- method Plugin::get_version
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Plugin", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUTF8
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_plugin_get_version" gst_plugin_get_version :: 
+    Ptr Plugin ->                           -- _obj : TInterface "Gst" "Plugin"
+    IO CString
+
+
+pluginGetVersion ::
+    (MonadIO m, PluginK a) =>
+    a                                       -- _obj
+    -> m T.Text                             -- result
+pluginGetVersion _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_plugin_get_version _obj'
+    checkUnexpectedReturnNULL "gst_plugin_get_version" result
+    result' <- cstringToText result
+    touchManagedPtr _obj
+    return result'
+
+data PluginGetVersionMethodInfo
+instance (signature ~ (m T.Text), MonadIO m, PluginK a) => MethodInfo PluginGetVersionMethodInfo a signature where
+    overloadedMethod _ = pluginGetVersion
+
+-- method Plugin::is_loaded
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Plugin", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_plugin_is_loaded" gst_plugin_is_loaded :: 
+    Ptr Plugin ->                           -- _obj : TInterface "Gst" "Plugin"
+    IO CInt
+
+
+pluginIsLoaded ::
+    (MonadIO m, PluginK a) =>
+    a                                       -- _obj
+    -> m Bool                               -- result
+pluginIsLoaded _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_plugin_is_loaded _obj'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data PluginIsLoadedMethodInfo
+instance (signature ~ (m Bool), MonadIO m, PluginK a) => MethodInfo PluginIsLoadedMethodInfo a signature where
+    overloadedMethod _ = pluginIsLoaded
+
+-- method Plugin::load
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Plugin", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Plugin"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_plugin_load" gst_plugin_load :: 
+    Ptr Plugin ->                           -- _obj : TInterface "Gst" "Plugin"
+    IO (Ptr Plugin)
+
+
+pluginLoad ::
+    (MonadIO m, PluginK a) =>
+    a                                       -- _obj
+    -> m Plugin                             -- result
+pluginLoad _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_plugin_load _obj'
+    checkUnexpectedReturnNULL "gst_plugin_load" result
+    result' <- (wrapObject Plugin) result
+    touchManagedPtr _obj
+    return result'
+
+data PluginLoadMethodInfo
+instance (signature ~ (m Plugin), MonadIO m, PluginK a) => MethodInfo PluginLoadMethodInfo a signature where
+    overloadedMethod _ = pluginLoad
+
+-- method Plugin::set_cache_data
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Plugin", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cache_data", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_plugin_set_cache_data" gst_plugin_set_cache_data :: 
+    Ptr Plugin ->                           -- _obj : TInterface "Gst" "Plugin"
+    Ptr Structure ->                        -- cache_data : TInterface "Gst" "Structure"
+    IO ()
+
+
+pluginSetCacheData ::
+    (MonadIO m, PluginK a) =>
+    a                                       -- _obj
+    -> Structure                            -- cacheData
+    -> m ()                                 -- result
+pluginSetCacheData _obj cacheData = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    cacheData' <- copyBoxed cacheData
+    gst_plugin_set_cache_data _obj' cacheData'
+    touchManagedPtr _obj
+    touchManagedPtr cacheData
+    return ()
+
+data PluginSetCacheDataMethodInfo
+instance (signature ~ (Structure -> m ()), MonadIO m, PluginK a) => MethodInfo PluginSetCacheDataMethodInfo a signature where
+    overloadedMethod _ = pluginSetCacheData
+
+-- method Plugin::list_free
+-- method type : MemberFunction
+-- Args : [Arg {argCName = "list", argType = TGList (TInterface "Gst" "Plugin"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_plugin_list_free" gst_plugin_list_free :: 
+    Ptr (GList (Ptr Plugin)) ->             -- list : TGList (TInterface "Gst" "Plugin")
+    IO ()
+
+
+pluginListFree ::
+    (MonadIO m, PluginK a) =>
+    [a]                                     -- list
+    -> m ()                                 -- result
+pluginListFree list = liftIO $ do
+    list' <- mapM refObject list
+    list'' <- packGList list'
+    gst_plugin_list_free list''
+    mapM_ touchManagedPtr list
+    return ()
+
+-- method Plugin::load_by_name
+-- method type : MemberFunction
+-- Args : [Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Plugin"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_plugin_load_by_name" gst_plugin_load_by_name :: 
+    CString ->                              -- name : TBasicType TUTF8
+    IO (Ptr Plugin)
+
+
+pluginLoadByName ::
+    (MonadIO m) =>
+    T.Text                                  -- name
+    -> m Plugin                             -- result
+pluginLoadByName name = liftIO $ do
+    name' <- textToCString name
+    result <- gst_plugin_load_by_name name'
+    checkUnexpectedReturnNULL "gst_plugin_load_by_name" result
+    result' <- (wrapObject Plugin) result
+    freeMem name'
+    return result'
+
+-- method Plugin::load_file
+-- method type : MemberFunction
+-- Args : [Arg {argCName = "filename", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Plugin"
+-- throws : True
+-- Skip return : False
+
+foreign import ccall "gst_plugin_load_file" gst_plugin_load_file :: 
+    CString ->                              -- filename : TBasicType TUTF8
+    Ptr (Ptr GError) ->                     -- error
+    IO (Ptr Plugin)
+
+
+pluginLoadFile ::
+    (MonadIO m) =>
+    T.Text                                  -- filename
+    -> m Plugin                             -- result
+pluginLoadFile filename = liftIO $ do
+    filename' <- textToCString filename
+    onException (do
+        result <- propagateGError $ gst_plugin_load_file filename'
+        checkUnexpectedReturnNULL "gst_plugin_load_file" result
+        result' <- (wrapObject Plugin) result
+        freeMem filename'
+        return result'
+     ) (do
+        freeMem filename'
+     )
+
+-- method Plugin::register_static
+-- method type : MemberFunction
+-- Args : [Arg {argCName = "major_version", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "minor_version", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "description", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "init_func", argType = TInterface "Gst" "PluginInitFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "version", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "license", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "source", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "package", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "origin", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_plugin_register_static" gst_plugin_register_static :: 
+    Int32 ->                                -- major_version : TBasicType TInt32
+    Int32 ->                                -- minor_version : TBasicType TInt32
+    CString ->                              -- name : TBasicType TUTF8
+    CString ->                              -- description : TBasicType TUTF8
+    FunPtr PluginInitFuncC ->               -- init_func : TInterface "Gst" "PluginInitFunc"
+    CString ->                              -- version : TBasicType TUTF8
+    CString ->                              -- license : TBasicType TUTF8
+    CString ->                              -- source : TBasicType TUTF8
+    CString ->                              -- package : TBasicType TUTF8
+    CString ->                              -- origin : TBasicType TUTF8
+    IO CInt
+
+
+pluginRegisterStatic ::
+    (MonadIO m) =>
+    Int32                                   -- majorVersion
+    -> Int32                                -- minorVersion
+    -> T.Text                               -- name
+    -> T.Text                               -- description
+    -> PluginInitFunc                       -- initFunc
+    -> T.Text                               -- version
+    -> T.Text                               -- license
+    -> T.Text                               -- source
+    -> T.Text                               -- package
+    -> T.Text                               -- origin
+    -> m Bool                               -- result
+pluginRegisterStatic majorVersion minorVersion name description initFunc version license source package origin = liftIO $ do
+    name' <- textToCString name
+    description' <- textToCString description
+    initFunc' <- mkPluginInitFunc (pluginInitFuncWrapper Nothing initFunc)
+    version' <- textToCString version
+    license' <- textToCString license
+    source' <- textToCString source
+    package' <- textToCString package
+    origin' <- textToCString origin
+    result <- gst_plugin_register_static majorVersion minorVersion name' description' initFunc' version' license' source' package' origin'
+    let result' = (/= 0) result
+    safeFreeFunPtr $ castFunPtrToPtr initFunc'
+    freeMem name'
+    freeMem description'
+    freeMem version'
+    freeMem license'
+    freeMem source'
+    freeMem package'
+    freeMem origin'
+    return result'
+
+-- method Plugin::register_static_full
+-- method type : MemberFunction
+-- Args : [Arg {argCName = "major_version", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "minor_version", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "description", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "init_full_func", argType = TInterface "Gst" "PluginInitFullFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, argClosure = 10, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "version", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "license", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "source", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "package", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "origin", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_plugin_register_static_full" gst_plugin_register_static_full :: 
+    Int32 ->                                -- major_version : TBasicType TInt32
+    Int32 ->                                -- minor_version : TBasicType TInt32
+    CString ->                              -- name : TBasicType TUTF8
+    CString ->                              -- description : TBasicType TUTF8
+    FunPtr PluginInitFullFuncC ->           -- init_full_func : TInterface "Gst" "PluginInitFullFunc"
+    CString ->                              -- version : TBasicType TUTF8
+    CString ->                              -- license : TBasicType TUTF8
+    CString ->                              -- source : TBasicType TUTF8
+    CString ->                              -- package : TBasicType TUTF8
+    CString ->                              -- origin : TBasicType TUTF8
+    Ptr () ->                               -- user_data : TBasicType TVoid
+    IO CInt
+
+
+pluginRegisterStaticFull ::
+    (MonadIO m) =>
+    Int32                                   -- majorVersion
+    -> Int32                                -- minorVersion
+    -> T.Text                               -- name
+    -> T.Text                               -- description
+    -> PluginInitFullFunc                   -- initFullFunc
+    -> T.Text                               -- version
+    -> T.Text                               -- license
+    -> T.Text                               -- source
+    -> T.Text                               -- package
+    -> T.Text                               -- origin
+    -> m Bool                               -- result
+pluginRegisterStaticFull majorVersion minorVersion name description initFullFunc version license source package origin = liftIO $ do
+    name' <- textToCString name
+    description' <- textToCString description
+    initFullFunc' <- mkPluginInitFullFunc (pluginInitFullFuncWrapper Nothing initFullFunc)
+    version' <- textToCString version
+    license' <- textToCString license
+    source' <- textToCString source
+    package' <- textToCString package
+    origin' <- textToCString origin
+    let userData = nullPtr
+    result <- gst_plugin_register_static_full majorVersion minorVersion name' description' initFullFunc' version' license' source' package' origin' userData
+    let result' = (/= 0) result
+    safeFreeFunPtr $ castFunPtrToPtr initFullFunc'
+    freeMem name'
+    freeMem description'
+    freeMem version'
+    freeMem license'
+    freeMem source'
+    freeMem package'
+    freeMem origin'
+    return result'
+
+
diff --git a/GI/Gst/Objects/Plugin.hs-boot b/GI/Gst/Objects/Plugin.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Objects/Plugin.hs-boot
@@ -0,0 +1,28 @@
+module GI.Gst.Objects.Plugin where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+newtype Plugin = Plugin (ForeignPtr Plugin)
+instance GObject Plugin where
+class GObject o => PluginK o
+instance (GObject o, IsDescendantOf Plugin o) => PluginK o
+data PluginAddDependencyMethodInfo
+data PluginAddDependencySimpleMethodInfo
+data PluginGetCacheDataMethodInfo
+data PluginGetDescriptionMethodInfo
+data PluginGetFilenameMethodInfo
+data PluginGetLicenseMethodInfo
+data PluginGetNameMethodInfo
+data PluginGetOriginMethodInfo
+data PluginGetPackageMethodInfo
+data PluginGetReleaseDateStringMethodInfo
+data PluginGetSourceMethodInfo
+data PluginGetVersionMethodInfo
+data PluginIsLoadedMethodInfo
+data PluginLoadMethodInfo
+data PluginSetCacheDataMethodInfo
diff --git a/GI/Gst/Objects/PluginFeature.hs b/GI/Gst/Objects/PluginFeature.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Objects/PluginFeature.hs
@@ -0,0 +1,446 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+-}
+
+module GI.Gst.Objects.PluginFeature
+    ( 
+
+-- * Exported types
+    PluginFeature(..)                       ,
+    PluginFeatureK                          ,
+    toPluginFeature                         ,
+    noPluginFeature                         ,
+
+
+ -- * Methods
+-- ** pluginFeatureCheckVersion
+    PluginFeatureCheckVersionMethodInfo     ,
+    pluginFeatureCheckVersion               ,
+
+
+-- ** pluginFeatureGetPlugin
+    PluginFeatureGetPluginMethodInfo        ,
+    pluginFeatureGetPlugin                  ,
+
+
+-- ** pluginFeatureGetPluginName
+    PluginFeatureGetPluginNameMethodInfo    ,
+    pluginFeatureGetPluginName              ,
+
+
+-- ** pluginFeatureGetRank
+    PluginFeatureGetRankMethodInfo          ,
+    pluginFeatureGetRank                    ,
+
+
+-- ** pluginFeatureListCopy
+    pluginFeatureListCopy                   ,
+
+
+-- ** pluginFeatureListDebug
+    pluginFeatureListDebug                  ,
+
+
+-- ** pluginFeatureListFree
+    pluginFeatureListFree                   ,
+
+
+-- ** pluginFeatureLoad
+    PluginFeatureLoadMethodInfo             ,
+    pluginFeatureLoad                       ,
+
+
+-- ** pluginFeatureRankCompareFunc
+    pluginFeatureRankCompareFunc            ,
+
+
+-- ** pluginFeatureSetRank
+    PluginFeatureSetRankMethodInfo          ,
+    pluginFeatureSetRank                    ,
+
+
+
+
+    ) where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+import GI.Gst.Callbacks
+import qualified GI.GObject as GObject
+
+newtype PluginFeature = PluginFeature (ForeignPtr PluginFeature)
+foreign import ccall "gst_plugin_feature_get_type"
+    c_gst_plugin_feature_get_type :: IO GType
+
+type instance ParentTypes PluginFeature = PluginFeatureParentTypes
+type PluginFeatureParentTypes = '[Object, GObject.Object]
+
+instance GObject PluginFeature where
+    gobjectIsInitiallyUnowned _ = True
+    gobjectType _ = c_gst_plugin_feature_get_type
+    
+
+class GObject o => PluginFeatureK o
+instance (GObject o, IsDescendantOf PluginFeature o) => PluginFeatureK o
+
+toPluginFeature :: PluginFeatureK o => o -> IO PluginFeature
+toPluginFeature = unsafeCastTo PluginFeature
+
+noPluginFeature :: Maybe PluginFeature
+noPluginFeature = Nothing
+
+type family ResolvePluginFeatureMethod (t :: Symbol) (o :: *) :: * where
+    ResolvePluginFeatureMethod "addControlBinding" o = ObjectAddControlBindingMethodInfo
+    ResolvePluginFeatureMethod "bindProperty" o = GObject.ObjectBindPropertyMethodInfo
+    ResolvePluginFeatureMethod "bindPropertyFull" o = GObject.ObjectBindPropertyFullMethodInfo
+    ResolvePluginFeatureMethod "checkVersion" o = PluginFeatureCheckVersionMethodInfo
+    ResolvePluginFeatureMethod "defaultError" o = ObjectDefaultErrorMethodInfo
+    ResolvePluginFeatureMethod "forceFloating" o = GObject.ObjectForceFloatingMethodInfo
+    ResolvePluginFeatureMethod "freezeNotify" o = GObject.ObjectFreezeNotifyMethodInfo
+    ResolvePluginFeatureMethod "hasActiveControlBindings" o = ObjectHasActiveControlBindingsMethodInfo
+    ResolvePluginFeatureMethod "hasAncestor" o = ObjectHasAncestorMethodInfo
+    ResolvePluginFeatureMethod "hasAsAncestor" o = ObjectHasAsAncestorMethodInfo
+    ResolvePluginFeatureMethod "hasAsParent" o = ObjectHasAsParentMethodInfo
+    ResolvePluginFeatureMethod "isFloating" o = GObject.ObjectIsFloatingMethodInfo
+    ResolvePluginFeatureMethod "load" o = PluginFeatureLoadMethodInfo
+    ResolvePluginFeatureMethod "notify" o = GObject.ObjectNotifyMethodInfo
+    ResolvePluginFeatureMethod "notifyByPspec" o = GObject.ObjectNotifyByPspecMethodInfo
+    ResolvePluginFeatureMethod "refSink" o = GObject.ObjectRefSinkMethodInfo
+    ResolvePluginFeatureMethod "removeControlBinding" o = ObjectRemoveControlBindingMethodInfo
+    ResolvePluginFeatureMethod "replaceData" o = GObject.ObjectReplaceDataMethodInfo
+    ResolvePluginFeatureMethod "replaceQdata" o = GObject.ObjectReplaceQdataMethodInfo
+    ResolvePluginFeatureMethod "runDispose" o = GObject.ObjectRunDisposeMethodInfo
+    ResolvePluginFeatureMethod "stealData" o = GObject.ObjectStealDataMethodInfo
+    ResolvePluginFeatureMethod "stealQdata" o = GObject.ObjectStealQdataMethodInfo
+    ResolvePluginFeatureMethod "suggestNextSync" o = ObjectSuggestNextSyncMethodInfo
+    ResolvePluginFeatureMethod "syncValues" o = ObjectSyncValuesMethodInfo
+    ResolvePluginFeatureMethod "thawNotify" o = GObject.ObjectThawNotifyMethodInfo
+    ResolvePluginFeatureMethod "unparent" o = ObjectUnparentMethodInfo
+    ResolvePluginFeatureMethod "watchClosure" o = GObject.ObjectWatchClosureMethodInfo
+    ResolvePluginFeatureMethod "getControlBinding" o = ObjectGetControlBindingMethodInfo
+    ResolvePluginFeatureMethod "getControlRate" o = ObjectGetControlRateMethodInfo
+    ResolvePluginFeatureMethod "getData" o = GObject.ObjectGetDataMethodInfo
+    ResolvePluginFeatureMethod "getGValueArray" o = ObjectGetGValueArrayMethodInfo
+    ResolvePluginFeatureMethod "getName" o = ObjectGetNameMethodInfo
+    ResolvePluginFeatureMethod "getParent" o = ObjectGetParentMethodInfo
+    ResolvePluginFeatureMethod "getPathString" o = ObjectGetPathStringMethodInfo
+    ResolvePluginFeatureMethod "getPlugin" o = PluginFeatureGetPluginMethodInfo
+    ResolvePluginFeatureMethod "getPluginName" o = PluginFeatureGetPluginNameMethodInfo
+    ResolvePluginFeatureMethod "getProperty" o = GObject.ObjectGetPropertyMethodInfo
+    ResolvePluginFeatureMethod "getQdata" o = GObject.ObjectGetQdataMethodInfo
+    ResolvePluginFeatureMethod "getRank" o = PluginFeatureGetRankMethodInfo
+    ResolvePluginFeatureMethod "getValue" o = ObjectGetValueMethodInfo
+    ResolvePluginFeatureMethod "getValueArray" o = ObjectGetValueArrayMethodInfo
+    ResolvePluginFeatureMethod "setControlBindingDisabled" o = ObjectSetControlBindingDisabledMethodInfo
+    ResolvePluginFeatureMethod "setControlBindingsDisabled" o = ObjectSetControlBindingsDisabledMethodInfo
+    ResolvePluginFeatureMethod "setControlRate" o = ObjectSetControlRateMethodInfo
+    ResolvePluginFeatureMethod "setData" o = GObject.ObjectSetDataMethodInfo
+    ResolvePluginFeatureMethod "setName" o = ObjectSetNameMethodInfo
+    ResolvePluginFeatureMethod "setParent" o = ObjectSetParentMethodInfo
+    ResolvePluginFeatureMethod "setProperty" o = GObject.ObjectSetPropertyMethodInfo
+    ResolvePluginFeatureMethod "setRank" o = PluginFeatureSetRankMethodInfo
+    ResolvePluginFeatureMethod l o = MethodResolutionFailed l o
+
+instance (info ~ ResolvePluginFeatureMethod t PluginFeature, MethodInfo info PluginFeature p) => IsLabelProxy t (PluginFeature -> p) where
+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)
+
+#if MIN_VERSION_base(4,9,0)
+instance (info ~ ResolvePluginFeatureMethod t PluginFeature, MethodInfo info PluginFeature p) => IsLabel t (PluginFeature -> p) where
+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)
+#endif
+
+type instance AttributeList PluginFeature = PluginFeatureAttributeList
+type PluginFeatureAttributeList = ('[ '("name", ObjectNamePropertyInfo), '("parent", ObjectParentPropertyInfo)] :: [(Symbol, *)])
+
+type instance SignalList PluginFeature = PluginFeatureSignalList
+type PluginFeatureSignalList = ('[ '("deepNotify", ObjectDeepNotifySignalInfo), '("notify", GObject.ObjectNotifySignalInfo)] :: [(Symbol, *)])
+
+-- method PluginFeature::check_version
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "PluginFeature", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "min_major", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "min_minor", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "min_micro", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_plugin_feature_check_version" gst_plugin_feature_check_version :: 
+    Ptr PluginFeature ->                    -- _obj : TInterface "Gst" "PluginFeature"
+    Word32 ->                               -- min_major : TBasicType TUInt32
+    Word32 ->                               -- min_minor : TBasicType TUInt32
+    Word32 ->                               -- min_micro : TBasicType TUInt32
+    IO CInt
+
+
+pluginFeatureCheckVersion ::
+    (MonadIO m, PluginFeatureK a) =>
+    a                                       -- _obj
+    -> Word32                               -- minMajor
+    -> Word32                               -- minMinor
+    -> Word32                               -- minMicro
+    -> m Bool                               -- result
+pluginFeatureCheckVersion _obj minMajor minMinor minMicro = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_plugin_feature_check_version _obj' minMajor minMinor minMicro
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data PluginFeatureCheckVersionMethodInfo
+instance (signature ~ (Word32 -> Word32 -> Word32 -> m Bool), MonadIO m, PluginFeatureK a) => MethodInfo PluginFeatureCheckVersionMethodInfo a signature where
+    overloadedMethod _ = pluginFeatureCheckVersion
+
+-- method PluginFeature::get_plugin
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "PluginFeature", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Plugin"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_plugin_feature_get_plugin" gst_plugin_feature_get_plugin :: 
+    Ptr PluginFeature ->                    -- _obj : TInterface "Gst" "PluginFeature"
+    IO (Ptr Plugin)
+
+
+pluginFeatureGetPlugin ::
+    (MonadIO m, PluginFeatureK a) =>
+    a                                       -- _obj
+    -> m Plugin                             -- result
+pluginFeatureGetPlugin _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_plugin_feature_get_plugin _obj'
+    checkUnexpectedReturnNULL "gst_plugin_feature_get_plugin" result
+    result' <- (wrapObject Plugin) result
+    touchManagedPtr _obj
+    return result'
+
+data PluginFeatureGetPluginMethodInfo
+instance (signature ~ (m Plugin), MonadIO m, PluginFeatureK a) => MethodInfo PluginFeatureGetPluginMethodInfo a signature where
+    overloadedMethod _ = pluginFeatureGetPlugin
+
+-- method PluginFeature::get_plugin_name
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "PluginFeature", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUTF8
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_plugin_feature_get_plugin_name" gst_plugin_feature_get_plugin_name :: 
+    Ptr PluginFeature ->                    -- _obj : TInterface "Gst" "PluginFeature"
+    IO CString
+
+
+pluginFeatureGetPluginName ::
+    (MonadIO m, PluginFeatureK a) =>
+    a                                       -- _obj
+    -> m T.Text                             -- result
+pluginFeatureGetPluginName _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_plugin_feature_get_plugin_name _obj'
+    checkUnexpectedReturnNULL "gst_plugin_feature_get_plugin_name" result
+    result' <- cstringToText result
+    touchManagedPtr _obj
+    return result'
+
+data PluginFeatureGetPluginNameMethodInfo
+instance (signature ~ (m T.Text), MonadIO m, PluginFeatureK a) => MethodInfo PluginFeatureGetPluginNameMethodInfo a signature where
+    overloadedMethod _ = pluginFeatureGetPluginName
+
+-- method PluginFeature::get_rank
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "PluginFeature", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUInt32
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_plugin_feature_get_rank" gst_plugin_feature_get_rank :: 
+    Ptr PluginFeature ->                    -- _obj : TInterface "Gst" "PluginFeature"
+    IO Word32
+
+
+pluginFeatureGetRank ::
+    (MonadIO m, PluginFeatureK a) =>
+    a                                       -- _obj
+    -> m Word32                             -- result
+pluginFeatureGetRank _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_plugin_feature_get_rank _obj'
+    touchManagedPtr _obj
+    return result
+
+data PluginFeatureGetRankMethodInfo
+instance (signature ~ (m Word32), MonadIO m, PluginFeatureK a) => MethodInfo PluginFeatureGetRankMethodInfo a signature where
+    overloadedMethod _ = pluginFeatureGetRank
+
+-- method PluginFeature::load
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "PluginFeature", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "PluginFeature"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_plugin_feature_load" gst_plugin_feature_load :: 
+    Ptr PluginFeature ->                    -- _obj : TInterface "Gst" "PluginFeature"
+    IO (Ptr PluginFeature)
+
+
+pluginFeatureLoad ::
+    (MonadIO m, PluginFeatureK a) =>
+    a                                       -- _obj
+    -> m PluginFeature                      -- result
+pluginFeatureLoad _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_plugin_feature_load _obj'
+    checkUnexpectedReturnNULL "gst_plugin_feature_load" result
+    result' <- (wrapObject PluginFeature) result
+    touchManagedPtr _obj
+    return result'
+
+data PluginFeatureLoadMethodInfo
+instance (signature ~ (m PluginFeature), MonadIO m, PluginFeatureK a) => MethodInfo PluginFeatureLoadMethodInfo a signature where
+    overloadedMethod _ = pluginFeatureLoad
+
+-- method PluginFeature::set_rank
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "PluginFeature", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "rank", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_plugin_feature_set_rank" gst_plugin_feature_set_rank :: 
+    Ptr PluginFeature ->                    -- _obj : TInterface "Gst" "PluginFeature"
+    Word32 ->                               -- rank : TBasicType TUInt32
+    IO ()
+
+
+pluginFeatureSetRank ::
+    (MonadIO m, PluginFeatureK a) =>
+    a                                       -- _obj
+    -> Word32                               -- rank
+    -> m ()                                 -- result
+pluginFeatureSetRank _obj rank = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    gst_plugin_feature_set_rank _obj' rank
+    touchManagedPtr _obj
+    return ()
+
+data PluginFeatureSetRankMethodInfo
+instance (signature ~ (Word32 -> m ()), MonadIO m, PluginFeatureK a) => MethodInfo PluginFeatureSetRankMethodInfo a signature where
+    overloadedMethod _ = pluginFeatureSetRank
+
+-- method PluginFeature::list_copy
+-- method type : MemberFunction
+-- Args : [Arg {argCName = "list", argType = TGList (TInterface "Gst" "PluginFeature"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TGList (TInterface "Gst" "PluginFeature")
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_plugin_feature_list_copy" gst_plugin_feature_list_copy :: 
+    Ptr (GList (Ptr PluginFeature)) ->      -- list : TGList (TInterface "Gst" "PluginFeature")
+    IO (Ptr (GList (Ptr PluginFeature)))
+
+
+pluginFeatureListCopy ::
+    (MonadIO m, PluginFeatureK a) =>
+    [a]                                     -- list
+    -> m [PluginFeature]                    -- result
+pluginFeatureListCopy list = liftIO $ do
+    let list' = map unsafeManagedPtrCastPtr list
+    list'' <- packGList list'
+    result <- gst_plugin_feature_list_copy list''
+    checkUnexpectedReturnNULL "gst_plugin_feature_list_copy" result
+    result' <- unpackGList result
+    result'' <- mapM (wrapObject PluginFeature) result'
+    g_list_free result
+    mapM_ touchManagedPtr list
+    g_list_free list''
+    return result''
+
+-- method PluginFeature::list_debug
+-- method type : MemberFunction
+-- Args : [Arg {argCName = "list", argType = TGList (TInterface "Gst" "PluginFeature"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_plugin_feature_list_debug" gst_plugin_feature_list_debug :: 
+    Ptr (GList (Ptr PluginFeature)) ->      -- list : TGList (TInterface "Gst" "PluginFeature")
+    IO ()
+
+
+pluginFeatureListDebug ::
+    (MonadIO m, PluginFeatureK a) =>
+    [a]                                     -- list
+    -> m ()                                 -- result
+pluginFeatureListDebug list = liftIO $ do
+    let list' = map unsafeManagedPtrCastPtr list
+    list'' <- packGList list'
+    gst_plugin_feature_list_debug list''
+    mapM_ touchManagedPtr list
+    g_list_free list''
+    return ()
+
+-- method PluginFeature::list_free
+-- method type : MemberFunction
+-- Args : [Arg {argCName = "list", argType = TGList (TInterface "Gst" "PluginFeature"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_plugin_feature_list_free" gst_plugin_feature_list_free :: 
+    Ptr (GList (Ptr PluginFeature)) ->      -- list : TGList (TInterface "Gst" "PluginFeature")
+    IO ()
+
+
+pluginFeatureListFree ::
+    (MonadIO m, PluginFeatureK a) =>
+    [a]                                     -- list
+    -> m ()                                 -- result
+pluginFeatureListFree list = liftIO $ do
+    list' <- mapM refObject list
+    list'' <- packGList list'
+    gst_plugin_feature_list_free list''
+    mapM_ touchManagedPtr list
+    return ()
+
+-- method PluginFeature::rank_compare_func
+-- method type : MemberFunction
+-- Args : [Arg {argCName = "p1", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "p2", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TInt32
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_plugin_feature_rank_compare_func" gst_plugin_feature_rank_compare_func :: 
+    Ptr () ->                               -- p1 : TBasicType TVoid
+    Ptr () ->                               -- p2 : TBasicType TVoid
+    IO Int32
+
+
+pluginFeatureRankCompareFunc ::
+    (MonadIO m) =>
+    Ptr ()                                  -- p1
+    -> Ptr ()                               -- p2
+    -> m Int32                              -- result
+pluginFeatureRankCompareFunc p1 p2 = liftIO $ do
+    result <- gst_plugin_feature_rank_compare_func p1 p2
+    return result
+
+
diff --git a/GI/Gst/Objects/PluginFeature.hs-boot b/GI/Gst/Objects/PluginFeature.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Objects/PluginFeature.hs-boot
@@ -0,0 +1,19 @@
+module GI.Gst.Objects.PluginFeature where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+newtype PluginFeature = PluginFeature (ForeignPtr PluginFeature)
+instance GObject PluginFeature where
+class GObject o => PluginFeatureK o
+instance (GObject o, IsDescendantOf PluginFeature o) => PluginFeatureK o
+data PluginFeatureCheckVersionMethodInfo
+data PluginFeatureGetPluginMethodInfo
+data PluginFeatureGetPluginNameMethodInfo
+data PluginFeatureGetRankMethodInfo
+data PluginFeatureLoadMethodInfo
+data PluginFeatureSetRankMethodInfo
diff --git a/GI/Gst/Objects/ProxyPad.hs b/GI/Gst/Objects/ProxyPad.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Objects/ProxyPad.hs
@@ -0,0 +1,380 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+-}
+
+module GI.Gst.Objects.ProxyPad
+    ( 
+
+-- * Exported types
+    ProxyPad(..)                            ,
+    ProxyPadK                               ,
+    toProxyPad                              ,
+    noProxyPad                              ,
+
+
+ -- * Methods
+-- ** proxyPadChainDefault
+    proxyPadChainDefault                    ,
+
+
+-- ** proxyPadChainListDefault
+    proxyPadChainListDefault                ,
+
+
+-- ** proxyPadGetInternal
+    ProxyPadGetInternalMethodInfo           ,
+    proxyPadGetInternal                     ,
+
+
+-- ** proxyPadGetrangeDefault
+    proxyPadGetrangeDefault                 ,
+
+
+-- ** proxyPadIterateInternalLinksDefault
+    proxyPadIterateInternalLinksDefault     ,
+
+
+
+
+    ) where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+import GI.Gst.Callbacks
+import qualified GI.GObject as GObject
+
+newtype ProxyPad = ProxyPad (ForeignPtr ProxyPad)
+foreign import ccall "gst_proxy_pad_get_type"
+    c_gst_proxy_pad_get_type :: IO GType
+
+type instance ParentTypes ProxyPad = ProxyPadParentTypes
+type ProxyPadParentTypes = '[Pad, Object, GObject.Object]
+
+instance GObject ProxyPad where
+    gobjectIsInitiallyUnowned _ = True
+    gobjectType _ = c_gst_proxy_pad_get_type
+    
+
+class GObject o => ProxyPadK o
+instance (GObject o, IsDescendantOf ProxyPad o) => ProxyPadK o
+
+toProxyPad :: ProxyPadK o => o -> IO ProxyPad
+toProxyPad = unsafeCastTo ProxyPad
+
+noProxyPad :: Maybe ProxyPad
+noProxyPad = Nothing
+
+type family ResolveProxyPadMethod (t :: Symbol) (o :: *) :: * where
+    ResolveProxyPadMethod "activateMode" o = PadActivateModeMethodInfo
+    ResolveProxyPadMethod "addControlBinding" o = ObjectAddControlBindingMethodInfo
+    ResolveProxyPadMethod "addProbe" o = PadAddProbeMethodInfo
+    ResolveProxyPadMethod "bindProperty" o = GObject.ObjectBindPropertyMethodInfo
+    ResolveProxyPadMethod "bindPropertyFull" o = GObject.ObjectBindPropertyFullMethodInfo
+    ResolveProxyPadMethod "canLink" o = PadCanLinkMethodInfo
+    ResolveProxyPadMethod "chain" o = PadChainMethodInfo
+    ResolveProxyPadMethod "chainList" o = PadChainListMethodInfo
+    ResolveProxyPadMethod "checkReconfigure" o = PadCheckReconfigureMethodInfo
+    ResolveProxyPadMethod "createStreamId" o = PadCreateStreamIdMethodInfo
+    ResolveProxyPadMethod "defaultError" o = ObjectDefaultErrorMethodInfo
+    ResolveProxyPadMethod "eventDefault" o = PadEventDefaultMethodInfo
+    ResolveProxyPadMethod "forceFloating" o = GObject.ObjectForceFloatingMethodInfo
+    ResolveProxyPadMethod "forward" o = PadForwardMethodInfo
+    ResolveProxyPadMethod "freezeNotify" o = GObject.ObjectFreezeNotifyMethodInfo
+    ResolveProxyPadMethod "hasActiveControlBindings" o = ObjectHasActiveControlBindingsMethodInfo
+    ResolveProxyPadMethod "hasAncestor" o = ObjectHasAncestorMethodInfo
+    ResolveProxyPadMethod "hasAsAncestor" o = ObjectHasAsAncestorMethodInfo
+    ResolveProxyPadMethod "hasAsParent" o = ObjectHasAsParentMethodInfo
+    ResolveProxyPadMethod "hasCurrentCaps" o = PadHasCurrentCapsMethodInfo
+    ResolveProxyPadMethod "isActive" o = PadIsActiveMethodInfo
+    ResolveProxyPadMethod "isBlocked" o = PadIsBlockedMethodInfo
+    ResolveProxyPadMethod "isBlocking" o = PadIsBlockingMethodInfo
+    ResolveProxyPadMethod "isFloating" o = GObject.ObjectIsFloatingMethodInfo
+    ResolveProxyPadMethod "isLinked" o = PadIsLinkedMethodInfo
+    ResolveProxyPadMethod "iterateInternalLinks" o = PadIterateInternalLinksMethodInfo
+    ResolveProxyPadMethod "link" o = PadLinkMethodInfo
+    ResolveProxyPadMethod "linkFull" o = PadLinkFullMethodInfo
+    ResolveProxyPadMethod "markReconfigure" o = PadMarkReconfigureMethodInfo
+    ResolveProxyPadMethod "needsReconfigure" o = PadNeedsReconfigureMethodInfo
+    ResolveProxyPadMethod "notify" o = GObject.ObjectNotifyMethodInfo
+    ResolveProxyPadMethod "notifyByPspec" o = GObject.ObjectNotifyByPspecMethodInfo
+    ResolveProxyPadMethod "pauseTask" o = PadPauseTaskMethodInfo
+    ResolveProxyPadMethod "peerQuery" o = PadPeerQueryMethodInfo
+    ResolveProxyPadMethod "peerQueryAcceptCaps" o = PadPeerQueryAcceptCapsMethodInfo
+    ResolveProxyPadMethod "peerQueryCaps" o = PadPeerQueryCapsMethodInfo
+    ResolveProxyPadMethod "peerQueryConvert" o = PadPeerQueryConvertMethodInfo
+    ResolveProxyPadMethod "peerQueryDuration" o = PadPeerQueryDurationMethodInfo
+    ResolveProxyPadMethod "peerQueryPosition" o = PadPeerQueryPositionMethodInfo
+    ResolveProxyPadMethod "proxyQueryAcceptCaps" o = PadProxyQueryAcceptCapsMethodInfo
+    ResolveProxyPadMethod "proxyQueryCaps" o = PadProxyQueryCapsMethodInfo
+    ResolveProxyPadMethod "pullRange" o = PadPullRangeMethodInfo
+    ResolveProxyPadMethod "push" o = PadPushMethodInfo
+    ResolveProxyPadMethod "pushEvent" o = PadPushEventMethodInfo
+    ResolveProxyPadMethod "pushList" o = PadPushListMethodInfo
+    ResolveProxyPadMethod "query" o = PadQueryMethodInfo
+    ResolveProxyPadMethod "queryAcceptCaps" o = PadQueryAcceptCapsMethodInfo
+    ResolveProxyPadMethod "queryCaps" o = PadQueryCapsMethodInfo
+    ResolveProxyPadMethod "queryConvert" o = PadQueryConvertMethodInfo
+    ResolveProxyPadMethod "queryDefault" o = PadQueryDefaultMethodInfo
+    ResolveProxyPadMethod "queryDuration" o = PadQueryDurationMethodInfo
+    ResolveProxyPadMethod "queryPosition" o = PadQueryPositionMethodInfo
+    ResolveProxyPadMethod "refSink" o = GObject.ObjectRefSinkMethodInfo
+    ResolveProxyPadMethod "removeControlBinding" o = ObjectRemoveControlBindingMethodInfo
+    ResolveProxyPadMethod "removeProbe" o = PadRemoveProbeMethodInfo
+    ResolveProxyPadMethod "replaceData" o = GObject.ObjectReplaceDataMethodInfo
+    ResolveProxyPadMethod "replaceQdata" o = GObject.ObjectReplaceQdataMethodInfo
+    ResolveProxyPadMethod "runDispose" o = GObject.ObjectRunDisposeMethodInfo
+    ResolveProxyPadMethod "sendEvent" o = PadSendEventMethodInfo
+    ResolveProxyPadMethod "startTask" o = PadStartTaskMethodInfo
+    ResolveProxyPadMethod "stealData" o = GObject.ObjectStealDataMethodInfo
+    ResolveProxyPadMethod "stealQdata" o = GObject.ObjectStealQdataMethodInfo
+    ResolveProxyPadMethod "stickyEventsForeach" o = PadStickyEventsForeachMethodInfo
+    ResolveProxyPadMethod "stopTask" o = PadStopTaskMethodInfo
+    ResolveProxyPadMethod "storeStickyEvent" o = PadStoreStickyEventMethodInfo
+    ResolveProxyPadMethod "suggestNextSync" o = ObjectSuggestNextSyncMethodInfo
+    ResolveProxyPadMethod "syncValues" o = ObjectSyncValuesMethodInfo
+    ResolveProxyPadMethod "thawNotify" o = GObject.ObjectThawNotifyMethodInfo
+    ResolveProxyPadMethod "unlink" o = PadUnlinkMethodInfo
+    ResolveProxyPadMethod "unparent" o = ObjectUnparentMethodInfo
+    ResolveProxyPadMethod "useFixedCaps" o = PadUseFixedCapsMethodInfo
+    ResolveProxyPadMethod "watchClosure" o = GObject.ObjectWatchClosureMethodInfo
+    ResolveProxyPadMethod "getAllowedCaps" o = PadGetAllowedCapsMethodInfo
+    ResolveProxyPadMethod "getControlBinding" o = ObjectGetControlBindingMethodInfo
+    ResolveProxyPadMethod "getControlRate" o = ObjectGetControlRateMethodInfo
+    ResolveProxyPadMethod "getCurrentCaps" o = PadGetCurrentCapsMethodInfo
+    ResolveProxyPadMethod "getData" o = GObject.ObjectGetDataMethodInfo
+    ResolveProxyPadMethod "getDirection" o = PadGetDirectionMethodInfo
+    ResolveProxyPadMethod "getElementPrivate" o = PadGetElementPrivateMethodInfo
+    ResolveProxyPadMethod "getGValueArray" o = ObjectGetGValueArrayMethodInfo
+    ResolveProxyPadMethod "getInternal" o = ProxyPadGetInternalMethodInfo
+    ResolveProxyPadMethod "getLastFlowReturn" o = PadGetLastFlowReturnMethodInfo
+    ResolveProxyPadMethod "getName" o = ObjectGetNameMethodInfo
+    ResolveProxyPadMethod "getOffset" o = PadGetOffsetMethodInfo
+    ResolveProxyPadMethod "getPadTemplate" o = PadGetPadTemplateMethodInfo
+    ResolveProxyPadMethod "getPadTemplateCaps" o = PadGetPadTemplateCapsMethodInfo
+    ResolveProxyPadMethod "getParent" o = ObjectGetParentMethodInfo
+    ResolveProxyPadMethod "getParentElement" o = PadGetParentElementMethodInfo
+    ResolveProxyPadMethod "getPathString" o = ObjectGetPathStringMethodInfo
+    ResolveProxyPadMethod "getPeer" o = PadGetPeerMethodInfo
+    ResolveProxyPadMethod "getProperty" o = GObject.ObjectGetPropertyMethodInfo
+    ResolveProxyPadMethod "getQdata" o = GObject.ObjectGetQdataMethodInfo
+    ResolveProxyPadMethod "getRange" o = PadGetRangeMethodInfo
+    ResolveProxyPadMethod "getStickyEvent" o = PadGetStickyEventMethodInfo
+    ResolveProxyPadMethod "getStreamId" o = PadGetStreamIdMethodInfo
+    ResolveProxyPadMethod "getValue" o = ObjectGetValueMethodInfo
+    ResolveProxyPadMethod "getValueArray" o = ObjectGetValueArrayMethodInfo
+    ResolveProxyPadMethod "setActivateFunctionFull" o = PadSetActivateFunctionFullMethodInfo
+    ResolveProxyPadMethod "setActivatemodeFunctionFull" o = PadSetActivatemodeFunctionFullMethodInfo
+    ResolveProxyPadMethod "setActive" o = PadSetActiveMethodInfo
+    ResolveProxyPadMethod "setChainFunctionFull" o = PadSetChainFunctionFullMethodInfo
+    ResolveProxyPadMethod "setChainListFunctionFull" o = PadSetChainListFunctionFullMethodInfo
+    ResolveProxyPadMethod "setControlBindingDisabled" o = ObjectSetControlBindingDisabledMethodInfo
+    ResolveProxyPadMethod "setControlBindingsDisabled" o = ObjectSetControlBindingsDisabledMethodInfo
+    ResolveProxyPadMethod "setControlRate" o = ObjectSetControlRateMethodInfo
+    ResolveProxyPadMethod "setData" o = GObject.ObjectSetDataMethodInfo
+    ResolveProxyPadMethod "setElementPrivate" o = PadSetElementPrivateMethodInfo
+    ResolveProxyPadMethod "setEventFunctionFull" o = PadSetEventFunctionFullMethodInfo
+    ResolveProxyPadMethod "setGetrangeFunctionFull" o = PadSetGetrangeFunctionFullMethodInfo
+    ResolveProxyPadMethod "setIterateInternalLinksFunctionFull" o = PadSetIterateInternalLinksFunctionFullMethodInfo
+    ResolveProxyPadMethod "setLinkFunctionFull" o = PadSetLinkFunctionFullMethodInfo
+    ResolveProxyPadMethod "setName" o = ObjectSetNameMethodInfo
+    ResolveProxyPadMethod "setOffset" o = PadSetOffsetMethodInfo
+    ResolveProxyPadMethod "setParent" o = ObjectSetParentMethodInfo
+    ResolveProxyPadMethod "setProperty" o = GObject.ObjectSetPropertyMethodInfo
+    ResolveProxyPadMethod "setQueryFunctionFull" o = PadSetQueryFunctionFullMethodInfo
+    ResolveProxyPadMethod "setUnlinkFunctionFull" o = PadSetUnlinkFunctionFullMethodInfo
+    ResolveProxyPadMethod l o = MethodResolutionFailed l o
+
+instance (info ~ ResolveProxyPadMethod t ProxyPad, MethodInfo info ProxyPad p) => IsLabelProxy t (ProxyPad -> p) where
+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)
+
+#if MIN_VERSION_base(4,9,0)
+instance (info ~ ResolveProxyPadMethod t ProxyPad, MethodInfo info ProxyPad p) => IsLabel t (ProxyPad -> p) where
+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)
+#endif
+
+type instance AttributeList ProxyPad = ProxyPadAttributeList
+type ProxyPadAttributeList = ('[ '("caps", PadCapsPropertyInfo), '("direction", PadDirectionPropertyInfo), '("name", ObjectNamePropertyInfo), '("offset", PadOffsetPropertyInfo), '("parent", ObjectParentPropertyInfo), '("template", PadTemplatePropertyInfo)] :: [(Symbol, *)])
+
+type instance SignalList ProxyPad = ProxyPadSignalList
+type ProxyPadSignalList = ('[ '("deepNotify", ObjectDeepNotifySignalInfo), '("linked", PadLinkedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("unlinked", PadUnlinkedSignalInfo)] :: [(Symbol, *)])
+
+-- method ProxyPad::get_internal
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "ProxyPad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "ProxyPad"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_proxy_pad_get_internal" gst_proxy_pad_get_internal :: 
+    Ptr ProxyPad ->                         -- _obj : TInterface "Gst" "ProxyPad"
+    IO (Ptr ProxyPad)
+
+
+proxyPadGetInternal ::
+    (MonadIO m, ProxyPadK a) =>
+    a                                       -- _obj
+    -> m ProxyPad                           -- result
+proxyPadGetInternal _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_proxy_pad_get_internal _obj'
+    checkUnexpectedReturnNULL "gst_proxy_pad_get_internal" result
+    result' <- (wrapObject ProxyPad) result
+    touchManagedPtr _obj
+    return result'
+
+data ProxyPadGetInternalMethodInfo
+instance (signature ~ (m ProxyPad), MonadIO m, ProxyPadK a) => MethodInfo ProxyPadGetInternalMethodInfo a signature where
+    overloadedMethod _ = proxyPadGetInternal
+
+-- method ProxyPad::chain_default
+-- method type : MemberFunction
+-- Args : [Arg {argCName = "pad", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "parent", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "buffer", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "FlowReturn"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_proxy_pad_chain_default" gst_proxy_pad_chain_default :: 
+    Ptr Pad ->                              -- pad : TInterface "Gst" "Pad"
+    Ptr Object ->                           -- parent : TInterface "Gst" "Object"
+    Ptr Buffer ->                           -- buffer : TInterface "Gst" "Buffer"
+    IO CUInt
+
+
+proxyPadChainDefault ::
+    (MonadIO m, PadK a, ObjectK b) =>
+    a                                       -- pad
+    -> Maybe (b)                            -- parent
+    -> Buffer                               -- buffer
+    -> m FlowReturn                         -- result
+proxyPadChainDefault pad parent buffer = liftIO $ do
+    let pad' = unsafeManagedPtrCastPtr pad
+    maybeParent <- case parent of
+        Nothing -> return nullPtr
+        Just jParent -> do
+            let jParent' = unsafeManagedPtrCastPtr jParent
+            return jParent'
+    buffer' <- copyBoxed buffer
+    result <- gst_proxy_pad_chain_default pad' maybeParent buffer'
+    let result' = (toEnum . fromIntegral) result
+    touchManagedPtr pad
+    whenJust parent touchManagedPtr
+    touchManagedPtr buffer
+    return result'
+
+-- method ProxyPad::chain_list_default
+-- method type : MemberFunction
+-- Args : [Arg {argCName = "pad", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "parent", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "list", argType = TInterface "Gst" "BufferList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "FlowReturn"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_proxy_pad_chain_list_default" gst_proxy_pad_chain_list_default :: 
+    Ptr Pad ->                              -- pad : TInterface "Gst" "Pad"
+    Ptr Object ->                           -- parent : TInterface "Gst" "Object"
+    Ptr BufferList ->                       -- list : TInterface "Gst" "BufferList"
+    IO CUInt
+
+
+proxyPadChainListDefault ::
+    (MonadIO m, PadK a, ObjectK b) =>
+    a                                       -- pad
+    -> Maybe (b)                            -- parent
+    -> BufferList                           -- list
+    -> m FlowReturn                         -- result
+proxyPadChainListDefault pad parent list = liftIO $ do
+    let pad' = unsafeManagedPtrCastPtr pad
+    maybeParent <- case parent of
+        Nothing -> return nullPtr
+        Just jParent -> do
+            let jParent' = unsafeManagedPtrCastPtr jParent
+            return jParent'
+    list' <- copyBoxed list
+    result <- gst_proxy_pad_chain_list_default pad' maybeParent list'
+    let result' = (toEnum . fromIntegral) result
+    touchManagedPtr pad
+    whenJust parent touchManagedPtr
+    touchManagedPtr list
+    return result'
+
+-- method ProxyPad::getrange_default
+-- method type : MemberFunction
+-- Args : [Arg {argCName = "pad", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "parent", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "buffer", argType = TInterface "Gst" "Buffer", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "FlowReturn"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_proxy_pad_getrange_default" gst_proxy_pad_getrange_default :: 
+    Ptr Pad ->                              -- pad : TInterface "Gst" "Pad"
+    Ptr Object ->                           -- parent : TInterface "Gst" "Object"
+    Word64 ->                               -- offset : TBasicType TUInt64
+    Word32 ->                               -- size : TBasicType TUInt32
+    Ptr Buffer ->                           -- buffer : TInterface "Gst" "Buffer"
+    IO CUInt
+
+
+proxyPadGetrangeDefault ::
+    (MonadIO m, PadK a, ObjectK b) =>
+    a                                       -- pad
+    -> b                                    -- parent
+    -> Word64                               -- offset
+    -> Word32                               -- size
+    -> m (FlowReturn,Buffer)                -- result
+proxyPadGetrangeDefault pad parent offset size = liftIO $ do
+    let pad' = unsafeManagedPtrCastPtr pad
+    let parent' = unsafeManagedPtrCastPtr parent
+    buffer <- callocBoxedBytes 112 :: IO (Ptr Buffer)
+    result <- gst_proxy_pad_getrange_default pad' parent' offset size buffer
+    let result' = (toEnum . fromIntegral) result
+    buffer' <- (wrapBoxed Buffer) buffer
+    touchManagedPtr pad
+    touchManagedPtr parent
+    return (result', buffer')
+
+-- method ProxyPad::iterate_internal_links_default
+-- method type : MemberFunction
+-- Args : [Arg {argCName = "pad", argType = TInterface "Gst" "Pad", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "parent", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Iterator"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_proxy_pad_iterate_internal_links_default" gst_proxy_pad_iterate_internal_links_default :: 
+    Ptr Pad ->                              -- pad : TInterface "Gst" "Pad"
+    Ptr Object ->                           -- parent : TInterface "Gst" "Object"
+    IO (Ptr Iterator)
+
+
+proxyPadIterateInternalLinksDefault ::
+    (MonadIO m, PadK a, ObjectK b) =>
+    a                                       -- pad
+    -> Maybe (b)                            -- parent
+    -> m Iterator                           -- result
+proxyPadIterateInternalLinksDefault pad parent = liftIO $ do
+    let pad' = unsafeManagedPtrCastPtr pad
+    maybeParent <- case parent of
+        Nothing -> return nullPtr
+        Just jParent -> do
+            let jParent' = unsafeManagedPtrCastPtr jParent
+            return jParent'
+    result <- gst_proxy_pad_iterate_internal_links_default pad' maybeParent
+    checkUnexpectedReturnNULL "gst_proxy_pad_iterate_internal_links_default" result
+    result' <- (wrapBoxed Iterator) result
+    touchManagedPtr pad
+    whenJust parent touchManagedPtr
+    return result'
+
+
diff --git a/GI/Gst/Objects/ProxyPad.hs-boot b/GI/Gst/Objects/ProxyPad.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Objects/ProxyPad.hs-boot
@@ -0,0 +1,14 @@
+module GI.Gst.Objects.ProxyPad where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+newtype ProxyPad = ProxyPad (ForeignPtr ProxyPad)
+instance GObject ProxyPad where
+class GObject o => ProxyPadK o
+instance (GObject o, IsDescendantOf ProxyPad o) => ProxyPadK o
+data ProxyPadGetInternalMethodInfo
diff --git a/GI/Gst/Objects/Registry.hs b/GI/Gst/Objects/Registry.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Objects/Registry.hs
@@ -0,0 +1,946 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+-}
+
+module GI.Gst.Objects.Registry
+    ( 
+
+-- * Exported types
+    Registry(..)                            ,
+    RegistryK                               ,
+    toRegistry                              ,
+    noRegistry                              ,
+
+
+ -- * Methods
+-- ** registryAddFeature
+    RegistryAddFeatureMethodInfo            ,
+    registryAddFeature                      ,
+
+
+-- ** registryAddPlugin
+    RegistryAddPluginMethodInfo             ,
+    registryAddPlugin                       ,
+
+
+-- ** registryCheckFeatureVersion
+    RegistryCheckFeatureVersionMethodInfo   ,
+    registryCheckFeatureVersion             ,
+
+
+-- ** registryFeatureFilter
+    RegistryFeatureFilterMethodInfo         ,
+    registryFeatureFilter                   ,
+
+
+-- ** registryFindFeature
+    RegistryFindFeatureMethodInfo           ,
+    registryFindFeature                     ,
+
+
+-- ** registryFindPlugin
+    RegistryFindPluginMethodInfo            ,
+    registryFindPlugin                      ,
+
+
+-- ** registryForkIsEnabled
+    registryForkIsEnabled                   ,
+
+
+-- ** registryForkSetEnabled
+    registryForkSetEnabled                  ,
+
+
+-- ** registryGet
+    registryGet                             ,
+
+
+-- ** registryGetFeatureList
+    RegistryGetFeatureListMethodInfo        ,
+    registryGetFeatureList                  ,
+
+
+-- ** registryGetFeatureListByPlugin
+    RegistryGetFeatureListByPluginMethodInfo,
+    registryGetFeatureListByPlugin          ,
+
+
+-- ** registryGetFeatureListCookie
+    RegistryGetFeatureListCookieMethodInfo  ,
+    registryGetFeatureListCookie            ,
+
+
+-- ** registryGetPluginList
+    RegistryGetPluginListMethodInfo         ,
+    registryGetPluginList                   ,
+
+
+-- ** registryLookup
+    RegistryLookupMethodInfo                ,
+    registryLookup                          ,
+
+
+-- ** registryLookupFeature
+    RegistryLookupFeatureMethodInfo         ,
+    registryLookupFeature                   ,
+
+
+-- ** registryPluginFilter
+    RegistryPluginFilterMethodInfo          ,
+    registryPluginFilter                    ,
+
+
+-- ** registryRemoveFeature
+    RegistryRemoveFeatureMethodInfo         ,
+    registryRemoveFeature                   ,
+
+
+-- ** registryRemovePlugin
+    RegistryRemovePluginMethodInfo          ,
+    registryRemovePlugin                    ,
+
+
+-- ** registryScanPath
+    RegistryScanPathMethodInfo              ,
+    registryScanPath                        ,
+
+
+
+
+ -- * Signals
+-- ** FeatureAdded
+    RegistryFeatureAddedCallback            ,
+    RegistryFeatureAddedCallbackC           ,
+    RegistryFeatureAddedSignalInfo          ,
+    afterRegistryFeatureAdded               ,
+    mkRegistryFeatureAddedCallback          ,
+    noRegistryFeatureAddedCallback          ,
+    onRegistryFeatureAdded                  ,
+    registryFeatureAddedCallbackWrapper     ,
+    registryFeatureAddedClosure             ,
+
+
+-- ** PluginAdded
+    RegistryPluginAddedCallback             ,
+    RegistryPluginAddedCallbackC            ,
+    RegistryPluginAddedSignalInfo           ,
+    afterRegistryPluginAdded                ,
+    mkRegistryPluginAddedCallback           ,
+    noRegistryPluginAddedCallback           ,
+    onRegistryPluginAdded                   ,
+    registryPluginAddedCallbackWrapper      ,
+    registryPluginAddedClosure              ,
+
+
+
+
+    ) where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+import GI.Gst.Callbacks
+import qualified GI.GObject as GObject
+
+newtype Registry = Registry (ForeignPtr Registry)
+foreign import ccall "gst_registry_get_type"
+    c_gst_registry_get_type :: IO GType
+
+type instance ParentTypes Registry = RegistryParentTypes
+type RegistryParentTypes = '[Object, GObject.Object]
+
+instance GObject Registry where
+    gobjectIsInitiallyUnowned _ = True
+    gobjectType _ = c_gst_registry_get_type
+    
+
+class GObject o => RegistryK o
+instance (GObject o, IsDescendantOf Registry o) => RegistryK o
+
+toRegistry :: RegistryK o => o -> IO Registry
+toRegistry = unsafeCastTo Registry
+
+noRegistry :: Maybe Registry
+noRegistry = Nothing
+
+type family ResolveRegistryMethod (t :: Symbol) (o :: *) :: * where
+    ResolveRegistryMethod "addControlBinding" o = ObjectAddControlBindingMethodInfo
+    ResolveRegistryMethod "addFeature" o = RegistryAddFeatureMethodInfo
+    ResolveRegistryMethod "addPlugin" o = RegistryAddPluginMethodInfo
+    ResolveRegistryMethod "bindProperty" o = GObject.ObjectBindPropertyMethodInfo
+    ResolveRegistryMethod "bindPropertyFull" o = GObject.ObjectBindPropertyFullMethodInfo
+    ResolveRegistryMethod "checkFeatureVersion" o = RegistryCheckFeatureVersionMethodInfo
+    ResolveRegistryMethod "defaultError" o = ObjectDefaultErrorMethodInfo
+    ResolveRegistryMethod "featureFilter" o = RegistryFeatureFilterMethodInfo
+    ResolveRegistryMethod "findFeature" o = RegistryFindFeatureMethodInfo
+    ResolveRegistryMethod "findPlugin" o = RegistryFindPluginMethodInfo
+    ResolveRegistryMethod "forceFloating" o = GObject.ObjectForceFloatingMethodInfo
+    ResolveRegistryMethod "freezeNotify" o = GObject.ObjectFreezeNotifyMethodInfo
+    ResolveRegistryMethod "hasActiveControlBindings" o = ObjectHasActiveControlBindingsMethodInfo
+    ResolveRegistryMethod "hasAncestor" o = ObjectHasAncestorMethodInfo
+    ResolveRegistryMethod "hasAsAncestor" o = ObjectHasAsAncestorMethodInfo
+    ResolveRegistryMethod "hasAsParent" o = ObjectHasAsParentMethodInfo
+    ResolveRegistryMethod "isFloating" o = GObject.ObjectIsFloatingMethodInfo
+    ResolveRegistryMethod "lookup" o = RegistryLookupMethodInfo
+    ResolveRegistryMethod "lookupFeature" o = RegistryLookupFeatureMethodInfo
+    ResolveRegistryMethod "notify" o = GObject.ObjectNotifyMethodInfo
+    ResolveRegistryMethod "notifyByPspec" o = GObject.ObjectNotifyByPspecMethodInfo
+    ResolveRegistryMethod "pluginFilter" o = RegistryPluginFilterMethodInfo
+    ResolveRegistryMethod "refSink" o = GObject.ObjectRefSinkMethodInfo
+    ResolveRegistryMethod "removeControlBinding" o = ObjectRemoveControlBindingMethodInfo
+    ResolveRegistryMethod "removeFeature" o = RegistryRemoveFeatureMethodInfo
+    ResolveRegistryMethod "removePlugin" o = RegistryRemovePluginMethodInfo
+    ResolveRegistryMethod "replaceData" o = GObject.ObjectReplaceDataMethodInfo
+    ResolveRegistryMethod "replaceQdata" o = GObject.ObjectReplaceQdataMethodInfo
+    ResolveRegistryMethod "runDispose" o = GObject.ObjectRunDisposeMethodInfo
+    ResolveRegistryMethod "scanPath" o = RegistryScanPathMethodInfo
+    ResolveRegistryMethod "stealData" o = GObject.ObjectStealDataMethodInfo
+    ResolveRegistryMethod "stealQdata" o = GObject.ObjectStealQdataMethodInfo
+    ResolveRegistryMethod "suggestNextSync" o = ObjectSuggestNextSyncMethodInfo
+    ResolveRegistryMethod "syncValues" o = ObjectSyncValuesMethodInfo
+    ResolveRegistryMethod "thawNotify" o = GObject.ObjectThawNotifyMethodInfo
+    ResolveRegistryMethod "unparent" o = ObjectUnparentMethodInfo
+    ResolveRegistryMethod "watchClosure" o = GObject.ObjectWatchClosureMethodInfo
+    ResolveRegistryMethod "getControlBinding" o = ObjectGetControlBindingMethodInfo
+    ResolveRegistryMethod "getControlRate" o = ObjectGetControlRateMethodInfo
+    ResolveRegistryMethod "getData" o = GObject.ObjectGetDataMethodInfo
+    ResolveRegistryMethod "getFeatureList" o = RegistryGetFeatureListMethodInfo
+    ResolveRegistryMethod "getFeatureListByPlugin" o = RegistryGetFeatureListByPluginMethodInfo
+    ResolveRegistryMethod "getFeatureListCookie" o = RegistryGetFeatureListCookieMethodInfo
+    ResolveRegistryMethod "getGValueArray" o = ObjectGetGValueArrayMethodInfo
+    ResolveRegistryMethod "getName" o = ObjectGetNameMethodInfo
+    ResolveRegistryMethod "getParent" o = ObjectGetParentMethodInfo
+    ResolveRegistryMethod "getPathString" o = ObjectGetPathStringMethodInfo
+    ResolveRegistryMethod "getPluginList" o = RegistryGetPluginListMethodInfo
+    ResolveRegistryMethod "getProperty" o = GObject.ObjectGetPropertyMethodInfo
+    ResolveRegistryMethod "getQdata" o = GObject.ObjectGetQdataMethodInfo
+    ResolveRegistryMethod "getValue" o = ObjectGetValueMethodInfo
+    ResolveRegistryMethod "getValueArray" o = ObjectGetValueArrayMethodInfo
+    ResolveRegistryMethod "setControlBindingDisabled" o = ObjectSetControlBindingDisabledMethodInfo
+    ResolveRegistryMethod "setControlBindingsDisabled" o = ObjectSetControlBindingsDisabledMethodInfo
+    ResolveRegistryMethod "setControlRate" o = ObjectSetControlRateMethodInfo
+    ResolveRegistryMethod "setData" o = GObject.ObjectSetDataMethodInfo
+    ResolveRegistryMethod "setName" o = ObjectSetNameMethodInfo
+    ResolveRegistryMethod "setParent" o = ObjectSetParentMethodInfo
+    ResolveRegistryMethod "setProperty" o = GObject.ObjectSetPropertyMethodInfo
+    ResolveRegistryMethod l o = MethodResolutionFailed l o
+
+instance (info ~ ResolveRegistryMethod t Registry, MethodInfo info Registry p) => IsLabelProxy t (Registry -> p) where
+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)
+
+#if MIN_VERSION_base(4,9,0)
+instance (info ~ ResolveRegistryMethod t Registry, MethodInfo info Registry p) => IsLabel t (Registry -> p) where
+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)
+#endif
+
+-- signal Registry::feature-added
+type RegistryFeatureAddedCallback =
+    PluginFeature ->
+    IO ()
+
+noRegistryFeatureAddedCallback :: Maybe RegistryFeatureAddedCallback
+noRegistryFeatureAddedCallback = Nothing
+
+type RegistryFeatureAddedCallbackC =
+    Ptr () ->                               -- object
+    Ptr PluginFeature ->
+    Ptr () ->                               -- user_data
+    IO ()
+
+foreign import ccall "wrapper"
+    mkRegistryFeatureAddedCallback :: RegistryFeatureAddedCallbackC -> IO (FunPtr RegistryFeatureAddedCallbackC)
+
+registryFeatureAddedClosure :: RegistryFeatureAddedCallback -> IO Closure
+registryFeatureAddedClosure cb = newCClosure =<< mkRegistryFeatureAddedCallback wrapped
+    where wrapped = registryFeatureAddedCallbackWrapper cb
+
+registryFeatureAddedCallbackWrapper ::
+    RegistryFeatureAddedCallback ->
+    Ptr () ->
+    Ptr PluginFeature ->
+    Ptr () ->
+    IO ()
+registryFeatureAddedCallbackWrapper _cb _ feature _ = do
+    feature' <- (newObject PluginFeature) feature
+    _cb  feature'
+
+onRegistryFeatureAdded :: (GObject a, MonadIO m) => a -> RegistryFeatureAddedCallback -> m SignalHandlerId
+onRegistryFeatureAdded obj cb = liftIO $ connectRegistryFeatureAdded obj cb SignalConnectBefore
+afterRegistryFeatureAdded :: (GObject a, MonadIO m) => a -> RegistryFeatureAddedCallback -> m SignalHandlerId
+afterRegistryFeatureAdded obj cb = connectRegistryFeatureAdded obj cb SignalConnectAfter
+
+connectRegistryFeatureAdded :: (GObject a, MonadIO m) =>
+                               a -> RegistryFeatureAddedCallback -> SignalConnectMode -> m SignalHandlerId
+connectRegistryFeatureAdded obj cb after = liftIO $ do
+    cb' <- mkRegistryFeatureAddedCallback (registryFeatureAddedCallbackWrapper cb)
+    connectSignalFunPtr obj "feature-added" cb' after
+
+-- signal Registry::plugin-added
+type RegistryPluginAddedCallback =
+    Plugin ->
+    IO ()
+
+noRegistryPluginAddedCallback :: Maybe RegistryPluginAddedCallback
+noRegistryPluginAddedCallback = Nothing
+
+type RegistryPluginAddedCallbackC =
+    Ptr () ->                               -- object
+    Ptr Plugin ->
+    Ptr () ->                               -- user_data
+    IO ()
+
+foreign import ccall "wrapper"
+    mkRegistryPluginAddedCallback :: RegistryPluginAddedCallbackC -> IO (FunPtr RegistryPluginAddedCallbackC)
+
+registryPluginAddedClosure :: RegistryPluginAddedCallback -> IO Closure
+registryPluginAddedClosure cb = newCClosure =<< mkRegistryPluginAddedCallback wrapped
+    where wrapped = registryPluginAddedCallbackWrapper cb
+
+registryPluginAddedCallbackWrapper ::
+    RegistryPluginAddedCallback ->
+    Ptr () ->
+    Ptr Plugin ->
+    Ptr () ->
+    IO ()
+registryPluginAddedCallbackWrapper _cb _ plugin _ = do
+    plugin' <- (newObject Plugin) plugin
+    _cb  plugin'
+
+onRegistryPluginAdded :: (GObject a, MonadIO m) => a -> RegistryPluginAddedCallback -> m SignalHandlerId
+onRegistryPluginAdded obj cb = liftIO $ connectRegistryPluginAdded obj cb SignalConnectBefore
+afterRegistryPluginAdded :: (GObject a, MonadIO m) => a -> RegistryPluginAddedCallback -> m SignalHandlerId
+afterRegistryPluginAdded obj cb = connectRegistryPluginAdded obj cb SignalConnectAfter
+
+connectRegistryPluginAdded :: (GObject a, MonadIO m) =>
+                              a -> RegistryPluginAddedCallback -> SignalConnectMode -> m SignalHandlerId
+connectRegistryPluginAdded obj cb after = liftIO $ do
+    cb' <- mkRegistryPluginAddedCallback (registryPluginAddedCallbackWrapper cb)
+    connectSignalFunPtr obj "plugin-added" cb' after
+
+type instance AttributeList Registry = RegistryAttributeList
+type RegistryAttributeList = ('[ '("name", ObjectNamePropertyInfo), '("parent", ObjectParentPropertyInfo)] :: [(Symbol, *)])
+
+data RegistryFeatureAddedSignalInfo
+instance SignalInfo RegistryFeatureAddedSignalInfo where
+    type HaskellCallbackType RegistryFeatureAddedSignalInfo = RegistryFeatureAddedCallback
+    connectSignal _ = connectRegistryFeatureAdded
+
+data RegistryPluginAddedSignalInfo
+instance SignalInfo RegistryPluginAddedSignalInfo where
+    type HaskellCallbackType RegistryPluginAddedSignalInfo = RegistryPluginAddedCallback
+    connectSignal _ = connectRegistryPluginAdded
+
+type instance SignalList Registry = RegistrySignalList
+type RegistrySignalList = ('[ '("deepNotify", ObjectDeepNotifySignalInfo), '("featureAdded", RegistryFeatureAddedSignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("pluginAdded", RegistryPluginAddedSignalInfo)] :: [(Symbol, *)])
+
+-- method Registry::add_feature
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Registry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "feature", argType = TInterface "Gst" "PluginFeature", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_registry_add_feature" gst_registry_add_feature :: 
+    Ptr Registry ->                         -- _obj : TInterface "Gst" "Registry"
+    Ptr PluginFeature ->                    -- feature : TInterface "Gst" "PluginFeature"
+    IO CInt
+
+
+registryAddFeature ::
+    (MonadIO m, RegistryK a, PluginFeatureK b) =>
+    a                                       -- _obj
+    -> b                                    -- feature
+    -> m Bool                               -- result
+registryAddFeature _obj feature = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    feature' <- refObject feature
+    result <- gst_registry_add_feature _obj' feature'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    touchManagedPtr feature
+    return result'
+
+data RegistryAddFeatureMethodInfo
+instance (signature ~ (b -> m Bool), MonadIO m, RegistryK a, PluginFeatureK b) => MethodInfo RegistryAddFeatureMethodInfo a signature where
+    overloadedMethod _ = registryAddFeature
+
+-- method Registry::add_plugin
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Registry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "plugin", argType = TInterface "Gst" "Plugin", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_registry_add_plugin" gst_registry_add_plugin :: 
+    Ptr Registry ->                         -- _obj : TInterface "Gst" "Registry"
+    Ptr Plugin ->                           -- plugin : TInterface "Gst" "Plugin"
+    IO CInt
+
+
+registryAddPlugin ::
+    (MonadIO m, RegistryK a, PluginK b) =>
+    a                                       -- _obj
+    -> b                                    -- plugin
+    -> m Bool                               -- result
+registryAddPlugin _obj plugin = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    plugin' <- refObject plugin
+    result <- gst_registry_add_plugin _obj' plugin'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    touchManagedPtr plugin
+    return result'
+
+data RegistryAddPluginMethodInfo
+instance (signature ~ (b -> m Bool), MonadIO m, RegistryK a, PluginK b) => MethodInfo RegistryAddPluginMethodInfo a signature where
+    overloadedMethod _ = registryAddPlugin
+
+-- method Registry::check_feature_version
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Registry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "feature_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "min_major", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "min_minor", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "min_micro", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_registry_check_feature_version" gst_registry_check_feature_version :: 
+    Ptr Registry ->                         -- _obj : TInterface "Gst" "Registry"
+    CString ->                              -- feature_name : TBasicType TUTF8
+    Word32 ->                               -- min_major : TBasicType TUInt32
+    Word32 ->                               -- min_minor : TBasicType TUInt32
+    Word32 ->                               -- min_micro : TBasicType TUInt32
+    IO CInt
+
+
+registryCheckFeatureVersion ::
+    (MonadIO m, RegistryK a) =>
+    a                                       -- _obj
+    -> T.Text                               -- featureName
+    -> Word32                               -- minMajor
+    -> Word32                               -- minMinor
+    -> Word32                               -- minMicro
+    -> m Bool                               -- result
+registryCheckFeatureVersion _obj featureName minMajor minMinor minMicro = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    featureName' <- textToCString featureName
+    result <- gst_registry_check_feature_version _obj' featureName' minMajor minMinor minMicro
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    freeMem featureName'
+    return result'
+
+data RegistryCheckFeatureVersionMethodInfo
+instance (signature ~ (T.Text -> Word32 -> Word32 -> Word32 -> m Bool), MonadIO m, RegistryK a) => MethodInfo RegistryCheckFeatureVersionMethodInfo a signature where
+    overloadedMethod _ = registryCheckFeatureVersion
+
+-- method Registry::feature_filter
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Registry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "filter", argType = TInterface "Gst" "PluginFeatureFilter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, argClosure = 3, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "first", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TGList (TInterface "Gst" "PluginFeature")
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_registry_feature_filter" gst_registry_feature_filter :: 
+    Ptr Registry ->                         -- _obj : TInterface "Gst" "Registry"
+    FunPtr PluginFeatureFilterC ->          -- filter : TInterface "Gst" "PluginFeatureFilter"
+    CInt ->                                 -- first : TBasicType TBoolean
+    Ptr () ->                               -- user_data : TBasicType TVoid
+    IO (Ptr (GList (Ptr PluginFeature)))
+
+
+registryFeatureFilter ::
+    (MonadIO m, RegistryK a) =>
+    a                                       -- _obj
+    -> PluginFeatureFilter                  -- filter
+    -> Bool                                 -- first
+    -> m [PluginFeature]                    -- result
+registryFeatureFilter _obj filter first = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    filter' <- mkPluginFeatureFilter (pluginFeatureFilterWrapper Nothing filter)
+    let first' = (fromIntegral . fromEnum) first
+    let userData = nullPtr
+    result <- gst_registry_feature_filter _obj' filter' first' userData
+    checkUnexpectedReturnNULL "gst_registry_feature_filter" result
+    result' <- unpackGList result
+    result'' <- mapM (wrapObject PluginFeature) result'
+    g_list_free result
+    safeFreeFunPtr $ castFunPtrToPtr filter'
+    touchManagedPtr _obj
+    return result''
+
+data RegistryFeatureFilterMethodInfo
+instance (signature ~ (PluginFeatureFilter -> Bool -> m [PluginFeature]), MonadIO m, RegistryK a) => MethodInfo RegistryFeatureFilterMethodInfo a signature where
+    overloadedMethod _ = registryFeatureFilter
+
+-- method Registry::find_feature
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Registry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "type", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "PluginFeature"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_registry_find_feature" gst_registry_find_feature :: 
+    Ptr Registry ->                         -- _obj : TInterface "Gst" "Registry"
+    CString ->                              -- name : TBasicType TUTF8
+    CGType ->                               -- type : TBasicType TGType
+    IO (Ptr PluginFeature)
+
+
+registryFindFeature ::
+    (MonadIO m, RegistryK a) =>
+    a                                       -- _obj
+    -> T.Text                               -- name
+    -> GType                                -- type_
+    -> m PluginFeature                      -- result
+registryFindFeature _obj name type_ = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    name' <- textToCString name
+    let type_' = gtypeToCGType type_
+    result <- gst_registry_find_feature _obj' name' type_'
+    checkUnexpectedReturnNULL "gst_registry_find_feature" result
+    result' <- (wrapObject PluginFeature) result
+    touchManagedPtr _obj
+    freeMem name'
+    return result'
+
+data RegistryFindFeatureMethodInfo
+instance (signature ~ (T.Text -> GType -> m PluginFeature), MonadIO m, RegistryK a) => MethodInfo RegistryFindFeatureMethodInfo a signature where
+    overloadedMethod _ = registryFindFeature
+
+-- method Registry::find_plugin
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Registry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Plugin"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_registry_find_plugin" gst_registry_find_plugin :: 
+    Ptr Registry ->                         -- _obj : TInterface "Gst" "Registry"
+    CString ->                              -- name : TBasicType TUTF8
+    IO (Ptr Plugin)
+
+
+registryFindPlugin ::
+    (MonadIO m, RegistryK a) =>
+    a                                       -- _obj
+    -> T.Text                               -- name
+    -> m Plugin                             -- result
+registryFindPlugin _obj name = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    name' <- textToCString name
+    result <- gst_registry_find_plugin _obj' name'
+    checkUnexpectedReturnNULL "gst_registry_find_plugin" result
+    result' <- (wrapObject Plugin) result
+    touchManagedPtr _obj
+    freeMem name'
+    return result'
+
+data RegistryFindPluginMethodInfo
+instance (signature ~ (T.Text -> m Plugin), MonadIO m, RegistryK a) => MethodInfo RegistryFindPluginMethodInfo a signature where
+    overloadedMethod _ = registryFindPlugin
+
+-- method Registry::get_feature_list
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Registry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "type", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TGList (TInterface "Gst" "PluginFeature")
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_registry_get_feature_list" gst_registry_get_feature_list :: 
+    Ptr Registry ->                         -- _obj : TInterface "Gst" "Registry"
+    CGType ->                               -- type : TBasicType TGType
+    IO (Ptr (GList (Ptr PluginFeature)))
+
+
+registryGetFeatureList ::
+    (MonadIO m, RegistryK a) =>
+    a                                       -- _obj
+    -> GType                                -- type_
+    -> m [PluginFeature]                    -- result
+registryGetFeatureList _obj type_ = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let type_' = gtypeToCGType type_
+    result <- gst_registry_get_feature_list _obj' type_'
+    checkUnexpectedReturnNULL "gst_registry_get_feature_list" result
+    result' <- unpackGList result
+    result'' <- mapM (wrapObject PluginFeature) result'
+    g_list_free result
+    touchManagedPtr _obj
+    return result''
+
+data RegistryGetFeatureListMethodInfo
+instance (signature ~ (GType -> m [PluginFeature]), MonadIO m, RegistryK a) => MethodInfo RegistryGetFeatureListMethodInfo a signature where
+    overloadedMethod _ = registryGetFeatureList
+
+-- method Registry::get_feature_list_by_plugin
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Registry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TGList (TInterface "Gst" "PluginFeature")
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_registry_get_feature_list_by_plugin" gst_registry_get_feature_list_by_plugin :: 
+    Ptr Registry ->                         -- _obj : TInterface "Gst" "Registry"
+    CString ->                              -- name : TBasicType TUTF8
+    IO (Ptr (GList (Ptr PluginFeature)))
+
+
+registryGetFeatureListByPlugin ::
+    (MonadIO m, RegistryK a) =>
+    a                                       -- _obj
+    -> T.Text                               -- name
+    -> m [PluginFeature]                    -- result
+registryGetFeatureListByPlugin _obj name = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    name' <- textToCString name
+    result <- gst_registry_get_feature_list_by_plugin _obj' name'
+    checkUnexpectedReturnNULL "gst_registry_get_feature_list_by_plugin" result
+    result' <- unpackGList result
+    result'' <- mapM (wrapObject PluginFeature) result'
+    g_list_free result
+    touchManagedPtr _obj
+    freeMem name'
+    return result''
+
+data RegistryGetFeatureListByPluginMethodInfo
+instance (signature ~ (T.Text -> m [PluginFeature]), MonadIO m, RegistryK a) => MethodInfo RegistryGetFeatureListByPluginMethodInfo a signature where
+    overloadedMethod _ = registryGetFeatureListByPlugin
+
+-- method Registry::get_feature_list_cookie
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Registry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUInt32
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_registry_get_feature_list_cookie" gst_registry_get_feature_list_cookie :: 
+    Ptr Registry ->                         -- _obj : TInterface "Gst" "Registry"
+    IO Word32
+
+
+registryGetFeatureListCookie ::
+    (MonadIO m, RegistryK a) =>
+    a                                       -- _obj
+    -> m Word32                             -- result
+registryGetFeatureListCookie _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_registry_get_feature_list_cookie _obj'
+    touchManagedPtr _obj
+    return result
+
+data RegistryGetFeatureListCookieMethodInfo
+instance (signature ~ (m Word32), MonadIO m, RegistryK a) => MethodInfo RegistryGetFeatureListCookieMethodInfo a signature where
+    overloadedMethod _ = registryGetFeatureListCookie
+
+-- method Registry::get_plugin_list
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Registry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TGList (TInterface "Gst" "Plugin")
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_registry_get_plugin_list" gst_registry_get_plugin_list :: 
+    Ptr Registry ->                         -- _obj : TInterface "Gst" "Registry"
+    IO (Ptr (GList (Ptr Plugin)))
+
+
+registryGetPluginList ::
+    (MonadIO m, RegistryK a) =>
+    a                                       -- _obj
+    -> m [Plugin]                           -- result
+registryGetPluginList _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_registry_get_plugin_list _obj'
+    checkUnexpectedReturnNULL "gst_registry_get_plugin_list" result
+    result' <- unpackGList result
+    result'' <- mapM (wrapObject Plugin) result'
+    g_list_free result
+    touchManagedPtr _obj
+    return result''
+
+data RegistryGetPluginListMethodInfo
+instance (signature ~ (m [Plugin]), MonadIO m, RegistryK a) => MethodInfo RegistryGetPluginListMethodInfo a signature where
+    overloadedMethod _ = registryGetPluginList
+
+-- method Registry::lookup
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Registry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "filename", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Plugin"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_registry_lookup" gst_registry_lookup :: 
+    Ptr Registry ->                         -- _obj : TInterface "Gst" "Registry"
+    CString ->                              -- filename : TBasicType TUTF8
+    IO (Ptr Plugin)
+
+
+registryLookup ::
+    (MonadIO m, RegistryK a) =>
+    a                                       -- _obj
+    -> T.Text                               -- filename
+    -> m Plugin                             -- result
+registryLookup _obj filename = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    filename' <- textToCString filename
+    result <- gst_registry_lookup _obj' filename'
+    checkUnexpectedReturnNULL "gst_registry_lookup" result
+    result' <- (wrapObject Plugin) result
+    touchManagedPtr _obj
+    freeMem filename'
+    return result'
+
+data RegistryLookupMethodInfo
+instance (signature ~ (T.Text -> m Plugin), MonadIO m, RegistryK a) => MethodInfo RegistryLookupMethodInfo a signature where
+    overloadedMethod _ = registryLookup
+
+-- method Registry::lookup_feature
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Registry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "PluginFeature"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_registry_lookup_feature" gst_registry_lookup_feature :: 
+    Ptr Registry ->                         -- _obj : TInterface "Gst" "Registry"
+    CString ->                              -- name : TBasicType TUTF8
+    IO (Ptr PluginFeature)
+
+
+registryLookupFeature ::
+    (MonadIO m, RegistryK a) =>
+    a                                       -- _obj
+    -> T.Text                               -- name
+    -> m PluginFeature                      -- result
+registryLookupFeature _obj name = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    name' <- textToCString name
+    result <- gst_registry_lookup_feature _obj' name'
+    checkUnexpectedReturnNULL "gst_registry_lookup_feature" result
+    result' <- (wrapObject PluginFeature) result
+    touchManagedPtr _obj
+    freeMem name'
+    return result'
+
+data RegistryLookupFeatureMethodInfo
+instance (signature ~ (T.Text -> m PluginFeature), MonadIO m, RegistryK a) => MethodInfo RegistryLookupFeatureMethodInfo a signature where
+    overloadedMethod _ = registryLookupFeature
+
+-- method Registry::plugin_filter
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Registry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "filter", argType = TInterface "Gst" "PluginFilter", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, argClosure = 3, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "first", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TGList (TInterface "Gst" "Plugin")
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_registry_plugin_filter" gst_registry_plugin_filter :: 
+    Ptr Registry ->                         -- _obj : TInterface "Gst" "Registry"
+    FunPtr PluginFilterC ->                 -- filter : TInterface "Gst" "PluginFilter"
+    CInt ->                                 -- first : TBasicType TBoolean
+    Ptr () ->                               -- user_data : TBasicType TVoid
+    IO (Ptr (GList (Ptr Plugin)))
+
+
+registryPluginFilter ::
+    (MonadIO m, RegistryK a) =>
+    a                                       -- _obj
+    -> PluginFilter                         -- filter
+    -> Bool                                 -- first
+    -> m [Plugin]                           -- result
+registryPluginFilter _obj filter first = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    filter' <- mkPluginFilter (pluginFilterWrapper Nothing filter)
+    let first' = (fromIntegral . fromEnum) first
+    let userData = nullPtr
+    result <- gst_registry_plugin_filter _obj' filter' first' userData
+    checkUnexpectedReturnNULL "gst_registry_plugin_filter" result
+    result' <- unpackGList result
+    result'' <- mapM (wrapObject Plugin) result'
+    g_list_free result
+    safeFreeFunPtr $ castFunPtrToPtr filter'
+    touchManagedPtr _obj
+    return result''
+
+data RegistryPluginFilterMethodInfo
+instance (signature ~ (PluginFilter -> Bool -> m [Plugin]), MonadIO m, RegistryK a) => MethodInfo RegistryPluginFilterMethodInfo a signature where
+    overloadedMethod _ = registryPluginFilter
+
+-- method Registry::remove_feature
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Registry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "feature", argType = TInterface "Gst" "PluginFeature", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_registry_remove_feature" gst_registry_remove_feature :: 
+    Ptr Registry ->                         -- _obj : TInterface "Gst" "Registry"
+    Ptr PluginFeature ->                    -- feature : TInterface "Gst" "PluginFeature"
+    IO ()
+
+
+registryRemoveFeature ::
+    (MonadIO m, RegistryK a, PluginFeatureK b) =>
+    a                                       -- _obj
+    -> b                                    -- feature
+    -> m ()                                 -- result
+registryRemoveFeature _obj feature = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let feature' = unsafeManagedPtrCastPtr feature
+    gst_registry_remove_feature _obj' feature'
+    touchManagedPtr _obj
+    touchManagedPtr feature
+    return ()
+
+data RegistryRemoveFeatureMethodInfo
+instance (signature ~ (b -> m ()), MonadIO m, RegistryK a, PluginFeatureK b) => MethodInfo RegistryRemoveFeatureMethodInfo a signature where
+    overloadedMethod _ = registryRemoveFeature
+
+-- method Registry::remove_plugin
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Registry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "plugin", argType = TInterface "Gst" "Plugin", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_registry_remove_plugin" gst_registry_remove_plugin :: 
+    Ptr Registry ->                         -- _obj : TInterface "Gst" "Registry"
+    Ptr Plugin ->                           -- plugin : TInterface "Gst" "Plugin"
+    IO ()
+
+
+registryRemovePlugin ::
+    (MonadIO m, RegistryK a, PluginK b) =>
+    a                                       -- _obj
+    -> b                                    -- plugin
+    -> m ()                                 -- result
+registryRemovePlugin _obj plugin = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let plugin' = unsafeManagedPtrCastPtr plugin
+    gst_registry_remove_plugin _obj' plugin'
+    touchManagedPtr _obj
+    touchManagedPtr plugin
+    return ()
+
+data RegistryRemovePluginMethodInfo
+instance (signature ~ (b -> m ()), MonadIO m, RegistryK a, PluginK b) => MethodInfo RegistryRemovePluginMethodInfo a signature where
+    overloadedMethod _ = registryRemovePlugin
+
+-- method Registry::scan_path
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Registry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_registry_scan_path" gst_registry_scan_path :: 
+    Ptr Registry ->                         -- _obj : TInterface "Gst" "Registry"
+    CString ->                              -- path : TBasicType TUTF8
+    IO CInt
+
+
+registryScanPath ::
+    (MonadIO m, RegistryK a) =>
+    a                                       -- _obj
+    -> T.Text                               -- path
+    -> m Bool                               -- result
+registryScanPath _obj path = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    path' <- textToCString path
+    result <- gst_registry_scan_path _obj' path'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    freeMem path'
+    return result'
+
+data RegistryScanPathMethodInfo
+instance (signature ~ (T.Text -> m Bool), MonadIO m, RegistryK a) => MethodInfo RegistryScanPathMethodInfo a signature where
+    overloadedMethod _ = registryScanPath
+
+-- method Registry::fork_is_enabled
+-- method type : MemberFunction
+-- Args : []
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_registry_fork_is_enabled" gst_registry_fork_is_enabled :: 
+    IO CInt
+
+
+registryForkIsEnabled ::
+    (MonadIO m) =>
+    m Bool                                  -- result
+registryForkIsEnabled  = liftIO $ do
+    result <- gst_registry_fork_is_enabled
+    let result' = (/= 0) result
+    return result'
+
+-- method Registry::fork_set_enabled
+-- method type : MemberFunction
+-- Args : [Arg {argCName = "enabled", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_registry_fork_set_enabled" gst_registry_fork_set_enabled :: 
+    CInt ->                                 -- enabled : TBasicType TBoolean
+    IO ()
+
+
+registryForkSetEnabled ::
+    (MonadIO m) =>
+    Bool                                    -- enabled
+    -> m ()                                 -- result
+registryForkSetEnabled enabled = liftIO $ do
+    let enabled' = (fromIntegral . fromEnum) enabled
+    gst_registry_fork_set_enabled enabled'
+    return ()
+
+-- method Registry::get
+-- method type : MemberFunction
+-- Args : []
+-- Lengths : []
+-- returnType : TInterface "Gst" "Registry"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_registry_get" gst_registry_get :: 
+    IO (Ptr Registry)
+
+
+registryGet ::
+    (MonadIO m) =>
+    m Registry                              -- result
+registryGet  = liftIO $ do
+    result <- gst_registry_get
+    checkUnexpectedReturnNULL "gst_registry_get" result
+    result' <- (newObject Registry) result
+    return result'
+
+
diff --git a/GI/Gst/Objects/Registry.hs-boot b/GI/Gst/Objects/Registry.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Objects/Registry.hs-boot
@@ -0,0 +1,31 @@
+module GI.Gst.Objects.Registry where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+newtype Registry = Registry (ForeignPtr Registry)
+instance GObject Registry where
+class GObject o => RegistryK o
+instance (GObject o, IsDescendantOf Registry o) => RegistryK o
+data RegistryFeatureAddedSignalInfo
+data RegistryPluginAddedSignalInfo
+data RegistryAddFeatureMethodInfo
+data RegistryAddPluginMethodInfo
+data RegistryCheckFeatureVersionMethodInfo
+data RegistryFeatureFilterMethodInfo
+data RegistryFindFeatureMethodInfo
+data RegistryFindPluginMethodInfo
+data RegistryGetFeatureListMethodInfo
+data RegistryGetFeatureListByPluginMethodInfo
+data RegistryGetFeatureListCookieMethodInfo
+data RegistryGetPluginListMethodInfo
+data RegistryLookupMethodInfo
+data RegistryLookupFeatureMethodInfo
+data RegistryPluginFilterMethodInfo
+data RegistryRemoveFeatureMethodInfo
+data RegistryRemovePluginMethodInfo
+data RegistryScanPathMethodInfo
diff --git a/GI/Gst/Objects/SystemClock.hs b/GI/Gst/Objects/SystemClock.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Objects/SystemClock.hs
@@ -0,0 +1,224 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+-}
+
+module GI.Gst.Objects.SystemClock
+    ( 
+
+-- * Exported types
+    SystemClock(..)                         ,
+    SystemClockK                            ,
+    toSystemClock                           ,
+    noSystemClock                           ,
+
+
+ -- * Methods
+-- ** systemClockObtain
+    systemClockObtain                       ,
+
+
+-- ** systemClockSetDefault
+    systemClockSetDefault                   ,
+
+
+
+
+ -- * Properties
+-- ** ClockType
+    SystemClockClockTypePropertyInfo        ,
+    constructSystemClockClockType           ,
+    getSystemClockClockType                 ,
+    setSystemClockClockType                 ,
+
+
+
+
+    ) where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+import GI.Gst.Callbacks
+import qualified GI.GObject as GObject
+
+newtype SystemClock = SystemClock (ForeignPtr SystemClock)
+foreign import ccall "gst_system_clock_get_type"
+    c_gst_system_clock_get_type :: IO GType
+
+type instance ParentTypes SystemClock = SystemClockParentTypes
+type SystemClockParentTypes = '[Clock, Object, GObject.Object]
+
+instance GObject SystemClock where
+    gobjectIsInitiallyUnowned _ = True
+    gobjectType _ = c_gst_system_clock_get_type
+    
+
+class GObject o => SystemClockK o
+instance (GObject o, IsDescendantOf SystemClock o) => SystemClockK o
+
+toSystemClock :: SystemClockK o => o -> IO SystemClock
+toSystemClock = unsafeCastTo SystemClock
+
+noSystemClock :: Maybe SystemClock
+noSystemClock = Nothing
+
+type family ResolveSystemClockMethod (t :: Symbol) (o :: *) :: * where
+    ResolveSystemClockMethod "addControlBinding" o = ObjectAddControlBindingMethodInfo
+    ResolveSystemClockMethod "addObservation" o = ClockAddObservationMethodInfo
+    ResolveSystemClockMethod "addObservationUnapplied" o = ClockAddObservationUnappliedMethodInfo
+    ResolveSystemClockMethod "adjustUnlocked" o = ClockAdjustUnlockedMethodInfo
+    ResolveSystemClockMethod "adjustWithCalibration" o = ClockAdjustWithCalibrationMethodInfo
+    ResolveSystemClockMethod "bindProperty" o = GObject.ObjectBindPropertyMethodInfo
+    ResolveSystemClockMethod "bindPropertyFull" o = GObject.ObjectBindPropertyFullMethodInfo
+    ResolveSystemClockMethod "defaultError" o = ObjectDefaultErrorMethodInfo
+    ResolveSystemClockMethod "forceFloating" o = GObject.ObjectForceFloatingMethodInfo
+    ResolveSystemClockMethod "freezeNotify" o = GObject.ObjectFreezeNotifyMethodInfo
+    ResolveSystemClockMethod "hasActiveControlBindings" o = ObjectHasActiveControlBindingsMethodInfo
+    ResolveSystemClockMethod "hasAncestor" o = ObjectHasAncestorMethodInfo
+    ResolveSystemClockMethod "hasAsAncestor" o = ObjectHasAsAncestorMethodInfo
+    ResolveSystemClockMethod "hasAsParent" o = ObjectHasAsParentMethodInfo
+    ResolveSystemClockMethod "isFloating" o = GObject.ObjectIsFloatingMethodInfo
+    ResolveSystemClockMethod "isSynced" o = ClockIsSyncedMethodInfo
+    ResolveSystemClockMethod "newPeriodicId" o = ClockNewPeriodicIdMethodInfo
+    ResolveSystemClockMethod "newSingleShotId" o = ClockNewSingleShotIdMethodInfo
+    ResolveSystemClockMethod "notify" o = GObject.ObjectNotifyMethodInfo
+    ResolveSystemClockMethod "notifyByPspec" o = GObject.ObjectNotifyByPspecMethodInfo
+    ResolveSystemClockMethod "periodicIdReinit" o = ClockPeriodicIdReinitMethodInfo
+    ResolveSystemClockMethod "refSink" o = GObject.ObjectRefSinkMethodInfo
+    ResolveSystemClockMethod "removeControlBinding" o = ObjectRemoveControlBindingMethodInfo
+    ResolveSystemClockMethod "replaceData" o = GObject.ObjectReplaceDataMethodInfo
+    ResolveSystemClockMethod "replaceQdata" o = GObject.ObjectReplaceQdataMethodInfo
+    ResolveSystemClockMethod "runDispose" o = GObject.ObjectRunDisposeMethodInfo
+    ResolveSystemClockMethod "singleShotIdReinit" o = ClockSingleShotIdReinitMethodInfo
+    ResolveSystemClockMethod "stealData" o = GObject.ObjectStealDataMethodInfo
+    ResolveSystemClockMethod "stealQdata" o = GObject.ObjectStealQdataMethodInfo
+    ResolveSystemClockMethod "suggestNextSync" o = ObjectSuggestNextSyncMethodInfo
+    ResolveSystemClockMethod "syncValues" o = ObjectSyncValuesMethodInfo
+    ResolveSystemClockMethod "thawNotify" o = GObject.ObjectThawNotifyMethodInfo
+    ResolveSystemClockMethod "unadjustUnlocked" o = ClockUnadjustUnlockedMethodInfo
+    ResolveSystemClockMethod "unparent" o = ObjectUnparentMethodInfo
+    ResolveSystemClockMethod "waitForSync" o = ClockWaitForSyncMethodInfo
+    ResolveSystemClockMethod "watchClosure" o = GObject.ObjectWatchClosureMethodInfo
+    ResolveSystemClockMethod "getCalibration" o = ClockGetCalibrationMethodInfo
+    ResolveSystemClockMethod "getControlBinding" o = ObjectGetControlBindingMethodInfo
+    ResolveSystemClockMethod "getControlRate" o = ObjectGetControlRateMethodInfo
+    ResolveSystemClockMethod "getData" o = GObject.ObjectGetDataMethodInfo
+    ResolveSystemClockMethod "getGValueArray" o = ObjectGetGValueArrayMethodInfo
+    ResolveSystemClockMethod "getInternalTime" o = ClockGetInternalTimeMethodInfo
+    ResolveSystemClockMethod "getMaster" o = ClockGetMasterMethodInfo
+    ResolveSystemClockMethod "getName" o = ObjectGetNameMethodInfo
+    ResolveSystemClockMethod "getParent" o = ObjectGetParentMethodInfo
+    ResolveSystemClockMethod "getPathString" o = ObjectGetPathStringMethodInfo
+    ResolveSystemClockMethod "getProperty" o = GObject.ObjectGetPropertyMethodInfo
+    ResolveSystemClockMethod "getQdata" o = GObject.ObjectGetQdataMethodInfo
+    ResolveSystemClockMethod "getResolution" o = ClockGetResolutionMethodInfo
+    ResolveSystemClockMethod "getTime" o = ClockGetTimeMethodInfo
+    ResolveSystemClockMethod "getTimeout" o = ClockGetTimeoutMethodInfo
+    ResolveSystemClockMethod "getValue" o = ObjectGetValueMethodInfo
+    ResolveSystemClockMethod "getValueArray" o = ObjectGetValueArrayMethodInfo
+    ResolveSystemClockMethod "setCalibration" o = ClockSetCalibrationMethodInfo
+    ResolveSystemClockMethod "setControlBindingDisabled" o = ObjectSetControlBindingDisabledMethodInfo
+    ResolveSystemClockMethod "setControlBindingsDisabled" o = ObjectSetControlBindingsDisabledMethodInfo
+    ResolveSystemClockMethod "setControlRate" o = ObjectSetControlRateMethodInfo
+    ResolveSystemClockMethod "setData" o = GObject.ObjectSetDataMethodInfo
+    ResolveSystemClockMethod "setMaster" o = ClockSetMasterMethodInfo
+    ResolveSystemClockMethod "setName" o = ObjectSetNameMethodInfo
+    ResolveSystemClockMethod "setParent" o = ObjectSetParentMethodInfo
+    ResolveSystemClockMethod "setProperty" o = GObject.ObjectSetPropertyMethodInfo
+    ResolveSystemClockMethod "setResolution" o = ClockSetResolutionMethodInfo
+    ResolveSystemClockMethod "setSynced" o = ClockSetSyncedMethodInfo
+    ResolveSystemClockMethod "setTimeout" o = ClockSetTimeoutMethodInfo
+    ResolveSystemClockMethod l o = MethodResolutionFailed l o
+
+instance (info ~ ResolveSystemClockMethod t SystemClock, MethodInfo info SystemClock p) => IsLabelProxy t (SystemClock -> p) where
+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)
+
+#if MIN_VERSION_base(4,9,0)
+instance (info ~ ResolveSystemClockMethod t SystemClock, MethodInfo info SystemClock p) => IsLabel t (SystemClock -> p) where
+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)
+#endif
+
+-- VVV Prop "clock-type"
+   -- Type: TInterface "Gst" "ClockType"
+   -- Flags: [PropertyReadable,PropertyWritable]
+
+getSystemClockClockType :: (MonadIO m, SystemClockK o) => o -> m ClockType
+getSystemClockClockType obj = liftIO $ getObjectPropertyEnum obj "clock-type"
+
+setSystemClockClockType :: (MonadIO m, SystemClockK o) => o -> ClockType -> m ()
+setSystemClockClockType obj val = liftIO $ setObjectPropertyEnum obj "clock-type" val
+
+constructSystemClockClockType :: ClockType -> IO ([Char], GValue)
+constructSystemClockClockType val = constructObjectPropertyEnum "clock-type" val
+
+data SystemClockClockTypePropertyInfo
+instance AttrInfo SystemClockClockTypePropertyInfo where
+    type AttrAllowedOps SystemClockClockTypePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
+    type AttrSetTypeConstraint SystemClockClockTypePropertyInfo = (~) ClockType
+    type AttrBaseTypeConstraint SystemClockClockTypePropertyInfo = SystemClockK
+    type AttrGetType SystemClockClockTypePropertyInfo = ClockType
+    type AttrLabel SystemClockClockTypePropertyInfo = "clock-type"
+    attrGet _ = getSystemClockClockType
+    attrSet _ = setSystemClockClockType
+    attrConstruct _ = constructSystemClockClockType
+
+type instance AttributeList SystemClock = SystemClockAttributeList
+type SystemClockAttributeList = ('[ '("clockType", SystemClockClockTypePropertyInfo), '("name", ObjectNamePropertyInfo), '("parent", ObjectParentPropertyInfo), '("timeout", ClockTimeoutPropertyInfo), '("windowSize", ClockWindowSizePropertyInfo), '("windowThreshold", ClockWindowThresholdPropertyInfo)] :: [(Symbol, *)])
+
+type instance SignalList SystemClock = SystemClockSignalList
+type SystemClockSignalList = ('[ '("deepNotify", ObjectDeepNotifySignalInfo), '("notify", GObject.ObjectNotifySignalInfo), '("synced", ClockSyncedSignalInfo)] :: [(Symbol, *)])
+
+-- method SystemClock::obtain
+-- method type : MemberFunction
+-- Args : []
+-- Lengths : []
+-- returnType : TInterface "Gst" "Clock"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_system_clock_obtain" gst_system_clock_obtain :: 
+    IO (Ptr Clock)
+
+
+systemClockObtain ::
+    (MonadIO m) =>
+    m Clock                                 -- result
+systemClockObtain  = liftIO $ do
+    result <- gst_system_clock_obtain
+    checkUnexpectedReturnNULL "gst_system_clock_obtain" result
+    result' <- (wrapObject Clock) result
+    return result'
+
+-- method SystemClock::set_default
+-- method type : MemberFunction
+-- Args : [Arg {argCName = "new_clock", argType = TInterface "Gst" "Clock", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_system_clock_set_default" gst_system_clock_set_default :: 
+    Ptr Clock ->                            -- new_clock : TInterface "Gst" "Clock"
+    IO ()
+
+
+systemClockSetDefault ::
+    (MonadIO m, ClockK a) =>
+    a                                       -- newClock
+    -> m ()                                 -- result
+systemClockSetDefault newClock = liftIO $ do
+    let newClock' = unsafeManagedPtrCastPtr newClock
+    gst_system_clock_set_default newClock'
+    touchManagedPtr newClock
+    return ()
+
+
diff --git a/GI/Gst/Objects/SystemClock.hs-boot b/GI/Gst/Objects/SystemClock.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Objects/SystemClock.hs-boot
@@ -0,0 +1,14 @@
+module GI.Gst.Objects.SystemClock where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+newtype SystemClock = SystemClock (ForeignPtr SystemClock)
+instance GObject SystemClock where
+class GObject o => SystemClockK o
+instance (GObject o, IsDescendantOf SystemClock o) => SystemClockK o
+data SystemClockClockTypePropertyInfo
diff --git a/GI/Gst/Objects/Task.hs b/GI/Gst/Objects/Task.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Objects/Task.hs
@@ -0,0 +1,568 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+-}
+
+module GI.Gst.Objects.Task
+    ( 
+
+-- * Exported types
+    Task(..)                                ,
+    TaskK                                   ,
+    toTask                                  ,
+    noTask                                  ,
+
+
+ -- * Methods
+-- ** taskCleanupAll
+    taskCleanupAll                          ,
+
+
+-- ** taskGetPool
+    TaskGetPoolMethodInfo                   ,
+    taskGetPool                             ,
+
+
+-- ** taskGetState
+    TaskGetStateMethodInfo                  ,
+    taskGetState                            ,
+
+
+-- ** taskJoin
+    TaskJoinMethodInfo                      ,
+    taskJoin                                ,
+
+
+-- ** taskNew
+    taskNew                                 ,
+
+
+-- ** taskPause
+    TaskPauseMethodInfo                     ,
+    taskPause                               ,
+
+
+-- ** taskSetEnterCallback
+    TaskSetEnterCallbackMethodInfo          ,
+    taskSetEnterCallback                    ,
+
+
+-- ** taskSetLeaveCallback
+    TaskSetLeaveCallbackMethodInfo          ,
+    taskSetLeaveCallback                    ,
+
+
+-- ** taskSetLock
+    TaskSetLockMethodInfo                   ,
+    taskSetLock                             ,
+
+
+-- ** taskSetPool
+    TaskSetPoolMethodInfo                   ,
+    taskSetPool                             ,
+
+
+-- ** taskSetState
+    TaskSetStateMethodInfo                  ,
+    taskSetState                            ,
+
+
+-- ** taskStart
+    TaskStartMethodInfo                     ,
+    taskStart                               ,
+
+
+-- ** taskStop
+    TaskStopMethodInfo                      ,
+    taskStop                                ,
+
+
+
+
+    ) where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+import GI.Gst.Callbacks
+import qualified GI.GLib as GLib
+import qualified GI.GObject as GObject
+
+newtype Task = Task (ForeignPtr Task)
+foreign import ccall "gst_task_get_type"
+    c_gst_task_get_type :: IO GType
+
+type instance ParentTypes Task = TaskParentTypes
+type TaskParentTypes = '[Object, GObject.Object]
+
+instance GObject Task where
+    gobjectIsInitiallyUnowned _ = True
+    gobjectType _ = c_gst_task_get_type
+    
+
+class GObject o => TaskK o
+instance (GObject o, IsDescendantOf Task o) => TaskK o
+
+toTask :: TaskK o => o -> IO Task
+toTask = unsafeCastTo Task
+
+noTask :: Maybe Task
+noTask = Nothing
+
+type family ResolveTaskMethod (t :: Symbol) (o :: *) :: * where
+    ResolveTaskMethod "addControlBinding" o = ObjectAddControlBindingMethodInfo
+    ResolveTaskMethod "bindProperty" o = GObject.ObjectBindPropertyMethodInfo
+    ResolveTaskMethod "bindPropertyFull" o = GObject.ObjectBindPropertyFullMethodInfo
+    ResolveTaskMethod "defaultError" o = ObjectDefaultErrorMethodInfo
+    ResolveTaskMethod "forceFloating" o = GObject.ObjectForceFloatingMethodInfo
+    ResolveTaskMethod "freezeNotify" o = GObject.ObjectFreezeNotifyMethodInfo
+    ResolveTaskMethod "hasActiveControlBindings" o = ObjectHasActiveControlBindingsMethodInfo
+    ResolveTaskMethod "hasAncestor" o = ObjectHasAncestorMethodInfo
+    ResolveTaskMethod "hasAsAncestor" o = ObjectHasAsAncestorMethodInfo
+    ResolveTaskMethod "hasAsParent" o = ObjectHasAsParentMethodInfo
+    ResolveTaskMethod "isFloating" o = GObject.ObjectIsFloatingMethodInfo
+    ResolveTaskMethod "join" o = TaskJoinMethodInfo
+    ResolveTaskMethod "notify" o = GObject.ObjectNotifyMethodInfo
+    ResolveTaskMethod "notifyByPspec" o = GObject.ObjectNotifyByPspecMethodInfo
+    ResolveTaskMethod "pause" o = TaskPauseMethodInfo
+    ResolveTaskMethod "refSink" o = GObject.ObjectRefSinkMethodInfo
+    ResolveTaskMethod "removeControlBinding" o = ObjectRemoveControlBindingMethodInfo
+    ResolveTaskMethod "replaceData" o = GObject.ObjectReplaceDataMethodInfo
+    ResolveTaskMethod "replaceQdata" o = GObject.ObjectReplaceQdataMethodInfo
+    ResolveTaskMethod "runDispose" o = GObject.ObjectRunDisposeMethodInfo
+    ResolveTaskMethod "start" o = TaskStartMethodInfo
+    ResolveTaskMethod "stealData" o = GObject.ObjectStealDataMethodInfo
+    ResolveTaskMethod "stealQdata" o = GObject.ObjectStealQdataMethodInfo
+    ResolveTaskMethod "stop" o = TaskStopMethodInfo
+    ResolveTaskMethod "suggestNextSync" o = ObjectSuggestNextSyncMethodInfo
+    ResolveTaskMethod "syncValues" o = ObjectSyncValuesMethodInfo
+    ResolveTaskMethod "thawNotify" o = GObject.ObjectThawNotifyMethodInfo
+    ResolveTaskMethod "unparent" o = ObjectUnparentMethodInfo
+    ResolveTaskMethod "watchClosure" o = GObject.ObjectWatchClosureMethodInfo
+    ResolveTaskMethod "getControlBinding" o = ObjectGetControlBindingMethodInfo
+    ResolveTaskMethod "getControlRate" o = ObjectGetControlRateMethodInfo
+    ResolveTaskMethod "getData" o = GObject.ObjectGetDataMethodInfo
+    ResolveTaskMethod "getGValueArray" o = ObjectGetGValueArrayMethodInfo
+    ResolveTaskMethod "getName" o = ObjectGetNameMethodInfo
+    ResolveTaskMethod "getParent" o = ObjectGetParentMethodInfo
+    ResolveTaskMethod "getPathString" o = ObjectGetPathStringMethodInfo
+    ResolveTaskMethod "getPool" o = TaskGetPoolMethodInfo
+    ResolveTaskMethod "getProperty" o = GObject.ObjectGetPropertyMethodInfo
+    ResolveTaskMethod "getQdata" o = GObject.ObjectGetQdataMethodInfo
+    ResolveTaskMethod "getState" o = TaskGetStateMethodInfo
+    ResolveTaskMethod "getValue" o = ObjectGetValueMethodInfo
+    ResolveTaskMethod "getValueArray" o = ObjectGetValueArrayMethodInfo
+    ResolveTaskMethod "setControlBindingDisabled" o = ObjectSetControlBindingDisabledMethodInfo
+    ResolveTaskMethod "setControlBindingsDisabled" o = ObjectSetControlBindingsDisabledMethodInfo
+    ResolveTaskMethod "setControlRate" o = ObjectSetControlRateMethodInfo
+    ResolveTaskMethod "setData" o = GObject.ObjectSetDataMethodInfo
+    ResolveTaskMethod "setEnterCallback" o = TaskSetEnterCallbackMethodInfo
+    ResolveTaskMethod "setLeaveCallback" o = TaskSetLeaveCallbackMethodInfo
+    ResolveTaskMethod "setLock" o = TaskSetLockMethodInfo
+    ResolveTaskMethod "setName" o = ObjectSetNameMethodInfo
+    ResolveTaskMethod "setParent" o = ObjectSetParentMethodInfo
+    ResolveTaskMethod "setPool" o = TaskSetPoolMethodInfo
+    ResolveTaskMethod "setProperty" o = GObject.ObjectSetPropertyMethodInfo
+    ResolveTaskMethod "setState" o = TaskSetStateMethodInfo
+    ResolveTaskMethod l o = MethodResolutionFailed l o
+
+instance (info ~ ResolveTaskMethod t Task, MethodInfo info Task p) => IsLabelProxy t (Task -> p) where
+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)
+
+#if MIN_VERSION_base(4,9,0)
+instance (info ~ ResolveTaskMethod t Task, MethodInfo info Task p) => IsLabel t (Task -> p) where
+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)
+#endif
+
+type instance AttributeList Task = TaskAttributeList
+type TaskAttributeList = ('[ '("name", ObjectNamePropertyInfo), '("parent", ObjectParentPropertyInfo)] :: [(Symbol, *)])
+
+type instance SignalList Task = TaskSignalList
+type TaskSignalList = ('[ '("deepNotify", ObjectDeepNotifySignalInfo), '("notify", GObject.ObjectNotifySignalInfo)] :: [(Symbol, *)])
+
+-- method Task::new
+-- method type : Constructor
+-- Args : [Arg {argCName = "func", argType = TInterface "Gst" "TaskFunction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeNotified, argClosure = 1, argDestroy = 2, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "notify", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Task"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_task_new" gst_task_new :: 
+    FunPtr TaskFunctionC ->                 -- func : TInterface "Gst" "TaskFunction"
+    Ptr () ->                               -- user_data : TBasicType TVoid
+    FunPtr GLib.DestroyNotifyC ->           -- notify : TInterface "GLib" "DestroyNotify"
+    IO (Ptr Task)
+
+
+taskNew ::
+    (MonadIO m) =>
+    TaskFunction                            -- func
+    -> m Task                               -- result
+taskNew func = liftIO $ do
+    func' <- mkTaskFunction (taskFunctionWrapper Nothing func)
+    let userData = castFunPtrToPtr func'
+    let notify = safeFreeFunPtrPtr
+    result <- gst_task_new func' userData notify
+    checkUnexpectedReturnNULL "gst_task_new" result
+    result' <- (wrapObject Task) result
+    return result'
+
+-- method Task::get_pool
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Task", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "TaskPool"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_task_get_pool" gst_task_get_pool :: 
+    Ptr Task ->                             -- _obj : TInterface "Gst" "Task"
+    IO (Ptr TaskPool)
+
+
+taskGetPool ::
+    (MonadIO m, TaskK a) =>
+    a                                       -- _obj
+    -> m TaskPool                           -- result
+taskGetPool _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_task_get_pool _obj'
+    checkUnexpectedReturnNULL "gst_task_get_pool" result
+    result' <- (wrapObject TaskPool) result
+    touchManagedPtr _obj
+    return result'
+
+data TaskGetPoolMethodInfo
+instance (signature ~ (m TaskPool), MonadIO m, TaskK a) => MethodInfo TaskGetPoolMethodInfo a signature where
+    overloadedMethod _ = taskGetPool
+
+-- method Task::get_state
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Task", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "TaskState"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_task_get_state" gst_task_get_state :: 
+    Ptr Task ->                             -- _obj : TInterface "Gst" "Task"
+    IO CUInt
+
+
+taskGetState ::
+    (MonadIO m, TaskK a) =>
+    a                                       -- _obj
+    -> m TaskState                          -- result
+taskGetState _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_task_get_state _obj'
+    let result' = (toEnum . fromIntegral) result
+    touchManagedPtr _obj
+    return result'
+
+data TaskGetStateMethodInfo
+instance (signature ~ (m TaskState), MonadIO m, TaskK a) => MethodInfo TaskGetStateMethodInfo a signature where
+    overloadedMethod _ = taskGetState
+
+-- method Task::join
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Task", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_task_join" gst_task_join :: 
+    Ptr Task ->                             -- _obj : TInterface "Gst" "Task"
+    IO CInt
+
+
+taskJoin ::
+    (MonadIO m, TaskK a) =>
+    a                                       -- _obj
+    -> m Bool                               -- result
+taskJoin _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_task_join _obj'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data TaskJoinMethodInfo
+instance (signature ~ (m Bool), MonadIO m, TaskK a) => MethodInfo TaskJoinMethodInfo a signature where
+    overloadedMethod _ = taskJoin
+
+-- method Task::pause
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Task", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_task_pause" gst_task_pause :: 
+    Ptr Task ->                             -- _obj : TInterface "Gst" "Task"
+    IO CInt
+
+
+taskPause ::
+    (MonadIO m, TaskK a) =>
+    a                                       -- _obj
+    -> m Bool                               -- result
+taskPause _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_task_pause _obj'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data TaskPauseMethodInfo
+instance (signature ~ (m Bool), MonadIO m, TaskK a) => MethodInfo TaskPauseMethodInfo a signature where
+    overloadedMethod _ = taskPause
+
+-- method Task::set_enter_callback
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Task", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "enter_func", argType = TInterface "Gst" "TaskThreadFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "notify", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_task_set_enter_callback" gst_task_set_enter_callback :: 
+    Ptr Task ->                             -- _obj : TInterface "Gst" "Task"
+    FunPtr TaskThreadFuncC ->               -- enter_func : TInterface "Gst" "TaskThreadFunc"
+    Ptr () ->                               -- user_data : TBasicType TVoid
+    FunPtr GLib.DestroyNotifyC ->           -- notify : TInterface "GLib" "DestroyNotify"
+    IO ()
+
+
+taskSetEnterCallback ::
+    (MonadIO m, TaskK a) =>
+    a                                       -- _obj
+    -> TaskThreadFunc                       -- enterFunc
+    -> m ()                                 -- result
+taskSetEnterCallback _obj enterFunc = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    enterFunc' <- mkTaskThreadFunc (taskThreadFuncWrapper Nothing enterFunc)
+    let userData = castFunPtrToPtr enterFunc'
+    let notify = safeFreeFunPtrPtr
+    gst_task_set_enter_callback _obj' enterFunc' userData notify
+    touchManagedPtr _obj
+    return ()
+
+data TaskSetEnterCallbackMethodInfo
+instance (signature ~ (TaskThreadFunc -> m ()), MonadIO m, TaskK a) => MethodInfo TaskSetEnterCallbackMethodInfo a signature where
+    overloadedMethod _ = taskSetEnterCallback
+
+-- method Task::set_leave_callback
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Task", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "leave_func", argType = TInterface "Gst" "TaskThreadFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "notify", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_task_set_leave_callback" gst_task_set_leave_callback :: 
+    Ptr Task ->                             -- _obj : TInterface "Gst" "Task"
+    FunPtr TaskThreadFuncC ->               -- leave_func : TInterface "Gst" "TaskThreadFunc"
+    Ptr () ->                               -- user_data : TBasicType TVoid
+    FunPtr GLib.DestroyNotifyC ->           -- notify : TInterface "GLib" "DestroyNotify"
+    IO ()
+
+
+taskSetLeaveCallback ::
+    (MonadIO m, TaskK a) =>
+    a                                       -- _obj
+    -> TaskThreadFunc                       -- leaveFunc
+    -> m ()                                 -- result
+taskSetLeaveCallback _obj leaveFunc = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    leaveFunc' <- mkTaskThreadFunc (taskThreadFuncWrapper Nothing leaveFunc)
+    let userData = castFunPtrToPtr leaveFunc'
+    let notify = safeFreeFunPtrPtr
+    gst_task_set_leave_callback _obj' leaveFunc' userData notify
+    touchManagedPtr _obj
+    return ()
+
+data TaskSetLeaveCallbackMethodInfo
+instance (signature ~ (TaskThreadFunc -> m ()), MonadIO m, TaskK a) => MethodInfo TaskSetLeaveCallbackMethodInfo a signature where
+    overloadedMethod _ = taskSetLeaveCallback
+
+-- method Task::set_lock
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Task", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mutex", argType = TInterface "GLib" "RecMutex", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_task_set_lock" gst_task_set_lock :: 
+    Ptr Task ->                             -- _obj : TInterface "Gst" "Task"
+    Ptr GLib.RecMutex ->                    -- mutex : TInterface "GLib" "RecMutex"
+    IO ()
+
+
+taskSetLock ::
+    (MonadIO m, TaskK a) =>
+    a                                       -- _obj
+    -> GLib.RecMutex                        -- mutex
+    -> m ()                                 -- result
+taskSetLock _obj mutex = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let mutex' = unsafeManagedPtrGetPtr mutex
+    gst_task_set_lock _obj' mutex'
+    touchManagedPtr _obj
+    touchManagedPtr mutex
+    return ()
+
+data TaskSetLockMethodInfo
+instance (signature ~ (GLib.RecMutex -> m ()), MonadIO m, TaskK a) => MethodInfo TaskSetLockMethodInfo a signature where
+    overloadedMethod _ = taskSetLock
+
+-- method Task::set_pool
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Task", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pool", argType = TInterface "Gst" "TaskPool", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_task_set_pool" gst_task_set_pool :: 
+    Ptr Task ->                             -- _obj : TInterface "Gst" "Task"
+    Ptr TaskPool ->                         -- pool : TInterface "Gst" "TaskPool"
+    IO ()
+
+
+taskSetPool ::
+    (MonadIO m, TaskK a, TaskPoolK b) =>
+    a                                       -- _obj
+    -> b                                    -- pool
+    -> m ()                                 -- result
+taskSetPool _obj pool = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let pool' = unsafeManagedPtrCastPtr pool
+    gst_task_set_pool _obj' pool'
+    touchManagedPtr _obj
+    touchManagedPtr pool
+    return ()
+
+data TaskSetPoolMethodInfo
+instance (signature ~ (b -> m ()), MonadIO m, TaskK a, TaskPoolK b) => MethodInfo TaskSetPoolMethodInfo a signature where
+    overloadedMethod _ = taskSetPool
+
+-- method Task::set_state
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Task", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "state", argType = TInterface "Gst" "TaskState", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_task_set_state" gst_task_set_state :: 
+    Ptr Task ->                             -- _obj : TInterface "Gst" "Task"
+    CUInt ->                                -- state : TInterface "Gst" "TaskState"
+    IO CInt
+
+
+taskSetState ::
+    (MonadIO m, TaskK a) =>
+    a                                       -- _obj
+    -> TaskState                            -- state
+    -> m Bool                               -- result
+taskSetState _obj state = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let state' = (fromIntegral . fromEnum) state
+    result <- gst_task_set_state _obj' state'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data TaskSetStateMethodInfo
+instance (signature ~ (TaskState -> m Bool), MonadIO m, TaskK a) => MethodInfo TaskSetStateMethodInfo a signature where
+    overloadedMethod _ = taskSetState
+
+-- method Task::start
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Task", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_task_start" gst_task_start :: 
+    Ptr Task ->                             -- _obj : TInterface "Gst" "Task"
+    IO CInt
+
+
+taskStart ::
+    (MonadIO m, TaskK a) =>
+    a                                       -- _obj
+    -> m Bool                               -- result
+taskStart _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_task_start _obj'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data TaskStartMethodInfo
+instance (signature ~ (m Bool), MonadIO m, TaskK a) => MethodInfo TaskStartMethodInfo a signature where
+    overloadedMethod _ = taskStart
+
+-- method Task::stop
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Task", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_task_stop" gst_task_stop :: 
+    Ptr Task ->                             -- _obj : TInterface "Gst" "Task"
+    IO CInt
+
+
+taskStop ::
+    (MonadIO m, TaskK a) =>
+    a                                       -- _obj
+    -> m Bool                               -- result
+taskStop _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_task_stop _obj'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data TaskStopMethodInfo
+instance (signature ~ (m Bool), MonadIO m, TaskK a) => MethodInfo TaskStopMethodInfo a signature where
+    overloadedMethod _ = taskStop
+
+-- method Task::cleanup_all
+-- method type : MemberFunction
+-- Args : []
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_task_cleanup_all" gst_task_cleanup_all :: 
+    IO ()
+
+
+taskCleanupAll ::
+    (MonadIO m) =>
+    m ()                                    -- result
+taskCleanupAll  = liftIO $ do
+    gst_task_cleanup_all
+    return ()
+
+
diff --git a/GI/Gst/Objects/Task.hs-boot b/GI/Gst/Objects/Task.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Objects/Task.hs-boot
@@ -0,0 +1,24 @@
+module GI.Gst.Objects.Task where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+newtype Task = Task (ForeignPtr Task)
+instance GObject Task where
+class GObject o => TaskK o
+instance (GObject o, IsDescendantOf Task o) => TaskK o
+data TaskGetPoolMethodInfo
+data TaskGetStateMethodInfo
+data TaskJoinMethodInfo
+data TaskPauseMethodInfo
+data TaskSetEnterCallbackMethodInfo
+data TaskSetLeaveCallbackMethodInfo
+data TaskSetLockMethodInfo
+data TaskSetPoolMethodInfo
+data TaskSetStateMethodInfo
+data TaskStartMethodInfo
+data TaskStopMethodInfo
diff --git a/GI/Gst/Objects/TaskPool.hs b/GI/Gst/Objects/TaskPool.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Objects/TaskPool.hs
@@ -0,0 +1,292 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+-}
+
+module GI.Gst.Objects.TaskPool
+    ( 
+
+-- * Exported types
+    TaskPool(..)                            ,
+    TaskPoolK                               ,
+    toTaskPool                              ,
+    noTaskPool                              ,
+
+
+ -- * Methods
+-- ** taskPoolCleanup
+    TaskPoolCleanupMethodInfo               ,
+    taskPoolCleanup                         ,
+
+
+-- ** taskPoolJoin
+    TaskPoolJoinMethodInfo                  ,
+    taskPoolJoin                            ,
+
+
+-- ** taskPoolNew
+    taskPoolNew                             ,
+
+
+-- ** taskPoolPrepare
+    TaskPoolPrepareMethodInfo               ,
+    taskPoolPrepare                         ,
+
+
+-- ** taskPoolPush
+    TaskPoolPushMethodInfo                  ,
+    taskPoolPush                            ,
+
+
+
+
+    ) where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+import GI.Gst.Callbacks
+import qualified GI.GObject as GObject
+
+newtype TaskPool = TaskPool (ForeignPtr TaskPool)
+foreign import ccall "gst_task_pool_get_type"
+    c_gst_task_pool_get_type :: IO GType
+
+type instance ParentTypes TaskPool = TaskPoolParentTypes
+type TaskPoolParentTypes = '[Object, GObject.Object]
+
+instance GObject TaskPool where
+    gobjectIsInitiallyUnowned _ = True
+    gobjectType _ = c_gst_task_pool_get_type
+    
+
+class GObject o => TaskPoolK o
+instance (GObject o, IsDescendantOf TaskPool o) => TaskPoolK o
+
+toTaskPool :: TaskPoolK o => o -> IO TaskPool
+toTaskPool = unsafeCastTo TaskPool
+
+noTaskPool :: Maybe TaskPool
+noTaskPool = Nothing
+
+type family ResolveTaskPoolMethod (t :: Symbol) (o :: *) :: * where
+    ResolveTaskPoolMethod "addControlBinding" o = ObjectAddControlBindingMethodInfo
+    ResolveTaskPoolMethod "bindProperty" o = GObject.ObjectBindPropertyMethodInfo
+    ResolveTaskPoolMethod "bindPropertyFull" o = GObject.ObjectBindPropertyFullMethodInfo
+    ResolveTaskPoolMethod "cleanup" o = TaskPoolCleanupMethodInfo
+    ResolveTaskPoolMethod "defaultError" o = ObjectDefaultErrorMethodInfo
+    ResolveTaskPoolMethod "forceFloating" o = GObject.ObjectForceFloatingMethodInfo
+    ResolveTaskPoolMethod "freezeNotify" o = GObject.ObjectFreezeNotifyMethodInfo
+    ResolveTaskPoolMethod "hasActiveControlBindings" o = ObjectHasActiveControlBindingsMethodInfo
+    ResolveTaskPoolMethod "hasAncestor" o = ObjectHasAncestorMethodInfo
+    ResolveTaskPoolMethod "hasAsAncestor" o = ObjectHasAsAncestorMethodInfo
+    ResolveTaskPoolMethod "hasAsParent" o = ObjectHasAsParentMethodInfo
+    ResolveTaskPoolMethod "isFloating" o = GObject.ObjectIsFloatingMethodInfo
+    ResolveTaskPoolMethod "join" o = TaskPoolJoinMethodInfo
+    ResolveTaskPoolMethod "notify" o = GObject.ObjectNotifyMethodInfo
+    ResolveTaskPoolMethod "notifyByPspec" o = GObject.ObjectNotifyByPspecMethodInfo
+    ResolveTaskPoolMethod "prepare" o = TaskPoolPrepareMethodInfo
+    ResolveTaskPoolMethod "push" o = TaskPoolPushMethodInfo
+    ResolveTaskPoolMethod "refSink" o = GObject.ObjectRefSinkMethodInfo
+    ResolveTaskPoolMethod "removeControlBinding" o = ObjectRemoveControlBindingMethodInfo
+    ResolveTaskPoolMethod "replaceData" o = GObject.ObjectReplaceDataMethodInfo
+    ResolveTaskPoolMethod "replaceQdata" o = GObject.ObjectReplaceQdataMethodInfo
+    ResolveTaskPoolMethod "runDispose" o = GObject.ObjectRunDisposeMethodInfo
+    ResolveTaskPoolMethod "stealData" o = GObject.ObjectStealDataMethodInfo
+    ResolveTaskPoolMethod "stealQdata" o = GObject.ObjectStealQdataMethodInfo
+    ResolveTaskPoolMethod "suggestNextSync" o = ObjectSuggestNextSyncMethodInfo
+    ResolveTaskPoolMethod "syncValues" o = ObjectSyncValuesMethodInfo
+    ResolveTaskPoolMethod "thawNotify" o = GObject.ObjectThawNotifyMethodInfo
+    ResolveTaskPoolMethod "unparent" o = ObjectUnparentMethodInfo
+    ResolveTaskPoolMethod "watchClosure" o = GObject.ObjectWatchClosureMethodInfo
+    ResolveTaskPoolMethod "getControlBinding" o = ObjectGetControlBindingMethodInfo
+    ResolveTaskPoolMethod "getControlRate" o = ObjectGetControlRateMethodInfo
+    ResolveTaskPoolMethod "getData" o = GObject.ObjectGetDataMethodInfo
+    ResolveTaskPoolMethod "getGValueArray" o = ObjectGetGValueArrayMethodInfo
+    ResolveTaskPoolMethod "getName" o = ObjectGetNameMethodInfo
+    ResolveTaskPoolMethod "getParent" o = ObjectGetParentMethodInfo
+    ResolveTaskPoolMethod "getPathString" o = ObjectGetPathStringMethodInfo
+    ResolveTaskPoolMethod "getProperty" o = GObject.ObjectGetPropertyMethodInfo
+    ResolveTaskPoolMethod "getQdata" o = GObject.ObjectGetQdataMethodInfo
+    ResolveTaskPoolMethod "getValue" o = ObjectGetValueMethodInfo
+    ResolveTaskPoolMethod "getValueArray" o = ObjectGetValueArrayMethodInfo
+    ResolveTaskPoolMethod "setControlBindingDisabled" o = ObjectSetControlBindingDisabledMethodInfo
+    ResolveTaskPoolMethod "setControlBindingsDisabled" o = ObjectSetControlBindingsDisabledMethodInfo
+    ResolveTaskPoolMethod "setControlRate" o = ObjectSetControlRateMethodInfo
+    ResolveTaskPoolMethod "setData" o = GObject.ObjectSetDataMethodInfo
+    ResolveTaskPoolMethod "setName" o = ObjectSetNameMethodInfo
+    ResolveTaskPoolMethod "setParent" o = ObjectSetParentMethodInfo
+    ResolveTaskPoolMethod "setProperty" o = GObject.ObjectSetPropertyMethodInfo
+    ResolveTaskPoolMethod l o = MethodResolutionFailed l o
+
+instance (info ~ ResolveTaskPoolMethod t TaskPool, MethodInfo info TaskPool p) => IsLabelProxy t (TaskPool -> p) where
+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)
+
+#if MIN_VERSION_base(4,9,0)
+instance (info ~ ResolveTaskPoolMethod t TaskPool, MethodInfo info TaskPool p) => IsLabel t (TaskPool -> p) where
+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)
+#endif
+
+type instance AttributeList TaskPool = TaskPoolAttributeList
+type TaskPoolAttributeList = ('[ '("name", ObjectNamePropertyInfo), '("parent", ObjectParentPropertyInfo)] :: [(Symbol, *)])
+
+type instance SignalList TaskPool = TaskPoolSignalList
+type TaskPoolSignalList = ('[ '("deepNotify", ObjectDeepNotifySignalInfo), '("notify", GObject.ObjectNotifySignalInfo)] :: [(Symbol, *)])
+
+-- method TaskPool::new
+-- method type : Constructor
+-- Args : []
+-- Lengths : []
+-- returnType : TInterface "Gst" "TaskPool"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_task_pool_new" gst_task_pool_new :: 
+    IO (Ptr TaskPool)
+
+
+taskPoolNew ::
+    (MonadIO m) =>
+    m TaskPool                              -- result
+taskPoolNew  = liftIO $ do
+    result <- gst_task_pool_new
+    checkUnexpectedReturnNULL "gst_task_pool_new" result
+    result' <- (wrapObject TaskPool) result
+    return result'
+
+-- method TaskPool::cleanup
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TaskPool", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_task_pool_cleanup" gst_task_pool_cleanup :: 
+    Ptr TaskPool ->                         -- _obj : TInterface "Gst" "TaskPool"
+    IO ()
+
+
+taskPoolCleanup ::
+    (MonadIO m, TaskPoolK a) =>
+    a                                       -- _obj
+    -> m ()                                 -- result
+taskPoolCleanup _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    gst_task_pool_cleanup _obj'
+    touchManagedPtr _obj
+    return ()
+
+data TaskPoolCleanupMethodInfo
+instance (signature ~ (m ()), MonadIO m, TaskPoolK a) => MethodInfo TaskPoolCleanupMethodInfo a signature where
+    overloadedMethod _ = taskPoolCleanup
+
+-- method TaskPool::join
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TaskPool", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "id", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_task_pool_join" gst_task_pool_join :: 
+    Ptr TaskPool ->                         -- _obj : TInterface "Gst" "TaskPool"
+    Ptr () ->                               -- id : TBasicType TVoid
+    IO ()
+
+
+taskPoolJoin ::
+    (MonadIO m, TaskPoolK a) =>
+    a                                       -- _obj
+    -> Ptr ()                               -- id
+    -> m ()                                 -- result
+taskPoolJoin _obj id = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    gst_task_pool_join _obj' id
+    touchManagedPtr _obj
+    return ()
+
+data TaskPoolJoinMethodInfo
+instance (signature ~ (Ptr () -> m ()), MonadIO m, TaskPoolK a) => MethodInfo TaskPoolJoinMethodInfo a signature where
+    overloadedMethod _ = taskPoolJoin
+
+-- method TaskPool::prepare
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TaskPool", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : True
+-- Skip return : False
+
+foreign import ccall "gst_task_pool_prepare" gst_task_pool_prepare :: 
+    Ptr TaskPool ->                         -- _obj : TInterface "Gst" "TaskPool"
+    Ptr (Ptr GError) ->                     -- error
+    IO ()
+
+
+taskPoolPrepare ::
+    (MonadIO m, TaskPoolK a) =>
+    a                                       -- _obj
+    -> m ()                                 -- result
+taskPoolPrepare _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    onException (do
+        propagateGError $ gst_task_pool_prepare _obj'
+        touchManagedPtr _obj
+        return ()
+     ) (do
+        return ()
+     )
+
+data TaskPoolPrepareMethodInfo
+instance (signature ~ (m ()), MonadIO m, TaskPoolK a) => MethodInfo TaskPoolPrepareMethodInfo a signature where
+    overloadedMethod _ = taskPoolPrepare
+
+-- method TaskPool::push
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TaskPool", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "func", argType = TInterface "Gst" "TaskPoolFunction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : True
+-- Skip return : False
+
+foreign import ccall "gst_task_pool_push" gst_task_pool_push :: 
+    Ptr TaskPool ->                         -- _obj : TInterface "Gst" "TaskPool"
+    FunPtr TaskPoolFunctionC ->             -- func : TInterface "Gst" "TaskPoolFunction"
+    Ptr () ->                               -- user_data : TBasicType TVoid
+    Ptr (Ptr GError) ->                     -- error
+    IO ()
+
+
+taskPoolPush ::
+    (MonadIO m, TaskPoolK a) =>
+    a                                       -- _obj
+    -> TaskPoolFunction                     -- func
+    -> m ()                                 -- result
+taskPoolPush _obj func = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    ptrfunc <- callocMem :: IO (Ptr (FunPtr TaskPoolFunctionC))
+    func' <- mkTaskPoolFunction (taskPoolFunctionWrapper (Just ptrfunc) func)
+    poke ptrfunc func'
+    let userData = nullPtr
+    onException (do
+        propagateGError $ gst_task_pool_push _obj' func' userData
+        touchManagedPtr _obj
+        return ()
+     ) (do
+        return ()
+     )
+
+data TaskPoolPushMethodInfo
+instance (signature ~ (TaskPoolFunction -> m ()), MonadIO m, TaskPoolK a) => MethodInfo TaskPoolPushMethodInfo a signature where
+    overloadedMethod _ = taskPoolPush
+
+
diff --git a/GI/Gst/Objects/TaskPool.hs-boot b/GI/Gst/Objects/TaskPool.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Objects/TaskPool.hs-boot
@@ -0,0 +1,17 @@
+module GI.Gst.Objects.TaskPool where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+newtype TaskPool = TaskPool (ForeignPtr TaskPool)
+instance GObject TaskPool where
+class GObject o => TaskPoolK o
+instance (GObject o, IsDescendantOf TaskPool o) => TaskPoolK o
+data TaskPoolCleanupMethodInfo
+data TaskPoolJoinMethodInfo
+data TaskPoolPrepareMethodInfo
+data TaskPoolPushMethodInfo
diff --git a/GI/Gst/Objects/TypeFindFactory.hs b/GI/Gst/Objects/TypeFindFactory.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Objects/TypeFindFactory.hs
@@ -0,0 +1,290 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+-}
+
+module GI.Gst.Objects.TypeFindFactory
+    ( 
+
+-- * Exported types
+    TypeFindFactory(..)                     ,
+    TypeFindFactoryK                        ,
+    toTypeFindFactory                       ,
+    noTypeFindFactory                       ,
+
+
+ -- * Methods
+-- ** typeFindFactoryCallFunction
+    TypeFindFactoryCallFunctionMethodInfo   ,
+    typeFindFactoryCallFunction             ,
+
+
+-- ** typeFindFactoryGetCaps
+    TypeFindFactoryGetCapsMethodInfo        ,
+    typeFindFactoryGetCaps                  ,
+
+
+-- ** typeFindFactoryGetExtensions
+    TypeFindFactoryGetExtensionsMethodInfo  ,
+    typeFindFactoryGetExtensions            ,
+
+
+-- ** typeFindFactoryGetList
+    typeFindFactoryGetList                  ,
+
+
+-- ** typeFindFactoryHasFunction
+    TypeFindFactoryHasFunctionMethodInfo    ,
+    typeFindFactoryHasFunction              ,
+
+
+
+
+    ) where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+import GI.Gst.Callbacks
+import qualified GI.GObject as GObject
+
+newtype TypeFindFactory = TypeFindFactory (ForeignPtr TypeFindFactory)
+foreign import ccall "gst_type_find_factory_get_type"
+    c_gst_type_find_factory_get_type :: IO GType
+
+type instance ParentTypes TypeFindFactory = TypeFindFactoryParentTypes
+type TypeFindFactoryParentTypes = '[PluginFeature, Object, GObject.Object]
+
+instance GObject TypeFindFactory where
+    gobjectIsInitiallyUnowned _ = True
+    gobjectType _ = c_gst_type_find_factory_get_type
+    
+
+class GObject o => TypeFindFactoryK o
+instance (GObject o, IsDescendantOf TypeFindFactory o) => TypeFindFactoryK o
+
+toTypeFindFactory :: TypeFindFactoryK o => o -> IO TypeFindFactory
+toTypeFindFactory = unsafeCastTo TypeFindFactory
+
+noTypeFindFactory :: Maybe TypeFindFactory
+noTypeFindFactory = Nothing
+
+type family ResolveTypeFindFactoryMethod (t :: Symbol) (o :: *) :: * where
+    ResolveTypeFindFactoryMethod "addControlBinding" o = ObjectAddControlBindingMethodInfo
+    ResolveTypeFindFactoryMethod "bindProperty" o = GObject.ObjectBindPropertyMethodInfo
+    ResolveTypeFindFactoryMethod "bindPropertyFull" o = GObject.ObjectBindPropertyFullMethodInfo
+    ResolveTypeFindFactoryMethod "callFunction" o = TypeFindFactoryCallFunctionMethodInfo
+    ResolveTypeFindFactoryMethod "checkVersion" o = PluginFeatureCheckVersionMethodInfo
+    ResolveTypeFindFactoryMethod "defaultError" o = ObjectDefaultErrorMethodInfo
+    ResolveTypeFindFactoryMethod "forceFloating" o = GObject.ObjectForceFloatingMethodInfo
+    ResolveTypeFindFactoryMethod "freezeNotify" o = GObject.ObjectFreezeNotifyMethodInfo
+    ResolveTypeFindFactoryMethod "hasActiveControlBindings" o = ObjectHasActiveControlBindingsMethodInfo
+    ResolveTypeFindFactoryMethod "hasAncestor" o = ObjectHasAncestorMethodInfo
+    ResolveTypeFindFactoryMethod "hasAsAncestor" o = ObjectHasAsAncestorMethodInfo
+    ResolveTypeFindFactoryMethod "hasAsParent" o = ObjectHasAsParentMethodInfo
+    ResolveTypeFindFactoryMethod "hasFunction" o = TypeFindFactoryHasFunctionMethodInfo
+    ResolveTypeFindFactoryMethod "isFloating" o = GObject.ObjectIsFloatingMethodInfo
+    ResolveTypeFindFactoryMethod "load" o = PluginFeatureLoadMethodInfo
+    ResolveTypeFindFactoryMethod "notify" o = GObject.ObjectNotifyMethodInfo
+    ResolveTypeFindFactoryMethod "notifyByPspec" o = GObject.ObjectNotifyByPspecMethodInfo
+    ResolveTypeFindFactoryMethod "refSink" o = GObject.ObjectRefSinkMethodInfo
+    ResolveTypeFindFactoryMethod "removeControlBinding" o = ObjectRemoveControlBindingMethodInfo
+    ResolveTypeFindFactoryMethod "replaceData" o = GObject.ObjectReplaceDataMethodInfo
+    ResolveTypeFindFactoryMethod "replaceQdata" o = GObject.ObjectReplaceQdataMethodInfo
+    ResolveTypeFindFactoryMethod "runDispose" o = GObject.ObjectRunDisposeMethodInfo
+    ResolveTypeFindFactoryMethod "stealData" o = GObject.ObjectStealDataMethodInfo
+    ResolveTypeFindFactoryMethod "stealQdata" o = GObject.ObjectStealQdataMethodInfo
+    ResolveTypeFindFactoryMethod "suggestNextSync" o = ObjectSuggestNextSyncMethodInfo
+    ResolveTypeFindFactoryMethod "syncValues" o = ObjectSyncValuesMethodInfo
+    ResolveTypeFindFactoryMethod "thawNotify" o = GObject.ObjectThawNotifyMethodInfo
+    ResolveTypeFindFactoryMethod "unparent" o = ObjectUnparentMethodInfo
+    ResolveTypeFindFactoryMethod "watchClosure" o = GObject.ObjectWatchClosureMethodInfo
+    ResolveTypeFindFactoryMethod "getCaps" o = TypeFindFactoryGetCapsMethodInfo
+    ResolveTypeFindFactoryMethod "getControlBinding" o = ObjectGetControlBindingMethodInfo
+    ResolveTypeFindFactoryMethod "getControlRate" o = ObjectGetControlRateMethodInfo
+    ResolveTypeFindFactoryMethod "getData" o = GObject.ObjectGetDataMethodInfo
+    ResolveTypeFindFactoryMethod "getExtensions" o = TypeFindFactoryGetExtensionsMethodInfo
+    ResolveTypeFindFactoryMethod "getGValueArray" o = ObjectGetGValueArrayMethodInfo
+    ResolveTypeFindFactoryMethod "getName" o = ObjectGetNameMethodInfo
+    ResolveTypeFindFactoryMethod "getParent" o = ObjectGetParentMethodInfo
+    ResolveTypeFindFactoryMethod "getPathString" o = ObjectGetPathStringMethodInfo
+    ResolveTypeFindFactoryMethod "getPlugin" o = PluginFeatureGetPluginMethodInfo
+    ResolveTypeFindFactoryMethod "getPluginName" o = PluginFeatureGetPluginNameMethodInfo
+    ResolveTypeFindFactoryMethod "getProperty" o = GObject.ObjectGetPropertyMethodInfo
+    ResolveTypeFindFactoryMethod "getQdata" o = GObject.ObjectGetQdataMethodInfo
+    ResolveTypeFindFactoryMethod "getRank" o = PluginFeatureGetRankMethodInfo
+    ResolveTypeFindFactoryMethod "getValue" o = ObjectGetValueMethodInfo
+    ResolveTypeFindFactoryMethod "getValueArray" o = ObjectGetValueArrayMethodInfo
+    ResolveTypeFindFactoryMethod "setControlBindingDisabled" o = ObjectSetControlBindingDisabledMethodInfo
+    ResolveTypeFindFactoryMethod "setControlBindingsDisabled" o = ObjectSetControlBindingsDisabledMethodInfo
+    ResolveTypeFindFactoryMethod "setControlRate" o = ObjectSetControlRateMethodInfo
+    ResolveTypeFindFactoryMethod "setData" o = GObject.ObjectSetDataMethodInfo
+    ResolveTypeFindFactoryMethod "setName" o = ObjectSetNameMethodInfo
+    ResolveTypeFindFactoryMethod "setParent" o = ObjectSetParentMethodInfo
+    ResolveTypeFindFactoryMethod "setProperty" o = GObject.ObjectSetPropertyMethodInfo
+    ResolveTypeFindFactoryMethod "setRank" o = PluginFeatureSetRankMethodInfo
+    ResolveTypeFindFactoryMethod l o = MethodResolutionFailed l o
+
+instance (info ~ ResolveTypeFindFactoryMethod t TypeFindFactory, MethodInfo info TypeFindFactory p) => IsLabelProxy t (TypeFindFactory -> p) where
+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)
+
+#if MIN_VERSION_base(4,9,0)
+instance (info ~ ResolveTypeFindFactoryMethod t TypeFindFactory, MethodInfo info TypeFindFactory p) => IsLabel t (TypeFindFactory -> p) where
+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)
+#endif
+
+type instance AttributeList TypeFindFactory = TypeFindFactoryAttributeList
+type TypeFindFactoryAttributeList = ('[ '("name", ObjectNamePropertyInfo), '("parent", ObjectParentPropertyInfo)] :: [(Symbol, *)])
+
+type instance SignalList TypeFindFactory = TypeFindFactorySignalList
+type TypeFindFactorySignalList = ('[ '("deepNotify", ObjectDeepNotifySignalInfo), '("notify", GObject.ObjectNotifySignalInfo)] :: [(Symbol, *)])
+
+-- method TypeFindFactory::call_function
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TypeFindFactory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "find", argType = TInterface "Gst" "TypeFind", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_type_find_factory_call_function" gst_type_find_factory_call_function :: 
+    Ptr TypeFindFactory ->                  -- _obj : TInterface "Gst" "TypeFindFactory"
+    Ptr TypeFind ->                         -- find : TInterface "Gst" "TypeFind"
+    IO ()
+
+
+typeFindFactoryCallFunction ::
+    (MonadIO m, TypeFindFactoryK a) =>
+    a                                       -- _obj
+    -> TypeFind                             -- find
+    -> m ()                                 -- result
+typeFindFactoryCallFunction _obj find = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    let find' = unsafeManagedPtrGetPtr find
+    gst_type_find_factory_call_function _obj' find'
+    touchManagedPtr _obj
+    touchManagedPtr find
+    return ()
+
+data TypeFindFactoryCallFunctionMethodInfo
+instance (signature ~ (TypeFind -> m ()), MonadIO m, TypeFindFactoryK a) => MethodInfo TypeFindFactoryCallFunctionMethodInfo a signature where
+    overloadedMethod _ = typeFindFactoryCallFunction
+
+-- method TypeFindFactory::get_caps
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TypeFindFactory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Caps"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_type_find_factory_get_caps" gst_type_find_factory_get_caps :: 
+    Ptr TypeFindFactory ->                  -- _obj : TInterface "Gst" "TypeFindFactory"
+    IO (Ptr Caps)
+
+
+typeFindFactoryGetCaps ::
+    (MonadIO m, TypeFindFactoryK a) =>
+    a                                       -- _obj
+    -> m Caps                               -- result
+typeFindFactoryGetCaps _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_type_find_factory_get_caps _obj'
+    checkUnexpectedReturnNULL "gst_type_find_factory_get_caps" result
+    result' <- (newBoxed Caps) result
+    touchManagedPtr _obj
+    return result'
+
+data TypeFindFactoryGetCapsMethodInfo
+instance (signature ~ (m Caps), MonadIO m, TypeFindFactoryK a) => MethodInfo TypeFindFactoryGetCapsMethodInfo a signature where
+    overloadedMethod _ = typeFindFactoryGetCaps
+
+-- method TypeFindFactory::get_extensions
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TypeFindFactory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TCArray True (-1) (-1) (TBasicType TUTF8)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_type_find_factory_get_extensions" gst_type_find_factory_get_extensions :: 
+    Ptr TypeFindFactory ->                  -- _obj : TInterface "Gst" "TypeFindFactory"
+    IO (Ptr CString)
+
+
+typeFindFactoryGetExtensions ::
+    (MonadIO m, TypeFindFactoryK a) =>
+    a                                       -- _obj
+    -> m [T.Text]                           -- result
+typeFindFactoryGetExtensions _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_type_find_factory_get_extensions _obj'
+    checkUnexpectedReturnNULL "gst_type_find_factory_get_extensions" result
+    result' <- unpackZeroTerminatedUTF8CArray result
+    touchManagedPtr _obj
+    return result'
+
+data TypeFindFactoryGetExtensionsMethodInfo
+instance (signature ~ (m [T.Text]), MonadIO m, TypeFindFactoryK a) => MethodInfo TypeFindFactoryGetExtensionsMethodInfo a signature where
+    overloadedMethod _ = typeFindFactoryGetExtensions
+
+-- method TypeFindFactory::has_function
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TypeFindFactory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_type_find_factory_has_function" gst_type_find_factory_has_function :: 
+    Ptr TypeFindFactory ->                  -- _obj : TInterface "Gst" "TypeFindFactory"
+    IO CInt
+
+
+typeFindFactoryHasFunction ::
+    (MonadIO m, TypeFindFactoryK a) =>
+    a                                       -- _obj
+    -> m Bool                               -- result
+typeFindFactoryHasFunction _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrCastPtr _obj
+    result <- gst_type_find_factory_has_function _obj'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data TypeFindFactoryHasFunctionMethodInfo
+instance (signature ~ (m Bool), MonadIO m, TypeFindFactoryK a) => MethodInfo TypeFindFactoryHasFunctionMethodInfo a signature where
+    overloadedMethod _ = typeFindFactoryHasFunction
+
+-- method TypeFindFactory::get_list
+-- method type : MemberFunction
+-- Args : []
+-- Lengths : []
+-- returnType : TGList (TInterface "Gst" "TypeFindFactory")
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_type_find_factory_get_list" gst_type_find_factory_get_list :: 
+    IO (Ptr (GList (Ptr TypeFindFactory)))
+
+
+typeFindFactoryGetList ::
+    (MonadIO m) =>
+    m [TypeFindFactory]                     -- result
+typeFindFactoryGetList  = liftIO $ do
+    result <- gst_type_find_factory_get_list
+    checkUnexpectedReturnNULL "gst_type_find_factory_get_list" result
+    result' <- unpackGList result
+    result'' <- mapM (wrapObject TypeFindFactory) result'
+    g_list_free result
+    return result''
+
+
diff --git a/GI/Gst/Objects/TypeFindFactory.hs-boot b/GI/Gst/Objects/TypeFindFactory.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Objects/TypeFindFactory.hs-boot
@@ -0,0 +1,17 @@
+module GI.Gst.Objects.TypeFindFactory where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+newtype TypeFindFactory = TypeFindFactory (ForeignPtr TypeFindFactory)
+instance GObject TypeFindFactory where
+class GObject o => TypeFindFactoryK o
+instance (GObject o, IsDescendantOf TypeFindFactory o) => TypeFindFactoryK o
+data TypeFindFactoryCallFunctionMethodInfo
+data TypeFindFactoryGetCapsMethodInfo
+data TypeFindFactoryGetExtensionsMethodInfo
+data TypeFindFactoryHasFunctionMethodInfo
diff --git a/GI/Gst/Structs.hs b/GI/Gst/Structs.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs.hs
@@ -0,0 +1,111 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+-}
+
+module GI.Gst.Structs
+    (     module GI.Gst.Structs.AllocationParams  ,
+    module GI.Gst.Structs.AtomicQueue       ,
+    module GI.Gst.Structs.Buffer            ,
+    module GI.Gst.Structs.BufferList        ,
+    module GI.Gst.Structs.BufferPoolAcquireParams,
+    module GI.Gst.Structs.Caps              ,
+    module GI.Gst.Structs.CapsFeatures      ,
+    module GI.Gst.Structs.ClockEntry        ,
+    module GI.Gst.Structs.Context           ,
+    module GI.Gst.Structs.DateTime          ,
+    module GI.Gst.Structs.DebugCategory     ,
+    module GI.Gst.Structs.DebugMessage      ,
+    module GI.Gst.Structs.Event             ,
+    module GI.Gst.Structs.FormatDefinition  ,
+    module GI.Gst.Structs.Iterator          ,
+    module GI.Gst.Structs.MapInfo           ,
+    module GI.Gst.Structs.Memory            ,
+    module GI.Gst.Structs.Message           ,
+    module GI.Gst.Structs.Meta              ,
+    module GI.Gst.Structs.MetaInfo          ,
+    module GI.Gst.Structs.MetaTransformCopy ,
+    module GI.Gst.Structs.MiniObject        ,
+    module GI.Gst.Structs.PadProbeInfo      ,
+    module GI.Gst.Structs.ParamSpecFraction ,
+    module GI.Gst.Structs.ParentBufferMeta  ,
+    module GI.Gst.Structs.ParseContext      ,
+    module GI.Gst.Structs.PluginDesc        ,
+    module GI.Gst.Structs.Poll              ,
+    module GI.Gst.Structs.PollFD            ,
+    module GI.Gst.Structs.ProtectionMeta    ,
+    module GI.Gst.Structs.Query             ,
+    module GI.Gst.Structs.Sample            ,
+    module GI.Gst.Structs.Segment           ,
+    module GI.Gst.Structs.StaticCaps        ,
+    module GI.Gst.Structs.StaticPadTemplate ,
+    module GI.Gst.Structs.Structure         ,
+    module GI.Gst.Structs.TagList           ,
+    module GI.Gst.Structs.TimedValue        ,
+    module GI.Gst.Structs.Toc               ,
+    module GI.Gst.Structs.TocEntry          ,
+    module GI.Gst.Structs.TypeFind          ,
+    module GI.Gst.Structs.Uri               ,
+    module GI.Gst.Structs.ValueTable        ,
+
+
+    ) where
+
+import GI.Gst.Structs.AllocationParams
+import GI.Gst.Structs.AtomicQueue
+import GI.Gst.Structs.Buffer
+import GI.Gst.Structs.BufferList
+import GI.Gst.Structs.BufferPoolAcquireParams
+import GI.Gst.Structs.Caps
+import GI.Gst.Structs.CapsFeatures
+import GI.Gst.Structs.ClockEntry
+import GI.Gst.Structs.Context
+import GI.Gst.Structs.DateTime
+import GI.Gst.Structs.DebugCategory
+import GI.Gst.Structs.DebugMessage
+import GI.Gst.Structs.Event
+import GI.Gst.Structs.FormatDefinition
+import GI.Gst.Structs.Iterator
+import GI.Gst.Structs.MapInfo
+import GI.Gst.Structs.Memory
+import GI.Gst.Structs.Message
+import GI.Gst.Structs.Meta
+import GI.Gst.Structs.MetaInfo
+import GI.Gst.Structs.MetaTransformCopy
+import GI.Gst.Structs.MiniObject
+import GI.Gst.Structs.PadProbeInfo
+import GI.Gst.Structs.ParamSpecFraction
+import GI.Gst.Structs.ParentBufferMeta
+import GI.Gst.Structs.ParseContext
+import GI.Gst.Structs.PluginDesc
+import GI.Gst.Structs.Poll
+import GI.Gst.Structs.PollFD
+import GI.Gst.Structs.ProtectionMeta
+import GI.Gst.Structs.Query
+import GI.Gst.Structs.Sample
+import GI.Gst.Structs.Segment
+import GI.Gst.Structs.StaticCaps
+import GI.Gst.Structs.StaticPadTemplate
+import GI.Gst.Structs.Structure
+import GI.Gst.Structs.TagList
+import GI.Gst.Structs.TimedValue
+import GI.Gst.Structs.Toc
+import GI.Gst.Structs.TocEntry
+import GI.Gst.Structs.TypeFind
+import GI.Gst.Structs.Uri
+import GI.Gst.Structs.ValueTable
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+import GI.Gst.Callbacks
+
+
diff --git a/GI/Gst/Structs/AllocationParams.hs b/GI/Gst/Structs/AllocationParams.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/AllocationParams.hs
@@ -0,0 +1,201 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+
+Parameters to control the allocation of memory
+-}
+
+module GI.Gst.Structs.AllocationParams
+    ( 
+
+-- * Exported types
+    AllocationParams(..)                    ,
+    newZeroAllocationParams                 ,
+    noAllocationParams                      ,
+
+
+ -- * Methods
+-- ** allocationParamsCopy
+    AllocationParamsCopyMethodInfo          ,
+    allocationParamsCopy                    ,
+
+
+-- ** allocationParamsFree
+    AllocationParamsFreeMethodInfo          ,
+    allocationParamsFree                    ,
+
+
+-- ** allocationParamsInit
+    AllocationParamsInitMethodInfo          ,
+    allocationParamsInit                    ,
+
+
+
+
+ -- * Properties
+-- ** Align
+    allocationParamsReadAlign               ,
+
+
+-- ** Flags
+    allocationParamsReadFlags               ,
+
+
+-- ** Padding
+    allocationParamsReadPadding             ,
+
+
+-- ** Prefix
+    allocationParamsReadPrefix              ,
+
+
+
+
+    ) where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+import GI.Gst.Callbacks
+
+newtype AllocationParams = AllocationParams (ForeignPtr AllocationParams)
+foreign import ccall "gst_allocation_params_get_type" c_gst_allocation_params_get_type :: 
+    IO GType
+
+instance BoxedObject AllocationParams where
+    boxedType _ = c_gst_allocation_params_get_type
+
+-- | Construct a `AllocationParams` struct initialized to zero.
+newZeroAllocationParams :: MonadIO m => m AllocationParams
+newZeroAllocationParams = liftIO $ callocBoxedBytes 64 >>= wrapBoxed AllocationParams
+
+noAllocationParams :: Maybe AllocationParams
+noAllocationParams = Nothing
+
+allocationParamsReadFlags :: AllocationParams -> IO [MemoryFlags]
+allocationParamsReadFlags s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 0) :: IO CUInt
+    let val' = wordToGFlags val
+    return val'
+
+allocationParamsReadAlign :: AllocationParams -> IO Word64
+allocationParamsReadAlign s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 8) :: IO Word64
+    return val
+
+allocationParamsReadPrefix :: AllocationParams -> IO Word64
+allocationParamsReadPrefix s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 16) :: IO Word64
+    return val
+
+allocationParamsReadPadding :: AllocationParams -> IO Word64
+allocationParamsReadPadding s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 24) :: IO Word64
+    return val
+
+-- method AllocationParams::copy
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "AllocationParams", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "AllocationParams"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_allocation_params_copy" gst_allocation_params_copy :: 
+    Ptr AllocationParams ->                 -- _obj : TInterface "Gst" "AllocationParams"
+    IO (Ptr AllocationParams)
+
+
+allocationParamsCopy ::
+    (MonadIO m) =>
+    AllocationParams                        -- _obj
+    -> m AllocationParams                   -- result
+allocationParamsCopy _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_allocation_params_copy _obj'
+    checkUnexpectedReturnNULL "gst_allocation_params_copy" result
+    result' <- (wrapBoxed AllocationParams) result
+    touchManagedPtr _obj
+    return result'
+
+data AllocationParamsCopyMethodInfo
+instance (signature ~ (m AllocationParams), MonadIO m) => MethodInfo AllocationParamsCopyMethodInfo AllocationParams signature where
+    overloadedMethod _ = allocationParamsCopy
+
+-- method AllocationParams::free
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "AllocationParams", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_allocation_params_free" gst_allocation_params_free :: 
+    Ptr AllocationParams ->                 -- _obj : TInterface "Gst" "AllocationParams"
+    IO ()
+
+
+allocationParamsFree ::
+    (MonadIO m) =>
+    AllocationParams                        -- _obj
+    -> m ()                                 -- result
+allocationParamsFree _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    gst_allocation_params_free _obj'
+    touchManagedPtr _obj
+    return ()
+
+data AllocationParamsFreeMethodInfo
+instance (signature ~ (m ()), MonadIO m) => MethodInfo AllocationParamsFreeMethodInfo AllocationParams signature where
+    overloadedMethod _ = allocationParamsFree
+
+-- method AllocationParams::init
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "AllocationParams", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_allocation_params_init" gst_allocation_params_init :: 
+    Ptr AllocationParams ->                 -- _obj : TInterface "Gst" "AllocationParams"
+    IO ()
+
+
+allocationParamsInit ::
+    (MonadIO m) =>
+    AllocationParams                        -- _obj
+    -> m ()                                 -- result
+allocationParamsInit _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    gst_allocation_params_init _obj'
+    touchManagedPtr _obj
+    return ()
+
+data AllocationParamsInitMethodInfo
+instance (signature ~ (m ()), MonadIO m) => MethodInfo AllocationParamsInitMethodInfo AllocationParams signature where
+    overloadedMethod _ = allocationParamsInit
+
+type family ResolveAllocationParamsMethod (t :: Symbol) (o :: *) :: * where
+    ResolveAllocationParamsMethod "copy" o = AllocationParamsCopyMethodInfo
+    ResolveAllocationParamsMethod "free" o = AllocationParamsFreeMethodInfo
+    ResolveAllocationParamsMethod "init" o = AllocationParamsInitMethodInfo
+    ResolveAllocationParamsMethod l o = MethodResolutionFailed l o
+
+instance (info ~ ResolveAllocationParamsMethod t AllocationParams, MethodInfo info AllocationParams p) => IsLabelProxy t (AllocationParams -> p) where
+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)
+
+#if MIN_VERSION_base(4,9,0)
+instance (info ~ ResolveAllocationParamsMethod t AllocationParams, MethodInfo info AllocationParams p) => IsLabel t (AllocationParams -> p) where
+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)
+#endif
+
+
diff --git a/GI/Gst/Structs/AllocationParams.hs-boot b/GI/Gst/Structs/AllocationParams.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/AllocationParams.hs-boot
@@ -0,0 +1,14 @@
+module GI.Gst.Structs.AllocationParams where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+newtype AllocationParams = AllocationParams (ForeignPtr AllocationParams)
+instance BoxedObject AllocationParams where
+data AllocationParamsCopyMethodInfo
+data AllocationParamsFreeMethodInfo
+data AllocationParamsInitMethodInfo
diff --git a/GI/Gst/Structs/AtomicQueue.hs b/GI/Gst/Structs/AtomicQueue.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/AtomicQueue.hs
@@ -0,0 +1,283 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+
+The #GstAtomicQueue object implements a queue that can be used from multiple
+threads without performing any blocking operations.
+-}
+
+module GI.Gst.Structs.AtomicQueue
+    ( 
+
+-- * Exported types
+    AtomicQueue(..)                         ,
+    noAtomicQueue                           ,
+
+
+ -- * Methods
+-- ** atomicQueueLength
+    AtomicQueueLengthMethodInfo             ,
+    atomicQueueLength                       ,
+
+
+-- ** atomicQueueNew
+    atomicQueueNew                          ,
+
+
+-- ** atomicQueuePeek
+    AtomicQueuePeekMethodInfo               ,
+    atomicQueuePeek                         ,
+
+
+-- ** atomicQueuePop
+    AtomicQueuePopMethodInfo                ,
+    atomicQueuePop                          ,
+
+
+-- ** atomicQueuePush
+    AtomicQueuePushMethodInfo               ,
+    atomicQueuePush                         ,
+
+
+-- ** atomicQueueRef
+    AtomicQueueRefMethodInfo                ,
+    atomicQueueRef                          ,
+
+
+-- ** atomicQueueUnref
+    AtomicQueueUnrefMethodInfo              ,
+    atomicQueueUnref                        ,
+
+
+
+
+    ) where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+import GI.Gst.Callbacks
+
+newtype AtomicQueue = AtomicQueue (ForeignPtr AtomicQueue)
+foreign import ccall "gst_atomic_queue_get_type" c_gst_atomic_queue_get_type :: 
+    IO GType
+
+instance BoxedObject AtomicQueue where
+    boxedType _ = c_gst_atomic_queue_get_type
+
+noAtomicQueue :: Maybe AtomicQueue
+noAtomicQueue = Nothing
+
+-- method AtomicQueue::new
+-- method type : Constructor
+-- Args : [Arg {argCName = "initial_size", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "AtomicQueue"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_atomic_queue_new" gst_atomic_queue_new :: 
+    Word32 ->                               -- initial_size : TBasicType TUInt32
+    IO (Ptr AtomicQueue)
+
+
+atomicQueueNew ::
+    (MonadIO m) =>
+    Word32                                  -- initialSize
+    -> m AtomicQueue                        -- result
+atomicQueueNew initialSize = liftIO $ do
+    result <- gst_atomic_queue_new initialSize
+    checkUnexpectedReturnNULL "gst_atomic_queue_new" result
+    result' <- (wrapBoxed AtomicQueue) result
+    return result'
+
+-- method AtomicQueue::length
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "AtomicQueue", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUInt32
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_atomic_queue_length" gst_atomic_queue_length :: 
+    Ptr AtomicQueue ->                      -- _obj : TInterface "Gst" "AtomicQueue"
+    IO Word32
+
+
+atomicQueueLength ::
+    (MonadIO m) =>
+    AtomicQueue                             -- _obj
+    -> m Word32                             -- result
+atomicQueueLength _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_atomic_queue_length _obj'
+    touchManagedPtr _obj
+    return result
+
+data AtomicQueueLengthMethodInfo
+instance (signature ~ (m Word32), MonadIO m) => MethodInfo AtomicQueueLengthMethodInfo AtomicQueue signature where
+    overloadedMethod _ = atomicQueueLength
+
+-- method AtomicQueue::peek
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "AtomicQueue", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_atomic_queue_peek" gst_atomic_queue_peek :: 
+    Ptr AtomicQueue ->                      -- _obj : TInterface "Gst" "AtomicQueue"
+    IO ()
+
+
+atomicQueuePeek ::
+    (MonadIO m) =>
+    AtomicQueue                             -- _obj
+    -> m ()                                 -- result
+atomicQueuePeek _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    gst_atomic_queue_peek _obj'
+    touchManagedPtr _obj
+    return ()
+
+data AtomicQueuePeekMethodInfo
+instance (signature ~ (m ()), MonadIO m) => MethodInfo AtomicQueuePeekMethodInfo AtomicQueue signature where
+    overloadedMethod _ = atomicQueuePeek
+
+-- method AtomicQueue::pop
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "AtomicQueue", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_atomic_queue_pop" gst_atomic_queue_pop :: 
+    Ptr AtomicQueue ->                      -- _obj : TInterface "Gst" "AtomicQueue"
+    IO ()
+
+
+atomicQueuePop ::
+    (MonadIO m) =>
+    AtomicQueue                             -- _obj
+    -> m ()                                 -- result
+atomicQueuePop _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    gst_atomic_queue_pop _obj'
+    touchManagedPtr _obj
+    return ()
+
+data AtomicQueuePopMethodInfo
+instance (signature ~ (m ()), MonadIO m) => MethodInfo AtomicQueuePopMethodInfo AtomicQueue signature where
+    overloadedMethod _ = atomicQueuePop
+
+-- method AtomicQueue::push
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "AtomicQueue", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_atomic_queue_push" gst_atomic_queue_push :: 
+    Ptr AtomicQueue ->                      -- _obj : TInterface "Gst" "AtomicQueue"
+    Ptr () ->                               -- data : TBasicType TVoid
+    IO ()
+
+
+atomicQueuePush ::
+    (MonadIO m) =>
+    AtomicQueue                             -- _obj
+    -> Ptr ()                               -- data_
+    -> m ()                                 -- result
+atomicQueuePush _obj data_ = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    gst_atomic_queue_push _obj' data_
+    touchManagedPtr _obj
+    return ()
+
+data AtomicQueuePushMethodInfo
+instance (signature ~ (Ptr () -> m ()), MonadIO m) => MethodInfo AtomicQueuePushMethodInfo AtomicQueue signature where
+    overloadedMethod _ = atomicQueuePush
+
+-- method AtomicQueue::ref
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "AtomicQueue", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_atomic_queue_ref" gst_atomic_queue_ref :: 
+    Ptr AtomicQueue ->                      -- _obj : TInterface "Gst" "AtomicQueue"
+    IO ()
+
+
+atomicQueueRef ::
+    (MonadIO m) =>
+    AtomicQueue                             -- _obj
+    -> m ()                                 -- result
+atomicQueueRef _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    gst_atomic_queue_ref _obj'
+    touchManagedPtr _obj
+    return ()
+
+data AtomicQueueRefMethodInfo
+instance (signature ~ (m ()), MonadIO m) => MethodInfo AtomicQueueRefMethodInfo AtomicQueue signature where
+    overloadedMethod _ = atomicQueueRef
+
+-- method AtomicQueue::unref
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "AtomicQueue", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_atomic_queue_unref" gst_atomic_queue_unref :: 
+    Ptr AtomicQueue ->                      -- _obj : TInterface "Gst" "AtomicQueue"
+    IO ()
+
+
+atomicQueueUnref ::
+    (MonadIO m) =>
+    AtomicQueue                             -- _obj
+    -> m ()                                 -- result
+atomicQueueUnref _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    gst_atomic_queue_unref _obj'
+    touchManagedPtr _obj
+    return ()
+
+data AtomicQueueUnrefMethodInfo
+instance (signature ~ (m ()), MonadIO m) => MethodInfo AtomicQueueUnrefMethodInfo AtomicQueue signature where
+    overloadedMethod _ = atomicQueueUnref
+
+type family ResolveAtomicQueueMethod (t :: Symbol) (o :: *) :: * where
+    ResolveAtomicQueueMethod "length" o = AtomicQueueLengthMethodInfo
+    ResolveAtomicQueueMethod "peek" o = AtomicQueuePeekMethodInfo
+    ResolveAtomicQueueMethod "pop" o = AtomicQueuePopMethodInfo
+    ResolveAtomicQueueMethod "push" o = AtomicQueuePushMethodInfo
+    ResolveAtomicQueueMethod "ref" o = AtomicQueueRefMethodInfo
+    ResolveAtomicQueueMethod "unref" o = AtomicQueueUnrefMethodInfo
+    ResolveAtomicQueueMethod l o = MethodResolutionFailed l o
+
+instance (info ~ ResolveAtomicQueueMethod t AtomicQueue, MethodInfo info AtomicQueue p) => IsLabelProxy t (AtomicQueue -> p) where
+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)
+
+#if MIN_VERSION_base(4,9,0)
+instance (info ~ ResolveAtomicQueueMethod t AtomicQueue, MethodInfo info AtomicQueue p) => IsLabel t (AtomicQueue -> p) where
+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)
+#endif
+
+
diff --git a/GI/Gst/Structs/AtomicQueue.hs-boot b/GI/Gst/Structs/AtomicQueue.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/AtomicQueue.hs-boot
@@ -0,0 +1,17 @@
+module GI.Gst.Structs.AtomicQueue where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+newtype AtomicQueue = AtomicQueue (ForeignPtr AtomicQueue)
+instance BoxedObject AtomicQueue where
+data AtomicQueueLengthMethodInfo
+data AtomicQueuePeekMethodInfo
+data AtomicQueuePopMethodInfo
+data AtomicQueuePushMethodInfo
+data AtomicQueueRefMethodInfo
+data AtomicQueueUnrefMethodInfo
diff --git a/GI/Gst/Structs/Buffer.hs b/GI/Gst/Structs/Buffer.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/Buffer.hs
@@ -0,0 +1,2061 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+
+Buffers are the basic unit of data transfer in GStreamer. They contain the
+timing and offset along with other arbitrary metadata that is associated
+with the #GstMemory blocks that the buffer contains.
+
+Buffers are usually created with gst_buffer_new(). After a buffer has been
+created one will typically allocate memory for it and add it to the buffer.
+The following example creates a buffer that can hold a given video frame
+with a given width, height and bits per plane.
+|[
+  GstBuffer *buffer;
+  GstMemory *memory;
+  gint size, width, height, bpp;
+  ...
+  size = width * height * bpp;
+  buffer = gst_buffer_new ();
+  memory = gst_allocator_alloc (NULL, size, NULL);
+  gst_buffer_insert_memory (buffer, -1, memory);
+  ...
+]|
+
+Alternatively, use gst_buffer_new_allocate() to create a buffer with
+preallocated data of a given size.
+
+Buffers can contain a list of #GstMemory objects. You can retrieve how many
+memory objects with gst_buffer_n_memory() and you can get a pointer
+to memory with gst_buffer_peek_memory()
+
+A buffer will usually have timestamps, and a duration, but neither of these
+are guaranteed (they may be set to #GST_CLOCK_TIME_NONE). Whenever a
+meaningful value can be given for these, they should be set. The timestamps
+and duration are measured in nanoseconds (they are #GstClockTime values).
+
+The buffer DTS refers to the timestamp when the buffer should be decoded and
+is usually monotonically increasing. The buffer PTS refers to the timestamp when
+the buffer content should be presented to the user and is not always
+monotonically increasing.
+
+A buffer can also have one or both of a start and an end offset. These are
+media-type specific. For video buffers, the start offset will generally be
+the frame number. For audio buffers, it will be the number of samples
+produced so far. For compressed data, it could be the byte offset in a
+source or destination file. Likewise, the end offset will be the offset of
+the end of the buffer. These can only be meaningfully interpreted if you
+know the media type of the buffer (the preceding CAPS event). Either or both
+can be set to #GST_BUFFER_OFFSET_NONE.
+
+gst_buffer_ref() is used to increase the refcount of a buffer. This must be
+done when you want to keep a handle to the buffer after pushing it to the
+next element. The buffer refcount determines the writability of the buffer, a
+buffer is only writable when the refcount is exactly 1, i.e. when the caller
+has the only reference to the buffer.
+
+To efficiently create a smaller buffer out of an existing one, you can
+use gst_buffer_copy_region(). This method tries to share the memory objects
+between the two buffers.
+
+If a plug-in wants to modify the buffer data or metadata in-place, it should
+first obtain a buffer that is safe to modify by using
+gst_buffer_make_writable().  This function is optimized so that a copy will
+only be made when it is necessary.
+
+Several flags of the buffer can be set and unset with the
+GST_BUFFER_FLAG_SET() and GST_BUFFER_FLAG_UNSET() macros. Use
+GST_BUFFER_FLAG_IS_SET() to test if a certain #GstBufferFlags flag is set.
+
+Buffers can be efficiently merged into a larger buffer with
+gst_buffer_append(). Copying of memory will only be done when absolutely
+needed.
+
+Arbitrary extra metadata can be set on a buffer with gst_buffer_add_meta().
+Metadata can be retrieved with gst_buffer_get_meta(). See also #GstMeta
+
+An element should either unref the buffer or push it out on a src pad
+using gst_pad_push() (see #GstPad).
+
+Buffers are usually freed by unreffing them with gst_buffer_unref(). When
+the refcount drops to 0, any memory and metadata pointed to by the buffer is
+unreffed as well. Buffers allocated from a #GstBufferPool will be returned to
+the pool when the refcount drops to 0.
+
+The #GstParentBufferMeta is a meta which can be attached to a #GstBuffer
+to hold a reference to another buffer that is only released when the child
+#GstBuffer is released.
+
+Typically, #GstParentBufferMeta is used when the child buffer is directly
+using the #GstMemory of the parent buffer, and wants to prevent the parent
+buffer from being returned to a buffer pool until the #GstMemory is available
+for re-use. (Since 1.6)
+-}
+
+module GI.Gst.Structs.Buffer
+    ( 
+
+-- * Exported types
+    Buffer(..)                              ,
+    newZeroBuffer                           ,
+    noBuffer                                ,
+
+
+ -- * Methods
+-- ** bufferAddMeta
+    BufferAddMetaMethodInfo                 ,
+    bufferAddMeta                           ,
+
+
+-- ** bufferAddParentBufferMeta
+    BufferAddParentBufferMetaMethodInfo     ,
+    bufferAddParentBufferMeta               ,
+
+
+-- ** bufferAddProtectionMeta
+    BufferAddProtectionMetaMethodInfo       ,
+    bufferAddProtectionMeta                 ,
+
+
+-- ** bufferAppend
+    BufferAppendMethodInfo                  ,
+    bufferAppend                            ,
+
+
+-- ** bufferAppendMemory
+    BufferAppendMemoryMethodInfo            ,
+    bufferAppendMemory                      ,
+
+
+-- ** bufferAppendRegion
+    BufferAppendRegionMethodInfo            ,
+    bufferAppendRegion                      ,
+
+
+-- ** bufferCopyDeep
+    BufferCopyDeepMethodInfo                ,
+    bufferCopyDeep                          ,
+
+
+-- ** bufferCopyInto
+    BufferCopyIntoMethodInfo                ,
+    bufferCopyInto                          ,
+
+
+-- ** bufferCopyRegion
+    BufferCopyRegionMethodInfo              ,
+    bufferCopyRegion                        ,
+
+
+-- ** bufferExtract
+    BufferExtractMethodInfo                 ,
+    bufferExtract                           ,
+
+
+-- ** bufferExtractDup
+    BufferExtractDupMethodInfo              ,
+    bufferExtractDup                        ,
+
+
+-- ** bufferFill
+    BufferFillMethodInfo                    ,
+    bufferFill                              ,
+
+
+-- ** bufferFindMemory
+    BufferFindMemoryMethodInfo              ,
+    bufferFindMemory                        ,
+
+
+-- ** bufferForeachMeta
+    BufferForeachMetaMethodInfo             ,
+    bufferForeachMeta                       ,
+
+
+-- ** bufferGetAllMemory
+    BufferGetAllMemoryMethodInfo            ,
+    bufferGetAllMemory                      ,
+
+
+-- ** bufferGetMaxMemory
+    bufferGetMaxMemory                      ,
+
+
+-- ** bufferGetMemory
+    BufferGetMemoryMethodInfo               ,
+    bufferGetMemory                         ,
+
+
+-- ** bufferGetMemoryRange
+    BufferGetMemoryRangeMethodInfo          ,
+    bufferGetMemoryRange                    ,
+
+
+-- ** bufferGetMeta
+    BufferGetMetaMethodInfo                 ,
+    bufferGetMeta                           ,
+
+
+-- ** bufferGetSize
+    BufferGetSizeMethodInfo                 ,
+    bufferGetSize                           ,
+
+
+-- ** bufferGetSizes
+    BufferGetSizesMethodInfo                ,
+    bufferGetSizes                          ,
+
+
+-- ** bufferGetSizesRange
+    BufferGetSizesRangeMethodInfo           ,
+    bufferGetSizesRange                     ,
+
+
+-- ** bufferInsertMemory
+    BufferInsertMemoryMethodInfo            ,
+    bufferInsertMemory                      ,
+
+
+-- ** bufferIsAllMemoryWritable
+    BufferIsAllMemoryWritableMethodInfo     ,
+    bufferIsAllMemoryWritable               ,
+
+
+-- ** bufferIsMemoryRangeWritable
+    BufferIsMemoryRangeWritableMethodInfo   ,
+    bufferIsMemoryRangeWritable             ,
+
+
+-- ** bufferIterateMeta
+    BufferIterateMetaMethodInfo             ,
+    bufferIterateMeta                       ,
+
+
+-- ** bufferMap
+    BufferMapMethodInfo                     ,
+    bufferMap                               ,
+
+
+-- ** bufferMapRange
+    BufferMapRangeMethodInfo                ,
+    bufferMapRange                          ,
+
+
+-- ** bufferMemcmp
+    BufferMemcmpMethodInfo                  ,
+    bufferMemcmp                            ,
+
+
+-- ** bufferMemset
+    BufferMemsetMethodInfo                  ,
+    bufferMemset                            ,
+
+
+-- ** bufferNMemory
+    BufferNMemoryMethodInfo                 ,
+    bufferNMemory                           ,
+
+
+-- ** bufferNew
+    bufferNew                               ,
+
+
+-- ** bufferNewAllocate
+    bufferNewAllocate                       ,
+
+
+-- ** bufferNewWrapped
+    bufferNewWrapped                        ,
+
+
+-- ** bufferNewWrappedFull
+    bufferNewWrappedFull                    ,
+
+
+-- ** bufferPeekMemory
+    BufferPeekMemoryMethodInfo              ,
+    bufferPeekMemory                        ,
+
+
+-- ** bufferPrependMemory
+    BufferPrependMemoryMethodInfo           ,
+    bufferPrependMemory                     ,
+
+
+-- ** bufferRemoveAllMemory
+    BufferRemoveAllMemoryMethodInfo         ,
+    bufferRemoveAllMemory                   ,
+
+
+-- ** bufferRemoveMemory
+    BufferRemoveMemoryMethodInfo            ,
+    bufferRemoveMemory                      ,
+
+
+-- ** bufferRemoveMemoryRange
+    BufferRemoveMemoryRangeMethodInfo       ,
+    bufferRemoveMemoryRange                 ,
+
+
+-- ** bufferRemoveMeta
+    BufferRemoveMetaMethodInfo              ,
+    bufferRemoveMeta                        ,
+
+
+-- ** bufferReplaceAllMemory
+    BufferReplaceAllMemoryMethodInfo        ,
+    bufferReplaceAllMemory                  ,
+
+
+-- ** bufferReplaceMemory
+    BufferReplaceMemoryMethodInfo           ,
+    bufferReplaceMemory                     ,
+
+
+-- ** bufferReplaceMemoryRange
+    BufferReplaceMemoryRangeMethodInfo      ,
+    bufferReplaceMemoryRange                ,
+
+
+-- ** bufferResize
+    BufferResizeMethodInfo                  ,
+    bufferResize                            ,
+
+
+-- ** bufferResizeRange
+    BufferResizeRangeMethodInfo             ,
+    bufferResizeRange                       ,
+
+
+-- ** bufferSetSize
+    BufferSetSizeMethodInfo                 ,
+    bufferSetSize                           ,
+
+
+-- ** bufferUnmap
+    BufferUnmapMethodInfo                   ,
+    bufferUnmap                             ,
+
+
+
+
+ -- * Properties
+-- ** Dts
+    bufferReadDts                           ,
+
+
+-- ** Duration
+    bufferReadDuration                      ,
+
+
+-- ** MiniObject
+    bufferReadMiniObject                    ,
+
+
+-- ** Offset
+    bufferReadOffset                        ,
+
+
+-- ** OffsetEnd
+    bufferReadOffsetEnd                     ,
+
+
+-- ** Pool
+    bufferReadPool                          ,
+
+
+-- ** Pts
+    bufferReadPts                           ,
+
+
+
+
+    ) where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+import GI.Gst.Callbacks
+import qualified GI.GLib as GLib
+
+newtype Buffer = Buffer (ForeignPtr Buffer)
+foreign import ccall "gst_buffer_get_type" c_gst_buffer_get_type :: 
+    IO GType
+
+instance BoxedObject Buffer where
+    boxedType _ = c_gst_buffer_get_type
+
+-- | Construct a `Buffer` struct initialized to zero.
+newZeroBuffer :: MonadIO m => m Buffer
+newZeroBuffer = liftIO $ callocBoxedBytes 112 >>= wrapBoxed Buffer
+
+noBuffer :: Maybe Buffer
+noBuffer = Nothing
+
+bufferReadMiniObject :: Buffer -> IO MiniObject
+bufferReadMiniObject s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 0) :: IO (Ptr MiniObject)
+    val' <- (newPtr 64 MiniObject) val
+    return val'
+
+bufferReadPool :: Buffer -> IO BufferPool
+bufferReadPool s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 64) :: IO (Ptr BufferPool)
+    val' <- (newObject BufferPool) val
+    return val'
+
+bufferReadPts :: Buffer -> IO Word64
+bufferReadPts s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 72) :: IO Word64
+    return val
+
+bufferReadDts :: Buffer -> IO Word64
+bufferReadDts s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 80) :: IO Word64
+    return val
+
+bufferReadDuration :: Buffer -> IO Word64
+bufferReadDuration s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 88) :: IO Word64
+    return val
+
+bufferReadOffset :: Buffer -> IO Word64
+bufferReadOffset s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 96) :: IO Word64
+    return val
+
+bufferReadOffsetEnd :: Buffer -> IO Word64
+bufferReadOffsetEnd s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 104) :: IO Word64
+    return val
+
+-- method Buffer::new
+-- method type : Constructor
+-- Args : []
+-- Lengths : []
+-- returnType : TInterface "Gst" "Buffer"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_buffer_new" gst_buffer_new :: 
+    IO (Ptr Buffer)
+
+
+bufferNew ::
+    (MonadIO m) =>
+    m Buffer                                -- result
+bufferNew  = liftIO $ do
+    result <- gst_buffer_new
+    checkUnexpectedReturnNULL "gst_buffer_new" result
+    result' <- (wrapBoxed Buffer) result
+    return result'
+
+-- method Buffer::new_allocate
+-- method type : Constructor
+-- Args : [Arg {argCName = "allocator", argType = TInterface "Gst" "Allocator", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "params", argType = TInterface "Gst" "AllocationParams", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Buffer"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_buffer_new_allocate" gst_buffer_new_allocate :: 
+    Ptr Allocator ->                        -- allocator : TInterface "Gst" "Allocator"
+    Word64 ->                               -- size : TBasicType TUInt64
+    Ptr AllocationParams ->                 -- params : TInterface "Gst" "AllocationParams"
+    IO (Ptr Buffer)
+
+
+bufferNewAllocate ::
+    (MonadIO m, AllocatorK a) =>
+    Maybe (a)                               -- allocator
+    -> Word64                               -- size
+    -> Maybe (AllocationParams)             -- params
+    -> m Buffer                             -- result
+bufferNewAllocate allocator size params = liftIO $ do
+    maybeAllocator <- case allocator of
+        Nothing -> return nullPtr
+        Just jAllocator -> do
+            let jAllocator' = unsafeManagedPtrCastPtr jAllocator
+            return jAllocator'
+    maybeParams <- case params of
+        Nothing -> return nullPtr
+        Just jParams -> do
+            let jParams' = unsafeManagedPtrGetPtr jParams
+            return jParams'
+    result <- gst_buffer_new_allocate maybeAllocator size maybeParams
+    checkUnexpectedReturnNULL "gst_buffer_new_allocate" result
+    result' <- (wrapBoxed Buffer) result
+    whenJust allocator touchManagedPtr
+    whenJust params touchManagedPtr
+    return result'
+
+-- method Buffer::new_wrapped
+-- method type : Constructor
+-- Args : [Arg {argCName = "data", argType = TCArray False (-1) 1 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : [Arg {argCName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- returnType : TInterface "Gst" "Buffer"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_buffer_new_wrapped" gst_buffer_new_wrapped :: 
+    Ptr Word8 ->                            -- data : TCArray False (-1) 1 (TBasicType TUInt8)
+    Word64 ->                               -- size : TBasicType TUInt64
+    IO (Ptr Buffer)
+
+
+bufferNewWrapped ::
+    (MonadIO m) =>
+    ByteString                              -- data_
+    -> m Buffer                             -- result
+bufferNewWrapped data_ = liftIO $ do
+    let size = fromIntegral $ B.length data_
+    data_' <- packByteString data_
+    result <- gst_buffer_new_wrapped data_' size
+    checkUnexpectedReturnNULL "gst_buffer_new_wrapped" result
+    result' <- (wrapBoxed Buffer) result
+    return result'
+
+-- method Buffer::new_wrapped_full
+-- method type : Constructor
+-- Args : [Arg {argCName = "flags", argType = TInterface "Gst" "MemoryFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TCArray False (-1) 4 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "maxsize", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "notify", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : [Arg {argCName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- returnType : TInterface "Gst" "Buffer"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_buffer_new_wrapped_full" gst_buffer_new_wrapped_full :: 
+    CUInt ->                                -- flags : TInterface "Gst" "MemoryFlags"
+    Ptr Word8 ->                            -- data : TCArray False (-1) 4 (TBasicType TUInt8)
+    Word64 ->                               -- maxsize : TBasicType TUInt64
+    Word64 ->                               -- offset : TBasicType TUInt64
+    Word64 ->                               -- size : TBasicType TUInt64
+    Ptr () ->                               -- user_data : TBasicType TVoid
+    FunPtr GLib.DestroyNotifyC ->           -- notify : TInterface "GLib" "DestroyNotify"
+    IO (Ptr Buffer)
+
+
+bufferNewWrappedFull ::
+    (MonadIO m) =>
+    [MemoryFlags]                           -- flags
+    -> ByteString                           -- data_
+    -> Word64                               -- maxsize
+    -> Word64                               -- offset
+    -> Maybe (GLib.DestroyNotify)           -- notify
+    -> m Buffer                             -- result
+bufferNewWrappedFull flags data_ maxsize offset notify = liftIO $ do
+    let size = fromIntegral $ B.length data_
+    let flags' = gflagsToWord flags
+    data_' <- packByteString data_
+    ptrnotify <- callocMem :: IO (Ptr (FunPtr GLib.DestroyNotifyC))
+    maybeNotify <- case notify of
+        Nothing -> return (castPtrToFunPtr nullPtr)
+        Just jNotify -> do
+            jNotify' <- GLib.mkDestroyNotify (GLib.destroyNotifyWrapper (Just ptrnotify) jNotify)
+            poke ptrnotify jNotify'
+            return jNotify'
+    let userData = nullPtr
+    result <- gst_buffer_new_wrapped_full flags' data_' maxsize offset size userData maybeNotify
+    checkUnexpectedReturnNULL "gst_buffer_new_wrapped_full" result
+    result' <- (wrapBoxed Buffer) result
+    freeMem data_'
+    return result'
+
+-- method Buffer::add_meta
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "info", argType = TInterface "Gst" "MetaInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "params", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Meta"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_buffer_add_meta" gst_buffer_add_meta :: 
+    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"
+    Ptr MetaInfo ->                         -- info : TInterface "Gst" "MetaInfo"
+    Ptr () ->                               -- params : TBasicType TVoid
+    IO (Ptr Meta)
+
+
+bufferAddMeta ::
+    (MonadIO m) =>
+    Buffer                                  -- _obj
+    -> MetaInfo                             -- info
+    -> Ptr ()                               -- params
+    -> m Meta                               -- result
+bufferAddMeta _obj info params = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let info' = unsafeManagedPtrGetPtr info
+    result <- gst_buffer_add_meta _obj' info' params
+    checkUnexpectedReturnNULL "gst_buffer_add_meta" result
+    result' <- (newPtr 16 Meta) result
+    touchManagedPtr _obj
+    touchManagedPtr info
+    return result'
+
+data BufferAddMetaMethodInfo
+instance (signature ~ (MetaInfo -> Ptr () -> m Meta), MonadIO m) => MethodInfo BufferAddMetaMethodInfo Buffer signature where
+    overloadedMethod _ = bufferAddMeta
+
+-- method Buffer::add_parent_buffer_meta
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "ref", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "ParentBufferMeta"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_buffer_add_parent_buffer_meta" gst_buffer_add_parent_buffer_meta :: 
+    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"
+    Ptr Buffer ->                           -- ref : TInterface "Gst" "Buffer"
+    IO (Ptr ParentBufferMeta)
+
+
+bufferAddParentBufferMeta ::
+    (MonadIO m) =>
+    Buffer                                  -- _obj
+    -> Buffer                               -- ref
+    -> m ParentBufferMeta                   -- result
+bufferAddParentBufferMeta _obj ref = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let ref' = unsafeManagedPtrGetPtr ref
+    result <- gst_buffer_add_parent_buffer_meta _obj' ref'
+    checkUnexpectedReturnNULL "gst_buffer_add_parent_buffer_meta" result
+    result' <- (newPtr 24 ParentBufferMeta) result
+    touchManagedPtr _obj
+    touchManagedPtr ref
+    return result'
+
+data BufferAddParentBufferMetaMethodInfo
+instance (signature ~ (Buffer -> m ParentBufferMeta), MonadIO m) => MethodInfo BufferAddParentBufferMetaMethodInfo Buffer signature where
+    overloadedMethod _ = bufferAddParentBufferMeta
+
+-- method Buffer::add_protection_meta
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "info", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "ProtectionMeta"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_buffer_add_protection_meta" gst_buffer_add_protection_meta :: 
+    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"
+    Ptr Structure ->                        -- info : TInterface "Gst" "Structure"
+    IO (Ptr ProtectionMeta)
+
+
+bufferAddProtectionMeta ::
+    (MonadIO m) =>
+    Buffer                                  -- _obj
+    -> Structure                            -- info
+    -> m ProtectionMeta                     -- result
+bufferAddProtectionMeta _obj info = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    info' <- copyBoxed info
+    result <- gst_buffer_add_protection_meta _obj' info'
+    checkUnexpectedReturnNULL "gst_buffer_add_protection_meta" result
+    result' <- (newPtr 24 ProtectionMeta) result
+    touchManagedPtr _obj
+    touchManagedPtr info
+    return result'
+
+data BufferAddProtectionMetaMethodInfo
+instance (signature ~ (Structure -> m ProtectionMeta), MonadIO m) => MethodInfo BufferAddProtectionMetaMethodInfo Buffer signature where
+    overloadedMethod _ = bufferAddProtectionMeta
+
+-- method Buffer::append
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "buf2", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Buffer"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_buffer_append" gst_buffer_append :: 
+    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"
+    Ptr Buffer ->                           -- buf2 : TInterface "Gst" "Buffer"
+    IO (Ptr Buffer)
+
+
+bufferAppend ::
+    (MonadIO m) =>
+    Buffer                                  -- _obj
+    -> Buffer                               -- buf2
+    -> m Buffer                             -- result
+bufferAppend _obj buf2 = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    buf2' <- copyBoxed buf2
+    result <- gst_buffer_append _obj' buf2'
+    checkUnexpectedReturnNULL "gst_buffer_append" result
+    result' <- (wrapBoxed Buffer) result
+    touchManagedPtr _obj
+    touchManagedPtr buf2
+    return result'
+
+data BufferAppendMethodInfo
+instance (signature ~ (Buffer -> m Buffer), MonadIO m) => MethodInfo BufferAppendMethodInfo Buffer signature where
+    overloadedMethod _ = bufferAppend
+
+-- method Buffer::append_memory
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mem", argType = TInterface "Gst" "Memory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_buffer_append_memory" gst_buffer_append_memory :: 
+    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"
+    Ptr Memory ->                           -- mem : TInterface "Gst" "Memory"
+    IO ()
+
+
+bufferAppendMemory ::
+    (MonadIO m) =>
+    Buffer                                  -- _obj
+    -> Memory                               -- mem
+    -> m ()                                 -- result
+bufferAppendMemory _obj mem = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    mem' <- copyBoxed mem
+    gst_buffer_append_memory _obj' mem'
+    touchManagedPtr _obj
+    touchManagedPtr mem
+    return ()
+
+data BufferAppendMemoryMethodInfo
+instance (signature ~ (Memory -> m ()), MonadIO m) => MethodInfo BufferAppendMemoryMethodInfo Buffer signature where
+    overloadedMethod _ = bufferAppendMemory
+
+-- method Buffer::append_region
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "buf2", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "offset", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Buffer"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_buffer_append_region" gst_buffer_append_region :: 
+    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"
+    Ptr Buffer ->                           -- buf2 : TInterface "Gst" "Buffer"
+    Int64 ->                                -- offset : TBasicType TInt64
+    Int64 ->                                -- size : TBasicType TInt64
+    IO (Ptr Buffer)
+
+
+bufferAppendRegion ::
+    (MonadIO m) =>
+    Buffer                                  -- _obj
+    -> Buffer                               -- buf2
+    -> Int64                                -- offset
+    -> Int64                                -- size
+    -> m Buffer                             -- result
+bufferAppendRegion _obj buf2 offset size = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    buf2' <- copyBoxed buf2
+    result <- gst_buffer_append_region _obj' buf2' offset size
+    checkUnexpectedReturnNULL "gst_buffer_append_region" result
+    result' <- (wrapBoxed Buffer) result
+    touchManagedPtr _obj
+    touchManagedPtr buf2
+    return result'
+
+data BufferAppendRegionMethodInfo
+instance (signature ~ (Buffer -> Int64 -> Int64 -> m Buffer), MonadIO m) => MethodInfo BufferAppendRegionMethodInfo Buffer signature where
+    overloadedMethod _ = bufferAppendRegion
+
+-- method Buffer::copy_deep
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Buffer"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_buffer_copy_deep" gst_buffer_copy_deep :: 
+    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"
+    IO (Ptr Buffer)
+
+
+bufferCopyDeep ::
+    (MonadIO m) =>
+    Buffer                                  -- _obj
+    -> m Buffer                             -- result
+bufferCopyDeep _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_buffer_copy_deep _obj'
+    checkUnexpectedReturnNULL "gst_buffer_copy_deep" result
+    result' <- (wrapBoxed Buffer) result
+    touchManagedPtr _obj
+    return result'
+
+data BufferCopyDeepMethodInfo
+instance (signature ~ (m Buffer), MonadIO m) => MethodInfo BufferCopyDeepMethodInfo Buffer signature where
+    overloadedMethod _ = bufferCopyDeep
+
+-- method Buffer::copy_into
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "src", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface "Gst" "BufferCopyFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_buffer_copy_into" gst_buffer_copy_into :: 
+    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"
+    Ptr Buffer ->                           -- src : TInterface "Gst" "Buffer"
+    CUInt ->                                -- flags : TInterface "Gst" "BufferCopyFlags"
+    Word64 ->                               -- offset : TBasicType TUInt64
+    Word64 ->                               -- size : TBasicType TUInt64
+    IO CInt
+
+
+bufferCopyInto ::
+    (MonadIO m) =>
+    Buffer                                  -- _obj
+    -> Buffer                               -- src
+    -> [BufferCopyFlags]                    -- flags
+    -> Word64                               -- offset
+    -> Word64                               -- size
+    -> m Bool                               -- result
+bufferCopyInto _obj src flags offset size = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let src' = unsafeManagedPtrGetPtr src
+    let flags' = gflagsToWord flags
+    result <- gst_buffer_copy_into _obj' src' flags' offset size
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    touchManagedPtr src
+    return result'
+
+data BufferCopyIntoMethodInfo
+instance (signature ~ (Buffer -> [BufferCopyFlags] -> Word64 -> Word64 -> m Bool), MonadIO m) => MethodInfo BufferCopyIntoMethodInfo Buffer signature where
+    overloadedMethod _ = bufferCopyInto
+
+-- method Buffer::copy_region
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface "Gst" "BufferCopyFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Buffer"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_buffer_copy_region" gst_buffer_copy_region :: 
+    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"
+    CUInt ->                                -- flags : TInterface "Gst" "BufferCopyFlags"
+    Word64 ->                               -- offset : TBasicType TUInt64
+    Word64 ->                               -- size : TBasicType TUInt64
+    IO (Ptr Buffer)
+
+
+bufferCopyRegion ::
+    (MonadIO m) =>
+    Buffer                                  -- _obj
+    -> [BufferCopyFlags]                    -- flags
+    -> Word64                               -- offset
+    -> Word64                               -- size
+    -> m Buffer                             -- result
+bufferCopyRegion _obj flags offset size = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let flags' = gflagsToWord flags
+    result <- gst_buffer_copy_region _obj' flags' offset size
+    checkUnexpectedReturnNULL "gst_buffer_copy_region" result
+    result' <- (wrapBoxed Buffer) result
+    touchManagedPtr _obj
+    return result'
+
+data BufferCopyRegionMethodInfo
+instance (signature ~ ([BufferCopyFlags] -> Word64 -> Word64 -> m Buffer), MonadIO m) => MethodInfo BufferCopyRegionMethodInfo Buffer signature where
+    overloadedMethod _ = bufferCopyRegion
+
+-- method Buffer::extract
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUInt64
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_buffer_extract" gst_buffer_extract :: 
+    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"
+    Word64 ->                               -- offset : TBasicType TUInt64
+    Ptr () ->                               -- dest : TBasicType TVoid
+    Word64 ->                               -- size : TBasicType TUInt64
+    IO Word64
+
+
+bufferExtract ::
+    (MonadIO m) =>
+    Buffer                                  -- _obj
+    -> Word64                               -- offset
+    -> Ptr ()                               -- dest
+    -> Word64                               -- size
+    -> m Word64                             -- result
+bufferExtract _obj offset dest size = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_buffer_extract _obj' offset dest size
+    touchManagedPtr _obj
+    return result
+
+data BufferExtractMethodInfo
+instance (signature ~ (Word64 -> Ptr () -> Word64 -> m Word64), MonadIO m) => MethodInfo BufferExtractMethodInfo Buffer signature where
+    overloadedMethod _ = bufferExtract
+
+-- method Buffer::extract_dup
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest", argType = TCArray False (-1) 4 (TBasicType TUInt8), direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "dest_size", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : [Arg {argCName = "dest_size", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_buffer_extract_dup" gst_buffer_extract_dup :: 
+    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"
+    Word64 ->                               -- offset : TBasicType TUInt64
+    Word64 ->                               -- size : TBasicType TUInt64
+    Ptr (Ptr Word8) ->                      -- dest : TCArray False (-1) 4 (TBasicType TUInt8)
+    Ptr Word64 ->                           -- dest_size : TBasicType TUInt64
+    IO ()
+
+
+bufferExtractDup ::
+    (MonadIO m) =>
+    Buffer                                  -- _obj
+    -> Word64                               -- offset
+    -> Word64                               -- size
+    -> m (ByteString)                       -- result
+bufferExtractDup _obj offset size = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    dest <- allocMem :: IO (Ptr (Ptr Word8))
+    destSize <- allocMem :: IO (Ptr Word64)
+    gst_buffer_extract_dup _obj' offset size dest destSize
+    destSize' <- peek destSize
+    dest' <- peek dest
+    dest'' <- (unpackByteStringWithLength destSize') dest'
+    freeMem dest'
+    touchManagedPtr _obj
+    freeMem dest
+    freeMem destSize
+    return dest''
+
+data BufferExtractDupMethodInfo
+instance (signature ~ (Word64 -> Word64 -> m (ByteString)), MonadIO m) => MethodInfo BufferExtractDupMethodInfo Buffer signature where
+    overloadedMethod _ = bufferExtractDup
+
+-- method Buffer::fill
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "src", argType = TCArray False (-1) 3 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : [Arg {argCName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- returnType : TBasicType TUInt64
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_buffer_fill" gst_buffer_fill :: 
+    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"
+    Word64 ->                               -- offset : TBasicType TUInt64
+    Ptr Word8 ->                            -- src : TCArray False (-1) 3 (TBasicType TUInt8)
+    Word64 ->                               -- size : TBasicType TUInt64
+    IO Word64
+
+
+bufferFill ::
+    (MonadIO m) =>
+    Buffer                                  -- _obj
+    -> Word64                               -- offset
+    -> ByteString                           -- src
+    -> m Word64                             -- result
+bufferFill _obj offset src = liftIO $ do
+    let size = fromIntegral $ B.length src
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    src' <- packByteString src
+    result <- gst_buffer_fill _obj' offset src' size
+    touchManagedPtr _obj
+    freeMem src'
+    return result
+
+data BufferFillMethodInfo
+instance (signature ~ (Word64 -> ByteString -> m Word64), MonadIO m) => MethodInfo BufferFillMethodInfo Buffer signature where
+    overloadedMethod _ = bufferFill
+
+-- method Buffer::find_memory
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "idx", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "length", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "skip", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_buffer_find_memory" gst_buffer_find_memory :: 
+    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"
+    Word64 ->                               -- offset : TBasicType TUInt64
+    Word64 ->                               -- size : TBasicType TUInt64
+    Ptr Word32 ->                           -- idx : TBasicType TUInt32
+    Ptr Word32 ->                           -- length : TBasicType TUInt32
+    Ptr Word64 ->                           -- skip : TBasicType TUInt64
+    IO CInt
+
+
+bufferFindMemory ::
+    (MonadIO m) =>
+    Buffer                                  -- _obj
+    -> Word64                               -- offset
+    -> Word64                               -- size
+    -> m (Bool,Word32,Word32,Word64)        -- result
+bufferFindMemory _obj offset size = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    idx <- allocMem :: IO (Ptr Word32)
+    length_ <- allocMem :: IO (Ptr Word32)
+    skip <- allocMem :: IO (Ptr Word64)
+    result <- gst_buffer_find_memory _obj' offset size idx length_ skip
+    let result' = (/= 0) result
+    idx' <- peek idx
+    length_' <- peek length_
+    skip' <- peek skip
+    touchManagedPtr _obj
+    freeMem idx
+    freeMem length_
+    freeMem skip
+    return (result', idx', length_', skip')
+
+data BufferFindMemoryMethodInfo
+instance (signature ~ (Word64 -> Word64 -> m (Bool,Word32,Word32,Word64)), MonadIO m) => MethodInfo BufferFindMemoryMethodInfo Buffer signature where
+    overloadedMethod _ = bufferFindMemory
+
+-- method Buffer::foreach_meta
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "func", argType = TInterface "Gst" "BufferForeachMetaFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_buffer_foreach_meta" gst_buffer_foreach_meta :: 
+    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"
+    FunPtr BufferForeachMetaFuncC ->        -- func : TInterface "Gst" "BufferForeachMetaFunc"
+    Ptr () ->                               -- user_data : TBasicType TVoid
+    IO CInt
+
+
+bufferForeachMeta ::
+    (MonadIO m) =>
+    Buffer                                  -- _obj
+    -> BufferForeachMetaFunc                -- func
+    -> m Bool                               -- result
+bufferForeachMeta _obj func = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    func' <- mkBufferForeachMetaFunc (bufferForeachMetaFuncWrapper Nothing func)
+    let userData = nullPtr
+    result <- gst_buffer_foreach_meta _obj' func' userData
+    let result' = (/= 0) result
+    safeFreeFunPtr $ castFunPtrToPtr func'
+    touchManagedPtr _obj
+    return result'
+
+data BufferForeachMetaMethodInfo
+instance (signature ~ (BufferForeachMetaFunc -> m Bool), MonadIO m) => MethodInfo BufferForeachMetaMethodInfo Buffer signature where
+    overloadedMethod _ = bufferForeachMeta
+
+-- method Buffer::get_all_memory
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Memory"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_buffer_get_all_memory" gst_buffer_get_all_memory :: 
+    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"
+    IO (Ptr Memory)
+
+
+bufferGetAllMemory ::
+    (MonadIO m) =>
+    Buffer                                  -- _obj
+    -> m Memory                             -- result
+bufferGetAllMemory _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_buffer_get_all_memory _obj'
+    checkUnexpectedReturnNULL "gst_buffer_get_all_memory" result
+    result' <- (wrapBoxed Memory) result
+    touchManagedPtr _obj
+    return result'
+
+data BufferGetAllMemoryMethodInfo
+instance (signature ~ (m Memory), MonadIO m) => MethodInfo BufferGetAllMemoryMethodInfo Buffer signature where
+    overloadedMethod _ = bufferGetAllMemory
+
+-- method Buffer::get_memory
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "idx", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Memory"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_buffer_get_memory" gst_buffer_get_memory :: 
+    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"
+    Word32 ->                               -- idx : TBasicType TUInt32
+    IO (Ptr Memory)
+
+
+bufferGetMemory ::
+    (MonadIO m) =>
+    Buffer                                  -- _obj
+    -> Word32                               -- idx
+    -> m Memory                             -- result
+bufferGetMemory _obj idx = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_buffer_get_memory _obj' idx
+    checkUnexpectedReturnNULL "gst_buffer_get_memory" result
+    result' <- (wrapBoxed Memory) result
+    touchManagedPtr _obj
+    return result'
+
+data BufferGetMemoryMethodInfo
+instance (signature ~ (Word32 -> m Memory), MonadIO m) => MethodInfo BufferGetMemoryMethodInfo Buffer signature where
+    overloadedMethod _ = bufferGetMemory
+
+-- method Buffer::get_memory_range
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "idx", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "length", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Memory"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_buffer_get_memory_range" gst_buffer_get_memory_range :: 
+    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"
+    Word32 ->                               -- idx : TBasicType TUInt32
+    Int32 ->                                -- length : TBasicType TInt32
+    IO (Ptr Memory)
+
+
+bufferGetMemoryRange ::
+    (MonadIO m) =>
+    Buffer                                  -- _obj
+    -> Word32                               -- idx
+    -> Int32                                -- length_
+    -> m Memory                             -- result
+bufferGetMemoryRange _obj idx length_ = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_buffer_get_memory_range _obj' idx length_
+    checkUnexpectedReturnNULL "gst_buffer_get_memory_range" result
+    result' <- (wrapBoxed Memory) result
+    touchManagedPtr _obj
+    return result'
+
+data BufferGetMemoryRangeMethodInfo
+instance (signature ~ (Word32 -> Int32 -> m Memory), MonadIO m) => MethodInfo BufferGetMemoryRangeMethodInfo Buffer signature where
+    overloadedMethod _ = bufferGetMemoryRange
+
+-- method Buffer::get_meta
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "api", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Meta"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_buffer_get_meta" gst_buffer_get_meta :: 
+    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"
+    CGType ->                               -- api : TBasicType TGType
+    IO (Ptr Meta)
+
+
+bufferGetMeta ::
+    (MonadIO m) =>
+    Buffer                                  -- _obj
+    -> GType                                -- api
+    -> m Meta                               -- result
+bufferGetMeta _obj api = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let api' = gtypeToCGType api
+    result <- gst_buffer_get_meta _obj' api'
+    checkUnexpectedReturnNULL "gst_buffer_get_meta" result
+    result' <- (newPtr 16 Meta) result
+    touchManagedPtr _obj
+    return result'
+
+data BufferGetMetaMethodInfo
+instance (signature ~ (GType -> m Meta), MonadIO m) => MethodInfo BufferGetMetaMethodInfo Buffer signature where
+    overloadedMethod _ = bufferGetMeta
+
+-- method Buffer::get_size
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUInt64
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_buffer_get_size" gst_buffer_get_size :: 
+    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"
+    IO Word64
+
+
+bufferGetSize ::
+    (MonadIO m) =>
+    Buffer                                  -- _obj
+    -> m Word64                             -- result
+bufferGetSize _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_buffer_get_size _obj'
+    touchManagedPtr _obj
+    return result
+
+data BufferGetSizeMethodInfo
+instance (signature ~ (m Word64), MonadIO m) => MethodInfo BufferGetSizeMethodInfo Buffer signature where
+    overloadedMethod _ = bufferGetSize
+
+-- method Buffer::get_sizes
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "maxsize", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TUInt64
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_buffer_get_sizes" gst_buffer_get_sizes :: 
+    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"
+    Ptr Word64 ->                           -- offset : TBasicType TUInt64
+    Ptr Word64 ->                           -- maxsize : TBasicType TUInt64
+    IO Word64
+
+
+bufferGetSizes ::
+    (MonadIO m) =>
+    Buffer                                  -- _obj
+    -> m (Word64,Word64,Word64)             -- result
+bufferGetSizes _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    offset <- allocMem :: IO (Ptr Word64)
+    maxsize <- allocMem :: IO (Ptr Word64)
+    result <- gst_buffer_get_sizes _obj' offset maxsize
+    offset' <- peek offset
+    maxsize' <- peek maxsize
+    touchManagedPtr _obj
+    freeMem offset
+    freeMem maxsize
+    return (result, offset', maxsize')
+
+data BufferGetSizesMethodInfo
+instance (signature ~ (m (Word64,Word64,Word64)), MonadIO m) => MethodInfo BufferGetSizesMethodInfo Buffer signature where
+    overloadedMethod _ = bufferGetSizes
+
+-- method Buffer::get_sizes_range
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "idx", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "length", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "maxsize", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TUInt64
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_buffer_get_sizes_range" gst_buffer_get_sizes_range :: 
+    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"
+    Word32 ->                               -- idx : TBasicType TUInt32
+    Int32 ->                                -- length : TBasicType TInt32
+    Ptr Word64 ->                           -- offset : TBasicType TUInt64
+    Ptr Word64 ->                           -- maxsize : TBasicType TUInt64
+    IO Word64
+
+
+bufferGetSizesRange ::
+    (MonadIO m) =>
+    Buffer                                  -- _obj
+    -> Word32                               -- idx
+    -> Int32                                -- length_
+    -> m (Word64,Word64,Word64)             -- result
+bufferGetSizesRange _obj idx length_ = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    offset <- allocMem :: IO (Ptr Word64)
+    maxsize <- allocMem :: IO (Ptr Word64)
+    result <- gst_buffer_get_sizes_range _obj' idx length_ offset maxsize
+    offset' <- peek offset
+    maxsize' <- peek maxsize
+    touchManagedPtr _obj
+    freeMem offset
+    freeMem maxsize
+    return (result, offset', maxsize')
+
+data BufferGetSizesRangeMethodInfo
+instance (signature ~ (Word32 -> Int32 -> m (Word64,Word64,Word64)), MonadIO m) => MethodInfo BufferGetSizesRangeMethodInfo Buffer signature where
+    overloadedMethod _ = bufferGetSizesRange
+
+-- method Buffer::insert_memory
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "idx", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mem", argType = TInterface "Gst" "Memory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_buffer_insert_memory" gst_buffer_insert_memory :: 
+    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"
+    Int32 ->                                -- idx : TBasicType TInt32
+    Ptr Memory ->                           -- mem : TInterface "Gst" "Memory"
+    IO ()
+
+
+bufferInsertMemory ::
+    (MonadIO m) =>
+    Buffer                                  -- _obj
+    -> Int32                                -- idx
+    -> Memory                               -- mem
+    -> m ()                                 -- result
+bufferInsertMemory _obj idx mem = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    mem' <- copyBoxed mem
+    gst_buffer_insert_memory _obj' idx mem'
+    touchManagedPtr _obj
+    touchManagedPtr mem
+    return ()
+
+data BufferInsertMemoryMethodInfo
+instance (signature ~ (Int32 -> Memory -> m ()), MonadIO m) => MethodInfo BufferInsertMemoryMethodInfo Buffer signature where
+    overloadedMethod _ = bufferInsertMemory
+
+-- method Buffer::is_all_memory_writable
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_buffer_is_all_memory_writable" gst_buffer_is_all_memory_writable :: 
+    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"
+    IO CInt
+
+
+bufferIsAllMemoryWritable ::
+    (MonadIO m) =>
+    Buffer                                  -- _obj
+    -> m Bool                               -- result
+bufferIsAllMemoryWritable _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_buffer_is_all_memory_writable _obj'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data BufferIsAllMemoryWritableMethodInfo
+instance (signature ~ (m Bool), MonadIO m) => MethodInfo BufferIsAllMemoryWritableMethodInfo Buffer signature where
+    overloadedMethod _ = bufferIsAllMemoryWritable
+
+-- method Buffer::is_memory_range_writable
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "idx", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "length", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_buffer_is_memory_range_writable" gst_buffer_is_memory_range_writable :: 
+    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"
+    Word32 ->                               -- idx : TBasicType TUInt32
+    Int32 ->                                -- length : TBasicType TInt32
+    IO CInt
+
+
+bufferIsMemoryRangeWritable ::
+    (MonadIO m) =>
+    Buffer                                  -- _obj
+    -> Word32                               -- idx
+    -> Int32                                -- length_
+    -> m Bool                               -- result
+bufferIsMemoryRangeWritable _obj idx length_ = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_buffer_is_memory_range_writable _obj' idx length_
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data BufferIsMemoryRangeWritableMethodInfo
+instance (signature ~ (Word32 -> Int32 -> m Bool), MonadIO m) => MethodInfo BufferIsMemoryRangeWritableMethodInfo Buffer signature where
+    overloadedMethod _ = bufferIsMemoryRangeWritable
+
+-- method Buffer::iterate_meta
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "state", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Meta"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_buffer_iterate_meta" gst_buffer_iterate_meta :: 
+    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"
+    Ptr () ->                               -- state : TBasicType TVoid
+    IO (Ptr Meta)
+
+
+bufferIterateMeta ::
+    (MonadIO m) =>
+    Buffer                                  -- _obj
+    -> Ptr ()                               -- state
+    -> m Meta                               -- result
+bufferIterateMeta _obj state = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_buffer_iterate_meta _obj' state
+    checkUnexpectedReturnNULL "gst_buffer_iterate_meta" result
+    result' <- (newPtr 16 Meta) result
+    touchManagedPtr _obj
+    return result'
+
+data BufferIterateMetaMethodInfo
+instance (signature ~ (Ptr () -> m Meta), MonadIO m) => MethodInfo BufferIterateMetaMethodInfo Buffer signature where
+    overloadedMethod _ = bufferIterateMeta
+
+-- method Buffer::map
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "info", argType = TInterface "Gst" "MapInfo", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface "Gst" "MapFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_buffer_map" gst_buffer_map :: 
+    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"
+    Ptr MapInfo ->                          -- info : TInterface "Gst" "MapInfo"
+    CUInt ->                                -- flags : TInterface "Gst" "MapFlags"
+    IO CInt
+
+
+bufferMap ::
+    (MonadIO m) =>
+    Buffer                                  -- _obj
+    -> [MapFlags]                           -- flags
+    -> m (Bool,MapInfo)                     -- result
+bufferMap _obj flags = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    info <- callocBytes 104 :: IO (Ptr MapInfo)
+    let flags' = gflagsToWord flags
+    result <- gst_buffer_map _obj' info flags'
+    let result' = (/= 0) result
+    info' <- (wrapPtr MapInfo) info
+    touchManagedPtr _obj
+    return (result', info')
+
+data BufferMapMethodInfo
+instance (signature ~ ([MapFlags] -> m (Bool,MapInfo)), MonadIO m) => MethodInfo BufferMapMethodInfo Buffer signature where
+    overloadedMethod _ = bufferMap
+
+-- method Buffer::map_range
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "idx", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "length", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "info", argType = TInterface "Gst" "MapInfo", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface "Gst" "MapFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_buffer_map_range" gst_buffer_map_range :: 
+    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"
+    Word32 ->                               -- idx : TBasicType TUInt32
+    Int32 ->                                -- length : TBasicType TInt32
+    Ptr MapInfo ->                          -- info : TInterface "Gst" "MapInfo"
+    CUInt ->                                -- flags : TInterface "Gst" "MapFlags"
+    IO CInt
+
+
+bufferMapRange ::
+    (MonadIO m) =>
+    Buffer                                  -- _obj
+    -> Word32                               -- idx
+    -> Int32                                -- length_
+    -> [MapFlags]                           -- flags
+    -> m (Bool,MapInfo)                     -- result
+bufferMapRange _obj idx length_ flags = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    info <- callocBytes 104 :: IO (Ptr MapInfo)
+    let flags' = gflagsToWord flags
+    result <- gst_buffer_map_range _obj' idx length_ info flags'
+    let result' = (/= 0) result
+    info' <- (wrapPtr MapInfo) info
+    touchManagedPtr _obj
+    return (result', info')
+
+data BufferMapRangeMethodInfo
+instance (signature ~ (Word32 -> Int32 -> [MapFlags] -> m (Bool,MapInfo)), MonadIO m) => MethodInfo BufferMapRangeMethodInfo Buffer signature where
+    overloadedMethod _ = bufferMapRange
+
+-- method Buffer::memcmp
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mem", argType = TCArray False (-1) 3 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : [Arg {argCName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- returnType : TBasicType TInt32
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_buffer_memcmp" gst_buffer_memcmp :: 
+    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"
+    Word64 ->                               -- offset : TBasicType TUInt64
+    Ptr Word8 ->                            -- mem : TCArray False (-1) 3 (TBasicType TUInt8)
+    Word64 ->                               -- size : TBasicType TUInt64
+    IO Int32
+
+
+bufferMemcmp ::
+    (MonadIO m) =>
+    Buffer                                  -- _obj
+    -> Word64                               -- offset
+    -> ByteString                           -- mem
+    -> m Int32                              -- result
+bufferMemcmp _obj offset mem = liftIO $ do
+    let size = fromIntegral $ B.length mem
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    mem' <- packByteString mem
+    result <- gst_buffer_memcmp _obj' offset mem' size
+    touchManagedPtr _obj
+    freeMem mem'
+    return result
+
+data BufferMemcmpMethodInfo
+instance (signature ~ (Word64 -> ByteString -> m Int32), MonadIO m) => MethodInfo BufferMemcmpMethodInfo Buffer signature where
+    overloadedMethod _ = bufferMemcmp
+
+-- method Buffer::memset
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "val", argType = TBasicType TUInt8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUInt64
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_buffer_memset" gst_buffer_memset :: 
+    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"
+    Word64 ->                               -- offset : TBasicType TUInt64
+    Word8 ->                                -- val : TBasicType TUInt8
+    Word64 ->                               -- size : TBasicType TUInt64
+    IO Word64
+
+
+bufferMemset ::
+    (MonadIO m) =>
+    Buffer                                  -- _obj
+    -> Word64                               -- offset
+    -> Word8                                -- val
+    -> Word64                               -- size
+    -> m Word64                             -- result
+bufferMemset _obj offset val size = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_buffer_memset _obj' offset val size
+    touchManagedPtr _obj
+    return result
+
+data BufferMemsetMethodInfo
+instance (signature ~ (Word64 -> Word8 -> Word64 -> m Word64), MonadIO m) => MethodInfo BufferMemsetMethodInfo Buffer signature where
+    overloadedMethod _ = bufferMemset
+
+-- method Buffer::n_memory
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUInt32
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_buffer_n_memory" gst_buffer_n_memory :: 
+    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"
+    IO Word32
+
+
+bufferNMemory ::
+    (MonadIO m) =>
+    Buffer                                  -- _obj
+    -> m Word32                             -- result
+bufferNMemory _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_buffer_n_memory _obj'
+    touchManagedPtr _obj
+    return result
+
+data BufferNMemoryMethodInfo
+instance (signature ~ (m Word32), MonadIO m) => MethodInfo BufferNMemoryMethodInfo Buffer signature where
+    overloadedMethod _ = bufferNMemory
+
+-- method Buffer::peek_memory
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "idx", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Memory"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_buffer_peek_memory" gst_buffer_peek_memory :: 
+    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"
+    Word32 ->                               -- idx : TBasicType TUInt32
+    IO (Ptr Memory)
+
+
+bufferPeekMemory ::
+    (MonadIO m) =>
+    Buffer                                  -- _obj
+    -> Word32                               -- idx
+    -> m Memory                             -- result
+bufferPeekMemory _obj idx = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_buffer_peek_memory _obj' idx
+    checkUnexpectedReturnNULL "gst_buffer_peek_memory" result
+    result' <- (newBoxed Memory) result
+    touchManagedPtr _obj
+    return result'
+
+data BufferPeekMemoryMethodInfo
+instance (signature ~ (Word32 -> m Memory), MonadIO m) => MethodInfo BufferPeekMemoryMethodInfo Buffer signature where
+    overloadedMethod _ = bufferPeekMemory
+
+-- method Buffer::prepend_memory
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mem", argType = TInterface "Gst" "Memory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_buffer_prepend_memory" gst_buffer_prepend_memory :: 
+    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"
+    Ptr Memory ->                           -- mem : TInterface "Gst" "Memory"
+    IO ()
+
+
+bufferPrependMemory ::
+    (MonadIO m) =>
+    Buffer                                  -- _obj
+    -> Memory                               -- mem
+    -> m ()                                 -- result
+bufferPrependMemory _obj mem = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    mem' <- copyBoxed mem
+    gst_buffer_prepend_memory _obj' mem'
+    touchManagedPtr _obj
+    touchManagedPtr mem
+    return ()
+
+data BufferPrependMemoryMethodInfo
+instance (signature ~ (Memory -> m ()), MonadIO m) => MethodInfo BufferPrependMemoryMethodInfo Buffer signature where
+    overloadedMethod _ = bufferPrependMemory
+
+-- method Buffer::remove_all_memory
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_buffer_remove_all_memory" gst_buffer_remove_all_memory :: 
+    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"
+    IO ()
+
+
+bufferRemoveAllMemory ::
+    (MonadIO m) =>
+    Buffer                                  -- _obj
+    -> m ()                                 -- result
+bufferRemoveAllMemory _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    gst_buffer_remove_all_memory _obj'
+    touchManagedPtr _obj
+    return ()
+
+data BufferRemoveAllMemoryMethodInfo
+instance (signature ~ (m ()), MonadIO m) => MethodInfo BufferRemoveAllMemoryMethodInfo Buffer signature where
+    overloadedMethod _ = bufferRemoveAllMemory
+
+-- method Buffer::remove_memory
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "idx", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_buffer_remove_memory" gst_buffer_remove_memory :: 
+    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"
+    Word32 ->                               -- idx : TBasicType TUInt32
+    IO ()
+
+
+bufferRemoveMemory ::
+    (MonadIO m) =>
+    Buffer                                  -- _obj
+    -> Word32                               -- idx
+    -> m ()                                 -- result
+bufferRemoveMemory _obj idx = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    gst_buffer_remove_memory _obj' idx
+    touchManagedPtr _obj
+    return ()
+
+data BufferRemoveMemoryMethodInfo
+instance (signature ~ (Word32 -> m ()), MonadIO m) => MethodInfo BufferRemoveMemoryMethodInfo Buffer signature where
+    overloadedMethod _ = bufferRemoveMemory
+
+-- method Buffer::remove_memory_range
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "idx", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "length", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_buffer_remove_memory_range" gst_buffer_remove_memory_range :: 
+    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"
+    Word32 ->                               -- idx : TBasicType TUInt32
+    Int32 ->                                -- length : TBasicType TInt32
+    IO ()
+
+
+bufferRemoveMemoryRange ::
+    (MonadIO m) =>
+    Buffer                                  -- _obj
+    -> Word32                               -- idx
+    -> Int32                                -- length_
+    -> m ()                                 -- result
+bufferRemoveMemoryRange _obj idx length_ = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    gst_buffer_remove_memory_range _obj' idx length_
+    touchManagedPtr _obj
+    return ()
+
+data BufferRemoveMemoryRangeMethodInfo
+instance (signature ~ (Word32 -> Int32 -> m ()), MonadIO m) => MethodInfo BufferRemoveMemoryRangeMethodInfo Buffer signature where
+    overloadedMethod _ = bufferRemoveMemoryRange
+
+-- method Buffer::remove_meta
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "meta", argType = TInterface "Gst" "Meta", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_buffer_remove_meta" gst_buffer_remove_meta :: 
+    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"
+    Ptr Meta ->                             -- meta : TInterface "Gst" "Meta"
+    IO CInt
+
+
+bufferRemoveMeta ::
+    (MonadIO m) =>
+    Buffer                                  -- _obj
+    -> Meta                                 -- meta
+    -> m Bool                               -- result
+bufferRemoveMeta _obj meta = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let meta' = unsafeManagedPtrGetPtr meta
+    result <- gst_buffer_remove_meta _obj' meta'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    touchManagedPtr meta
+    return result'
+
+data BufferRemoveMetaMethodInfo
+instance (signature ~ (Meta -> m Bool), MonadIO m) => MethodInfo BufferRemoveMetaMethodInfo Buffer signature where
+    overloadedMethod _ = bufferRemoveMeta
+
+-- method Buffer::replace_all_memory
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mem", argType = TInterface "Gst" "Memory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_buffer_replace_all_memory" gst_buffer_replace_all_memory :: 
+    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"
+    Ptr Memory ->                           -- mem : TInterface "Gst" "Memory"
+    IO ()
+
+
+bufferReplaceAllMemory ::
+    (MonadIO m) =>
+    Buffer                                  -- _obj
+    -> Memory                               -- mem
+    -> m ()                                 -- result
+bufferReplaceAllMemory _obj mem = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    mem' <- copyBoxed mem
+    gst_buffer_replace_all_memory _obj' mem'
+    touchManagedPtr _obj
+    touchManagedPtr mem
+    return ()
+
+data BufferReplaceAllMemoryMethodInfo
+instance (signature ~ (Memory -> m ()), MonadIO m) => MethodInfo BufferReplaceAllMemoryMethodInfo Buffer signature where
+    overloadedMethod _ = bufferReplaceAllMemory
+
+-- method Buffer::replace_memory
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "idx", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mem", argType = TInterface "Gst" "Memory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_buffer_replace_memory" gst_buffer_replace_memory :: 
+    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"
+    Word32 ->                               -- idx : TBasicType TUInt32
+    Ptr Memory ->                           -- mem : TInterface "Gst" "Memory"
+    IO ()
+
+
+bufferReplaceMemory ::
+    (MonadIO m) =>
+    Buffer                                  -- _obj
+    -> Word32                               -- idx
+    -> Memory                               -- mem
+    -> m ()                                 -- result
+bufferReplaceMemory _obj idx mem = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    mem' <- copyBoxed mem
+    gst_buffer_replace_memory _obj' idx mem'
+    touchManagedPtr _obj
+    touchManagedPtr mem
+    return ()
+
+data BufferReplaceMemoryMethodInfo
+instance (signature ~ (Word32 -> Memory -> m ()), MonadIO m) => MethodInfo BufferReplaceMemoryMethodInfo Buffer signature where
+    overloadedMethod _ = bufferReplaceMemory
+
+-- method Buffer::replace_memory_range
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "idx", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "length", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mem", argType = TInterface "Gst" "Memory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_buffer_replace_memory_range" gst_buffer_replace_memory_range :: 
+    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"
+    Word32 ->                               -- idx : TBasicType TUInt32
+    Int32 ->                                -- length : TBasicType TInt32
+    Ptr Memory ->                           -- mem : TInterface "Gst" "Memory"
+    IO ()
+
+
+bufferReplaceMemoryRange ::
+    (MonadIO m) =>
+    Buffer                                  -- _obj
+    -> Word32                               -- idx
+    -> Int32                                -- length_
+    -> Memory                               -- mem
+    -> m ()                                 -- result
+bufferReplaceMemoryRange _obj idx length_ mem = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    mem' <- copyBoxed mem
+    gst_buffer_replace_memory_range _obj' idx length_ mem'
+    touchManagedPtr _obj
+    touchManagedPtr mem
+    return ()
+
+data BufferReplaceMemoryRangeMethodInfo
+instance (signature ~ (Word32 -> Int32 -> Memory -> m ()), MonadIO m) => MethodInfo BufferReplaceMemoryRangeMethodInfo Buffer signature where
+    overloadedMethod _ = bufferReplaceMemoryRange
+
+-- method Buffer::resize
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_buffer_resize" gst_buffer_resize :: 
+    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"
+    Int64 ->                                -- offset : TBasicType TInt64
+    Int64 ->                                -- size : TBasicType TInt64
+    IO ()
+
+
+bufferResize ::
+    (MonadIO m) =>
+    Buffer                                  -- _obj
+    -> Int64                                -- offset
+    -> Int64                                -- size
+    -> m ()                                 -- result
+bufferResize _obj offset size = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    gst_buffer_resize _obj' offset size
+    touchManagedPtr _obj
+    return ()
+
+data BufferResizeMethodInfo
+instance (signature ~ (Int64 -> Int64 -> m ()), MonadIO m) => MethodInfo BufferResizeMethodInfo Buffer signature where
+    overloadedMethod _ = bufferResize
+
+-- method Buffer::resize_range
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "idx", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "length", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_buffer_resize_range" gst_buffer_resize_range :: 
+    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"
+    Word32 ->                               -- idx : TBasicType TUInt32
+    Int32 ->                                -- length : TBasicType TInt32
+    Int64 ->                                -- offset : TBasicType TInt64
+    Int64 ->                                -- size : TBasicType TInt64
+    IO CInt
+
+
+bufferResizeRange ::
+    (MonadIO m) =>
+    Buffer                                  -- _obj
+    -> Word32                               -- idx
+    -> Int32                                -- length_
+    -> Int64                                -- offset
+    -> Int64                                -- size
+    -> m Bool                               -- result
+bufferResizeRange _obj idx length_ offset size = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_buffer_resize_range _obj' idx length_ offset size
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data BufferResizeRangeMethodInfo
+instance (signature ~ (Word32 -> Int32 -> Int64 -> Int64 -> m Bool), MonadIO m) => MethodInfo BufferResizeRangeMethodInfo Buffer signature where
+    overloadedMethod _ = bufferResizeRange
+
+-- method Buffer::set_size
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_buffer_set_size" gst_buffer_set_size :: 
+    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"
+    Int64 ->                                -- size : TBasicType TInt64
+    IO ()
+
+
+bufferSetSize ::
+    (MonadIO m) =>
+    Buffer                                  -- _obj
+    -> Int64                                -- size
+    -> m ()                                 -- result
+bufferSetSize _obj size = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    gst_buffer_set_size _obj' size
+    touchManagedPtr _obj
+    return ()
+
+data BufferSetSizeMethodInfo
+instance (signature ~ (Int64 -> m ()), MonadIO m) => MethodInfo BufferSetSizeMethodInfo Buffer signature where
+    overloadedMethod _ = bufferSetSize
+
+-- method Buffer::unmap
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "info", argType = TInterface "Gst" "MapInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_buffer_unmap" gst_buffer_unmap :: 
+    Ptr Buffer ->                           -- _obj : TInterface "Gst" "Buffer"
+    Ptr MapInfo ->                          -- info : TInterface "Gst" "MapInfo"
+    IO ()
+
+
+bufferUnmap ::
+    (MonadIO m) =>
+    Buffer                                  -- _obj
+    -> MapInfo                              -- info
+    -> m ()                                 -- result
+bufferUnmap _obj info = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let info' = unsafeManagedPtrGetPtr info
+    gst_buffer_unmap _obj' info'
+    touchManagedPtr _obj
+    touchManagedPtr info
+    return ()
+
+data BufferUnmapMethodInfo
+instance (signature ~ (MapInfo -> m ()), MonadIO m) => MethodInfo BufferUnmapMethodInfo Buffer signature where
+    overloadedMethod _ = bufferUnmap
+
+-- method Buffer::get_max_memory
+-- method type : MemberFunction
+-- Args : []
+-- Lengths : []
+-- returnType : TBasicType TUInt32
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_buffer_get_max_memory" gst_buffer_get_max_memory :: 
+    IO Word32
+
+
+bufferGetMaxMemory ::
+    (MonadIO m) =>
+    m Word32                                -- result
+bufferGetMaxMemory  = liftIO $ do
+    result <- gst_buffer_get_max_memory
+    return result
+
+type family ResolveBufferMethod (t :: Symbol) (o :: *) :: * where
+    ResolveBufferMethod "addMeta" o = BufferAddMetaMethodInfo
+    ResolveBufferMethod "addParentBufferMeta" o = BufferAddParentBufferMetaMethodInfo
+    ResolveBufferMethod "addProtectionMeta" o = BufferAddProtectionMetaMethodInfo
+    ResolveBufferMethod "append" o = BufferAppendMethodInfo
+    ResolveBufferMethod "appendMemory" o = BufferAppendMemoryMethodInfo
+    ResolveBufferMethod "appendRegion" o = BufferAppendRegionMethodInfo
+    ResolveBufferMethod "copyDeep" o = BufferCopyDeepMethodInfo
+    ResolveBufferMethod "copyInto" o = BufferCopyIntoMethodInfo
+    ResolveBufferMethod "copyRegion" o = BufferCopyRegionMethodInfo
+    ResolveBufferMethod "extract" o = BufferExtractMethodInfo
+    ResolveBufferMethod "extractDup" o = BufferExtractDupMethodInfo
+    ResolveBufferMethod "fill" o = BufferFillMethodInfo
+    ResolveBufferMethod "findMemory" o = BufferFindMemoryMethodInfo
+    ResolveBufferMethod "foreachMeta" o = BufferForeachMetaMethodInfo
+    ResolveBufferMethod "insertMemory" o = BufferInsertMemoryMethodInfo
+    ResolveBufferMethod "isAllMemoryWritable" o = BufferIsAllMemoryWritableMethodInfo
+    ResolveBufferMethod "isMemoryRangeWritable" o = BufferIsMemoryRangeWritableMethodInfo
+    ResolveBufferMethod "iterateMeta" o = BufferIterateMetaMethodInfo
+    ResolveBufferMethod "map" o = BufferMapMethodInfo
+    ResolveBufferMethod "mapRange" o = BufferMapRangeMethodInfo
+    ResolveBufferMethod "memcmp" o = BufferMemcmpMethodInfo
+    ResolveBufferMethod "memset" o = BufferMemsetMethodInfo
+    ResolveBufferMethod "nMemory" o = BufferNMemoryMethodInfo
+    ResolveBufferMethod "peekMemory" o = BufferPeekMemoryMethodInfo
+    ResolveBufferMethod "prependMemory" o = BufferPrependMemoryMethodInfo
+    ResolveBufferMethod "removeAllMemory" o = BufferRemoveAllMemoryMethodInfo
+    ResolveBufferMethod "removeMemory" o = BufferRemoveMemoryMethodInfo
+    ResolveBufferMethod "removeMemoryRange" o = BufferRemoveMemoryRangeMethodInfo
+    ResolveBufferMethod "removeMeta" o = BufferRemoveMetaMethodInfo
+    ResolveBufferMethod "replaceAllMemory" o = BufferReplaceAllMemoryMethodInfo
+    ResolveBufferMethod "replaceMemory" o = BufferReplaceMemoryMethodInfo
+    ResolveBufferMethod "replaceMemoryRange" o = BufferReplaceMemoryRangeMethodInfo
+    ResolveBufferMethod "resize" o = BufferResizeMethodInfo
+    ResolveBufferMethod "resizeRange" o = BufferResizeRangeMethodInfo
+    ResolveBufferMethod "unmap" o = BufferUnmapMethodInfo
+    ResolveBufferMethod "getAllMemory" o = BufferGetAllMemoryMethodInfo
+    ResolveBufferMethod "getMemory" o = BufferGetMemoryMethodInfo
+    ResolveBufferMethod "getMemoryRange" o = BufferGetMemoryRangeMethodInfo
+    ResolveBufferMethod "getMeta" o = BufferGetMetaMethodInfo
+    ResolveBufferMethod "getSize" o = BufferGetSizeMethodInfo
+    ResolveBufferMethod "getSizes" o = BufferGetSizesMethodInfo
+    ResolveBufferMethod "getSizesRange" o = BufferGetSizesRangeMethodInfo
+    ResolveBufferMethod "setSize" o = BufferSetSizeMethodInfo
+    ResolveBufferMethod l o = MethodResolutionFailed l o
+
+instance (info ~ ResolveBufferMethod t Buffer, MethodInfo info Buffer p) => IsLabelProxy t (Buffer -> p) where
+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)
+
+#if MIN_VERSION_base(4,9,0)
+instance (info ~ ResolveBufferMethod t Buffer, MethodInfo info Buffer p) => IsLabel t (Buffer -> p) where
+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)
+#endif
+
+
diff --git a/GI/Gst/Structs/Buffer.hs-boot b/GI/Gst/Structs/Buffer.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/Buffer.hs-boot
@@ -0,0 +1,54 @@
+module GI.Gst.Structs.Buffer where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+newtype Buffer = Buffer (ForeignPtr Buffer)
+instance BoxedObject Buffer where
+data BufferAddMetaMethodInfo
+data BufferAddParentBufferMetaMethodInfo
+data BufferAddProtectionMetaMethodInfo
+data BufferAppendMethodInfo
+data BufferAppendMemoryMethodInfo
+data BufferAppendRegionMethodInfo
+data BufferCopyDeepMethodInfo
+data BufferCopyIntoMethodInfo
+data BufferCopyRegionMethodInfo
+data BufferExtractMethodInfo
+data BufferExtractDupMethodInfo
+data BufferFillMethodInfo
+data BufferFindMemoryMethodInfo
+data BufferForeachMetaMethodInfo
+data BufferGetAllMemoryMethodInfo
+data BufferGetMemoryMethodInfo
+data BufferGetMemoryRangeMethodInfo
+data BufferGetMetaMethodInfo
+data BufferGetSizeMethodInfo
+data BufferGetSizesMethodInfo
+data BufferGetSizesRangeMethodInfo
+data BufferInsertMemoryMethodInfo
+data BufferIsAllMemoryWritableMethodInfo
+data BufferIsMemoryRangeWritableMethodInfo
+data BufferIterateMetaMethodInfo
+data BufferMapMethodInfo
+data BufferMapRangeMethodInfo
+data BufferMemcmpMethodInfo
+data BufferMemsetMethodInfo
+data BufferNMemoryMethodInfo
+data BufferPeekMemoryMethodInfo
+data BufferPrependMemoryMethodInfo
+data BufferRemoveAllMemoryMethodInfo
+data BufferRemoveMemoryMethodInfo
+data BufferRemoveMemoryRangeMethodInfo
+data BufferRemoveMetaMethodInfo
+data BufferReplaceAllMemoryMethodInfo
+data BufferReplaceMemoryMethodInfo
+data BufferReplaceMemoryRangeMethodInfo
+data BufferResizeMethodInfo
+data BufferResizeRangeMethodInfo
+data BufferSetSizeMethodInfo
+data BufferUnmapMethodInfo
diff --git a/GI/Gst/Structs/BufferList.hs b/GI/Gst/Structs/BufferList.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/BufferList.hs
@@ -0,0 +1,335 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+
+Buffer lists are an object containing a list of buffers.
+
+Buffer lists are created with gst_buffer_list_new() and filled with data
+using a gst_buffer_list_insert().
+
+Buffer lists can be pushed on a srcpad with gst_pad_push_list(). This is
+interesting when multiple buffers need to be pushed in one go because it
+can reduce the amount of overhead for pushing each buffer individually.
+-}
+
+module GI.Gst.Structs.BufferList
+    ( 
+
+-- * Exported types
+    BufferList(..)                          ,
+    noBufferList                            ,
+
+
+ -- * Methods
+-- ** bufferListCopyDeep
+    BufferListCopyDeepMethodInfo            ,
+    bufferListCopyDeep                      ,
+
+
+-- ** bufferListForeach
+    BufferListForeachMethodInfo             ,
+    bufferListForeach                       ,
+
+
+-- ** bufferListGet
+    BufferListGetMethodInfo                 ,
+    bufferListGet                           ,
+
+
+-- ** bufferListInsert
+    BufferListInsertMethodInfo              ,
+    bufferListInsert                        ,
+
+
+-- ** bufferListLength
+    BufferListLengthMethodInfo              ,
+    bufferListLength                        ,
+
+
+-- ** bufferListNew
+    bufferListNew                           ,
+
+
+-- ** bufferListNewSized
+    bufferListNewSized                      ,
+
+
+-- ** bufferListRemove
+    BufferListRemoveMethodInfo              ,
+    bufferListRemove                        ,
+
+
+
+
+    ) where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+import GI.Gst.Callbacks
+
+newtype BufferList = BufferList (ForeignPtr BufferList)
+foreign import ccall "gst_buffer_list_get_type" c_gst_buffer_list_get_type :: 
+    IO GType
+
+instance BoxedObject BufferList where
+    boxedType _ = c_gst_buffer_list_get_type
+
+noBufferList :: Maybe BufferList
+noBufferList = Nothing
+
+-- method BufferList::new
+-- method type : Constructor
+-- Args : []
+-- Lengths : []
+-- returnType : TInterface "Gst" "BufferList"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_buffer_list_new" gst_buffer_list_new :: 
+    IO (Ptr BufferList)
+
+
+bufferListNew ::
+    (MonadIO m) =>
+    m BufferList                            -- result
+bufferListNew  = liftIO $ do
+    result <- gst_buffer_list_new
+    checkUnexpectedReturnNULL "gst_buffer_list_new" result
+    result' <- (wrapBoxed BufferList) result
+    return result'
+
+-- method BufferList::new_sized
+-- method type : Constructor
+-- Args : [Arg {argCName = "size", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "BufferList"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_buffer_list_new_sized" gst_buffer_list_new_sized :: 
+    Word32 ->                               -- size : TBasicType TUInt32
+    IO (Ptr BufferList)
+
+
+bufferListNewSized ::
+    (MonadIO m) =>
+    Word32                                  -- size
+    -> m BufferList                         -- result
+bufferListNewSized size = liftIO $ do
+    result <- gst_buffer_list_new_sized size
+    checkUnexpectedReturnNULL "gst_buffer_list_new_sized" result
+    result' <- (wrapBoxed BufferList) result
+    return result'
+
+-- method BufferList::copy_deep
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "BufferList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "BufferList"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_buffer_list_copy_deep" gst_buffer_list_copy_deep :: 
+    Ptr BufferList ->                       -- _obj : TInterface "Gst" "BufferList"
+    IO (Ptr BufferList)
+
+
+bufferListCopyDeep ::
+    (MonadIO m) =>
+    BufferList                              -- _obj
+    -> m BufferList                         -- result
+bufferListCopyDeep _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_buffer_list_copy_deep _obj'
+    checkUnexpectedReturnNULL "gst_buffer_list_copy_deep" result
+    result' <- (wrapBoxed BufferList) result
+    touchManagedPtr _obj
+    return result'
+
+data BufferListCopyDeepMethodInfo
+instance (signature ~ (m BufferList), MonadIO m) => MethodInfo BufferListCopyDeepMethodInfo BufferList signature where
+    overloadedMethod _ = bufferListCopyDeep
+
+-- method BufferList::foreach
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "BufferList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "func", argType = TInterface "Gst" "BufferListFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_buffer_list_foreach" gst_buffer_list_foreach :: 
+    Ptr BufferList ->                       -- _obj : TInterface "Gst" "BufferList"
+    FunPtr BufferListFuncC ->               -- func : TInterface "Gst" "BufferListFunc"
+    Ptr () ->                               -- user_data : TBasicType TVoid
+    IO CInt
+
+
+bufferListForeach ::
+    (MonadIO m) =>
+    BufferList                              -- _obj
+    -> BufferListFunc                       -- func
+    -> m Bool                               -- result
+bufferListForeach _obj func = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    func' <- mkBufferListFunc (bufferListFuncWrapper Nothing func)
+    let userData = nullPtr
+    result <- gst_buffer_list_foreach _obj' func' userData
+    let result' = (/= 0) result
+    safeFreeFunPtr $ castFunPtrToPtr func'
+    touchManagedPtr _obj
+    return result'
+
+data BufferListForeachMethodInfo
+instance (signature ~ (BufferListFunc -> m Bool), MonadIO m) => MethodInfo BufferListForeachMethodInfo BufferList signature where
+    overloadedMethod _ = bufferListForeach
+
+-- method BufferList::get
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "BufferList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "idx", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Buffer"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_buffer_list_get" gst_buffer_list_get :: 
+    Ptr BufferList ->                       -- _obj : TInterface "Gst" "BufferList"
+    Word32 ->                               -- idx : TBasicType TUInt32
+    IO (Ptr Buffer)
+
+
+bufferListGet ::
+    (MonadIO m) =>
+    BufferList                              -- _obj
+    -> Word32                               -- idx
+    -> m Buffer                             -- result
+bufferListGet _obj idx = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_buffer_list_get _obj' idx
+    checkUnexpectedReturnNULL "gst_buffer_list_get" result
+    result' <- (newBoxed Buffer) result
+    touchManagedPtr _obj
+    return result'
+
+data BufferListGetMethodInfo
+instance (signature ~ (Word32 -> m Buffer), MonadIO m) => MethodInfo BufferListGetMethodInfo BufferList signature where
+    overloadedMethod _ = bufferListGet
+
+-- method BufferList::insert
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "BufferList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "idx", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "buffer", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_buffer_list_insert" gst_buffer_list_insert :: 
+    Ptr BufferList ->                       -- _obj : TInterface "Gst" "BufferList"
+    Int32 ->                                -- idx : TBasicType TInt32
+    Ptr Buffer ->                           -- buffer : TInterface "Gst" "Buffer"
+    IO ()
+
+
+bufferListInsert ::
+    (MonadIO m) =>
+    BufferList                              -- _obj
+    -> Int32                                -- idx
+    -> Buffer                               -- buffer
+    -> m ()                                 -- result
+bufferListInsert _obj idx buffer = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    buffer' <- copyBoxed buffer
+    gst_buffer_list_insert _obj' idx buffer'
+    touchManagedPtr _obj
+    touchManagedPtr buffer
+    return ()
+
+data BufferListInsertMethodInfo
+instance (signature ~ (Int32 -> Buffer -> m ()), MonadIO m) => MethodInfo BufferListInsertMethodInfo BufferList signature where
+    overloadedMethod _ = bufferListInsert
+
+-- method BufferList::length
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "BufferList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUInt32
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_buffer_list_length" gst_buffer_list_length :: 
+    Ptr BufferList ->                       -- _obj : TInterface "Gst" "BufferList"
+    IO Word32
+
+
+bufferListLength ::
+    (MonadIO m) =>
+    BufferList                              -- _obj
+    -> m Word32                             -- result
+bufferListLength _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_buffer_list_length _obj'
+    touchManagedPtr _obj
+    return result
+
+data BufferListLengthMethodInfo
+instance (signature ~ (m Word32), MonadIO m) => MethodInfo BufferListLengthMethodInfo BufferList signature where
+    overloadedMethod _ = bufferListLength
+
+-- method BufferList::remove
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "BufferList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "idx", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "length", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_buffer_list_remove" gst_buffer_list_remove :: 
+    Ptr BufferList ->                       -- _obj : TInterface "Gst" "BufferList"
+    Word32 ->                               -- idx : TBasicType TUInt32
+    Word32 ->                               -- length : TBasicType TUInt32
+    IO ()
+
+
+bufferListRemove ::
+    (MonadIO m) =>
+    BufferList                              -- _obj
+    -> Word32                               -- idx
+    -> Word32                               -- length_
+    -> m ()                                 -- result
+bufferListRemove _obj idx length_ = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    gst_buffer_list_remove _obj' idx length_
+    touchManagedPtr _obj
+    return ()
+
+data BufferListRemoveMethodInfo
+instance (signature ~ (Word32 -> Word32 -> m ()), MonadIO m) => MethodInfo BufferListRemoveMethodInfo BufferList signature where
+    overloadedMethod _ = bufferListRemove
+
+type family ResolveBufferListMethod (t :: Symbol) (o :: *) :: * where
+    ResolveBufferListMethod "copyDeep" o = BufferListCopyDeepMethodInfo
+    ResolveBufferListMethod "foreach" o = BufferListForeachMethodInfo
+    ResolveBufferListMethod "get" o = BufferListGetMethodInfo
+    ResolveBufferListMethod "insert" o = BufferListInsertMethodInfo
+    ResolveBufferListMethod "length" o = BufferListLengthMethodInfo
+    ResolveBufferListMethod "remove" o = BufferListRemoveMethodInfo
+    ResolveBufferListMethod l o = MethodResolutionFailed l o
+
+instance (info ~ ResolveBufferListMethod t BufferList, MethodInfo info BufferList p) => IsLabelProxy t (BufferList -> p) where
+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)
+
+#if MIN_VERSION_base(4,9,0)
+instance (info ~ ResolveBufferListMethod t BufferList, MethodInfo info BufferList p) => IsLabel t (BufferList -> p) where
+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)
+#endif
+
+
diff --git a/GI/Gst/Structs/BufferList.hs-boot b/GI/Gst/Structs/BufferList.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/BufferList.hs-boot
@@ -0,0 +1,17 @@
+module GI.Gst.Structs.BufferList where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+newtype BufferList = BufferList (ForeignPtr BufferList)
+instance BoxedObject BufferList where
+data BufferListCopyDeepMethodInfo
+data BufferListForeachMethodInfo
+data BufferListGetMethodInfo
+data BufferListInsertMethodInfo
+data BufferListLengthMethodInfo
+data BufferListRemoveMethodInfo
diff --git a/GI/Gst/Structs/BufferPoolAcquireParams.hs b/GI/Gst/Structs/BufferPoolAcquireParams.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/BufferPoolAcquireParams.hs
@@ -0,0 +1,97 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+
+Parameters passed to the gst_buffer_pool_acquire_buffer() function to control the
+allocation of the buffer.
+
+The default implementation ignores the @start and @stop members but other
+implementations can use this extra information to decide what buffer to
+return.
+-}
+
+module GI.Gst.Structs.BufferPoolAcquireParams
+    ( 
+
+-- * Exported types
+    BufferPoolAcquireParams(..)             ,
+    newZeroBufferPoolAcquireParams          ,
+    noBufferPoolAcquireParams               ,
+
+
+ -- * Properties
+-- ** Flags
+    bufferPoolAcquireParamsReadFlags        ,
+
+
+-- ** Format
+    bufferPoolAcquireParamsReadFormat       ,
+
+
+-- ** Start
+    bufferPoolAcquireParamsReadStart        ,
+
+
+-- ** Stop
+    bufferPoolAcquireParamsReadStop         ,
+
+
+
+
+    ) where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+import GI.Gst.Callbacks
+
+newtype BufferPoolAcquireParams = BufferPoolAcquireParams (ForeignPtr BufferPoolAcquireParams)
+-- | Construct a `BufferPoolAcquireParams` struct initialized to zero.
+newZeroBufferPoolAcquireParams :: MonadIO m => m BufferPoolAcquireParams
+newZeroBufferPoolAcquireParams = liftIO $ callocBytes 64 >>= wrapPtr BufferPoolAcquireParams
+
+noBufferPoolAcquireParams :: Maybe BufferPoolAcquireParams
+noBufferPoolAcquireParams = Nothing
+
+bufferPoolAcquireParamsReadFormat :: BufferPoolAcquireParams -> IO Format
+bufferPoolAcquireParamsReadFormat s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 0) :: IO CUInt
+    let val' = (toEnum . fromIntegral) val
+    return val'
+
+bufferPoolAcquireParamsReadStart :: BufferPoolAcquireParams -> IO Int64
+bufferPoolAcquireParamsReadStart s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 8) :: IO Int64
+    return val
+
+bufferPoolAcquireParamsReadStop :: BufferPoolAcquireParams -> IO Int64
+bufferPoolAcquireParamsReadStop s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 16) :: IO Int64
+    return val
+
+bufferPoolAcquireParamsReadFlags :: BufferPoolAcquireParams -> IO [BufferPoolAcquireFlags]
+bufferPoolAcquireParamsReadFlags s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 24) :: IO CUInt
+    let val' = wordToGFlags val
+    return val'
+
+type family ResolveBufferPoolAcquireParamsMethod (t :: Symbol) (o :: *) :: * where
+    ResolveBufferPoolAcquireParamsMethod l o = MethodResolutionFailed l o
+
+instance (info ~ ResolveBufferPoolAcquireParamsMethod t BufferPoolAcquireParams, MethodInfo info BufferPoolAcquireParams p) => IsLabelProxy t (BufferPoolAcquireParams -> p) where
+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)
+
+#if MIN_VERSION_base(4,9,0)
+instance (info ~ ResolveBufferPoolAcquireParamsMethod t BufferPoolAcquireParams, MethodInfo info BufferPoolAcquireParams p) => IsLabel t (BufferPoolAcquireParams -> p) where
+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)
+#endif
+
+
diff --git a/GI/Gst/Structs/BufferPoolAcquireParams.hs-boot b/GI/Gst/Structs/BufferPoolAcquireParams.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/BufferPoolAcquireParams.hs-boot
@@ -0,0 +1,10 @@
+module GI.Gst.Structs.BufferPoolAcquireParams where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+newtype BufferPoolAcquireParams = BufferPoolAcquireParams (ForeignPtr BufferPoolAcquireParams)
diff --git a/GI/Gst/Structs/Caps.hs b/GI/Gst/Structs/Caps.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/Caps.hs
@@ -0,0 +1,1587 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+
+Caps (capabilities) are lightweight refcounted objects describing media types.
+They are composed of an array of #GstStructure.
+
+Caps are exposed on #GstPadTemplate to describe all possible types a
+given pad can handle. They are also stored in the #GstRegistry along with
+a description of the #GstElement.
+
+Caps are exposed on the element pads using the gst_pad_query_caps() pad
+function. This function describes the possible types that the pad can
+handle or produce at runtime.
+
+A #GstCaps can be constructed with the following code fragment:
+|[
+  GstCaps *caps = gst_caps_new_simple ("video/x-raw",
+     "format", G_TYPE_STRING, "I420",
+     "framerate", GST_TYPE_FRACTION, 25, 1,
+     "pixel-aspect-ratio", GST_TYPE_FRACTION, 1, 1,
+     "width", G_TYPE_INT, 320,
+     "height", G_TYPE_INT, 240,
+     NULL);
+]|
+
+A #GstCaps is fixed when it has no properties with ranges or lists. Use
+gst_caps_is_fixed() to test for fixed caps. Fixed caps can be used in a
+caps event to notify downstream elements of the current media type.
+
+Various methods exist to work with the media types such as subtracting
+or intersecting.
+
+Be aware that the current #GstCaps / #GstStructure serialization into string
+has limited support for nested #GstCaps / #GstStructure fields. It can only
+support one level of nesting. Using more levels will lead to unexpected
+behavior when using serialization features, such as gst_caps_to_string() or
+gst_value_serialize() and their counterparts.
+-}
+
+module GI.Gst.Structs.Caps
+    ( 
+
+-- * Exported types
+    Caps(..)                                ,
+    newZeroCaps                             ,
+    noCaps                                  ,
+
+
+ -- * Methods
+-- ** capsAppend
+    CapsAppendMethodInfo                    ,
+    capsAppend                              ,
+
+
+-- ** capsAppendStructure
+    CapsAppendStructureMethodInfo           ,
+    capsAppendStructure                     ,
+
+
+-- ** capsAppendStructureFull
+    CapsAppendStructureFullMethodInfo       ,
+    capsAppendStructureFull                 ,
+
+
+-- ** capsCanIntersect
+    CapsCanIntersectMethodInfo              ,
+    capsCanIntersect                        ,
+
+
+-- ** capsCopyNth
+    CapsCopyNthMethodInfo                   ,
+    capsCopyNth                             ,
+
+
+-- ** capsFilterAndMapInPlace
+    CapsFilterAndMapInPlaceMethodInfo       ,
+    capsFilterAndMapInPlace                 ,
+
+
+-- ** capsFixate
+    CapsFixateMethodInfo                    ,
+    capsFixate                              ,
+
+
+-- ** capsForeach
+    CapsForeachMethodInfo                   ,
+    capsForeach                             ,
+
+
+-- ** capsFromString
+    capsFromString                          ,
+
+
+-- ** capsGetFeatures
+    CapsGetFeaturesMethodInfo               ,
+    capsGetFeatures                         ,
+
+
+-- ** capsGetSize
+    CapsGetSizeMethodInfo                   ,
+    capsGetSize                             ,
+
+
+-- ** capsGetStructure
+    CapsGetStructureMethodInfo              ,
+    capsGetStructure                        ,
+
+
+-- ** capsIntersect
+    CapsIntersectMethodInfo                 ,
+    capsIntersect                           ,
+
+
+-- ** capsIntersectFull
+    CapsIntersectFullMethodInfo             ,
+    capsIntersectFull                       ,
+
+
+-- ** capsIsAlwaysCompatible
+    CapsIsAlwaysCompatibleMethodInfo        ,
+    capsIsAlwaysCompatible                  ,
+
+
+-- ** capsIsAny
+    CapsIsAnyMethodInfo                     ,
+    capsIsAny                               ,
+
+
+-- ** capsIsEmpty
+    CapsIsEmptyMethodInfo                   ,
+    capsIsEmpty                             ,
+
+
+-- ** capsIsEqual
+    CapsIsEqualMethodInfo                   ,
+    capsIsEqual                             ,
+
+
+-- ** capsIsEqualFixed
+    CapsIsEqualFixedMethodInfo              ,
+    capsIsEqualFixed                        ,
+
+
+-- ** capsIsFixed
+    CapsIsFixedMethodInfo                   ,
+    capsIsFixed                             ,
+
+
+-- ** capsIsStrictlyEqual
+    CapsIsStrictlyEqualMethodInfo           ,
+    capsIsStrictlyEqual                     ,
+
+
+-- ** capsIsSubset
+    CapsIsSubsetMethodInfo                  ,
+    capsIsSubset                            ,
+
+
+-- ** capsIsSubsetStructure
+    CapsIsSubsetStructureMethodInfo         ,
+    capsIsSubsetStructure                   ,
+
+
+-- ** capsIsSubsetStructureFull
+    CapsIsSubsetStructureFullMethodInfo     ,
+    capsIsSubsetStructureFull               ,
+
+
+-- ** capsMapInPlace
+    CapsMapInPlaceMethodInfo                ,
+    capsMapInPlace                          ,
+
+
+-- ** capsMerge
+    CapsMergeMethodInfo                     ,
+    capsMerge                               ,
+
+
+-- ** capsMergeStructure
+    CapsMergeStructureMethodInfo            ,
+    capsMergeStructure                      ,
+
+
+-- ** capsMergeStructureFull
+    CapsMergeStructureFullMethodInfo        ,
+    capsMergeStructureFull                  ,
+
+
+-- ** capsNewAny
+    capsNewAny                              ,
+
+
+-- ** capsNewEmpty
+    capsNewEmpty                            ,
+
+
+-- ** capsNewEmptySimple
+    capsNewEmptySimple                      ,
+
+
+-- ** capsNormalize
+    CapsNormalizeMethodInfo                 ,
+    capsNormalize                           ,
+
+
+-- ** capsRemoveStructure
+    CapsRemoveStructureMethodInfo           ,
+    capsRemoveStructure                     ,
+
+
+-- ** capsSetFeatures
+    CapsSetFeaturesMethodInfo               ,
+    capsSetFeatures                         ,
+
+
+-- ** capsSetValue
+    CapsSetValueMethodInfo                  ,
+    capsSetValue                            ,
+
+
+-- ** capsSimplify
+    CapsSimplifyMethodInfo                  ,
+    capsSimplify                            ,
+
+
+-- ** capsStealStructure
+    CapsStealStructureMethodInfo            ,
+    capsStealStructure                      ,
+
+
+-- ** capsSubtract
+    CapsSubtractMethodInfo                  ,
+    capsSubtract                            ,
+
+
+-- ** capsToString
+    CapsToStringMethodInfo                  ,
+    capsToString                            ,
+
+
+-- ** capsTruncate
+    CapsTruncateMethodInfo                  ,
+    capsTruncate                            ,
+
+
+
+
+ -- * Properties
+-- ** MiniObject
+    capsReadMiniObject                      ,
+
+
+
+
+    ) where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+import GI.Gst.Callbacks
+
+newtype Caps = Caps (ForeignPtr Caps)
+foreign import ccall "gst_caps_get_type" c_gst_caps_get_type :: 
+    IO GType
+
+instance BoxedObject Caps where
+    boxedType _ = c_gst_caps_get_type
+
+-- | Construct a `Caps` struct initialized to zero.
+newZeroCaps :: MonadIO m => m Caps
+newZeroCaps = liftIO $ callocBoxedBytes 64 >>= wrapBoxed Caps
+
+noCaps :: Maybe Caps
+noCaps = Nothing
+
+capsReadMiniObject :: Caps -> IO MiniObject
+capsReadMiniObject s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 0) :: IO (Ptr MiniObject)
+    val' <- (newPtr 64 MiniObject) val
+    return val'
+
+-- method Caps::new_any
+-- method type : Constructor
+-- Args : []
+-- Lengths : []
+-- returnType : TInterface "Gst" "Caps"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_caps_new_any" gst_caps_new_any :: 
+    IO (Ptr Caps)
+
+
+capsNewAny ::
+    (MonadIO m) =>
+    m Caps                                  -- result
+capsNewAny  = liftIO $ do
+    result <- gst_caps_new_any
+    checkUnexpectedReturnNULL "gst_caps_new_any" result
+    result' <- (wrapBoxed Caps) result
+    return result'
+
+-- method Caps::new_empty
+-- method type : Constructor
+-- Args : []
+-- Lengths : []
+-- returnType : TInterface "Gst" "Caps"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_caps_new_empty" gst_caps_new_empty :: 
+    IO (Ptr Caps)
+
+
+capsNewEmpty ::
+    (MonadIO m) =>
+    m Caps                                  -- result
+capsNewEmpty  = liftIO $ do
+    result <- gst_caps_new_empty
+    checkUnexpectedReturnNULL "gst_caps_new_empty" result
+    result' <- (wrapBoxed Caps) result
+    return result'
+
+-- method Caps::new_empty_simple
+-- method type : Constructor
+-- Args : [Arg {argCName = "media_type", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Caps"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_caps_new_empty_simple" gst_caps_new_empty_simple :: 
+    CString ->                              -- media_type : TBasicType TUTF8
+    IO (Ptr Caps)
+
+
+capsNewEmptySimple ::
+    (MonadIO m) =>
+    T.Text                                  -- mediaType
+    -> m Caps                               -- result
+capsNewEmptySimple mediaType = liftIO $ do
+    mediaType' <- textToCString mediaType
+    result <- gst_caps_new_empty_simple mediaType'
+    checkUnexpectedReturnNULL "gst_caps_new_empty_simple" result
+    result' <- (wrapBoxed Caps) result
+    freeMem mediaType'
+    return result'
+
+-- method Caps::append
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps2", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_caps_append" gst_caps_append :: 
+    Ptr Caps ->                             -- _obj : TInterface "Gst" "Caps"
+    Ptr Caps ->                             -- caps2 : TInterface "Gst" "Caps"
+    IO ()
+
+
+capsAppend ::
+    (MonadIO m) =>
+    Caps                                    -- _obj
+    -> Caps                                 -- caps2
+    -> m ()                                 -- result
+capsAppend _obj caps2 = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    caps2' <- copyBoxed caps2
+    gst_caps_append _obj' caps2'
+    touchManagedPtr _obj
+    touchManagedPtr caps2
+    return ()
+
+data CapsAppendMethodInfo
+instance (signature ~ (Caps -> m ()), MonadIO m) => MethodInfo CapsAppendMethodInfo Caps signature where
+    overloadedMethod _ = capsAppend
+
+-- method Caps::append_structure
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "structure", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_caps_append_structure" gst_caps_append_structure :: 
+    Ptr Caps ->                             -- _obj : TInterface "Gst" "Caps"
+    Ptr Structure ->                        -- structure : TInterface "Gst" "Structure"
+    IO ()
+
+
+capsAppendStructure ::
+    (MonadIO m) =>
+    Caps                                    -- _obj
+    -> Structure                            -- structure
+    -> m ()                                 -- result
+capsAppendStructure _obj structure = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    structure' <- copyBoxed structure
+    gst_caps_append_structure _obj' structure'
+    touchManagedPtr _obj
+    touchManagedPtr structure
+    return ()
+
+data CapsAppendStructureMethodInfo
+instance (signature ~ (Structure -> m ()), MonadIO m) => MethodInfo CapsAppendStructureMethodInfo Caps signature where
+    overloadedMethod _ = capsAppendStructure
+
+-- method Caps::append_structure_full
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "structure", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "features", argType = TInterface "Gst" "CapsFeatures", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_caps_append_structure_full" gst_caps_append_structure_full :: 
+    Ptr Caps ->                             -- _obj : TInterface "Gst" "Caps"
+    Ptr Structure ->                        -- structure : TInterface "Gst" "Structure"
+    Ptr CapsFeatures ->                     -- features : TInterface "Gst" "CapsFeatures"
+    IO ()
+
+
+capsAppendStructureFull ::
+    (MonadIO m) =>
+    Caps                                    -- _obj
+    -> Structure                            -- structure
+    -> Maybe (CapsFeatures)                 -- features
+    -> m ()                                 -- result
+capsAppendStructureFull _obj structure features = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    structure' <- copyBoxed structure
+    maybeFeatures <- case features of
+        Nothing -> return nullPtr
+        Just jFeatures -> do
+            jFeatures' <- copyBoxed jFeatures
+            return jFeatures'
+    gst_caps_append_structure_full _obj' structure' maybeFeatures
+    touchManagedPtr _obj
+    touchManagedPtr structure
+    whenJust features touchManagedPtr
+    return ()
+
+data CapsAppendStructureFullMethodInfo
+instance (signature ~ (Structure -> Maybe (CapsFeatures) -> m ()), MonadIO m) => MethodInfo CapsAppendStructureFullMethodInfo Caps signature where
+    overloadedMethod _ = capsAppendStructureFull
+
+-- method Caps::can_intersect
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps2", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_caps_can_intersect" gst_caps_can_intersect :: 
+    Ptr Caps ->                             -- _obj : TInterface "Gst" "Caps"
+    Ptr Caps ->                             -- caps2 : TInterface "Gst" "Caps"
+    IO CInt
+
+
+capsCanIntersect ::
+    (MonadIO m) =>
+    Caps                                    -- _obj
+    -> Caps                                 -- caps2
+    -> m Bool                               -- result
+capsCanIntersect _obj caps2 = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let caps2' = unsafeManagedPtrGetPtr caps2
+    result <- gst_caps_can_intersect _obj' caps2'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    touchManagedPtr caps2
+    return result'
+
+data CapsCanIntersectMethodInfo
+instance (signature ~ (Caps -> m Bool), MonadIO m) => MethodInfo CapsCanIntersectMethodInfo Caps signature where
+    overloadedMethod _ = capsCanIntersect
+
+-- method Caps::copy_nth
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "nth", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Caps"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_caps_copy_nth" gst_caps_copy_nth :: 
+    Ptr Caps ->                             -- _obj : TInterface "Gst" "Caps"
+    Word32 ->                               -- nth : TBasicType TUInt32
+    IO (Ptr Caps)
+
+
+capsCopyNth ::
+    (MonadIO m) =>
+    Caps                                    -- _obj
+    -> Word32                               -- nth
+    -> m Caps                               -- result
+capsCopyNth _obj nth = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_caps_copy_nth _obj' nth
+    checkUnexpectedReturnNULL "gst_caps_copy_nth" result
+    result' <- (wrapBoxed Caps) result
+    touchManagedPtr _obj
+    return result'
+
+data CapsCopyNthMethodInfo
+instance (signature ~ (Word32 -> m Caps), MonadIO m) => MethodInfo CapsCopyNthMethodInfo Caps signature where
+    overloadedMethod _ = capsCopyNth
+
+-- method Caps::filter_and_map_in_place
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "func", argType = TInterface "Gst" "CapsFilterMapFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_caps_filter_and_map_in_place" gst_caps_filter_and_map_in_place :: 
+    Ptr Caps ->                             -- _obj : TInterface "Gst" "Caps"
+    FunPtr CapsFilterMapFuncC ->            -- func : TInterface "Gst" "CapsFilterMapFunc"
+    Ptr () ->                               -- user_data : TBasicType TVoid
+    IO ()
+
+
+capsFilterAndMapInPlace ::
+    (MonadIO m) =>
+    Caps                                    -- _obj
+    -> CapsFilterMapFunc                    -- func
+    -> m ()                                 -- result
+capsFilterAndMapInPlace _obj func = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    func' <- mkCapsFilterMapFunc (capsFilterMapFuncWrapper Nothing func)
+    let userData = nullPtr
+    gst_caps_filter_and_map_in_place _obj' func' userData
+    safeFreeFunPtr $ castFunPtrToPtr func'
+    touchManagedPtr _obj
+    return ()
+
+data CapsFilterAndMapInPlaceMethodInfo
+instance (signature ~ (CapsFilterMapFunc -> m ()), MonadIO m) => MethodInfo CapsFilterAndMapInPlaceMethodInfo Caps signature where
+    overloadedMethod _ = capsFilterAndMapInPlace
+
+-- method Caps::fixate
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Caps"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_caps_fixate" gst_caps_fixate :: 
+    Ptr Caps ->                             -- _obj : TInterface "Gst" "Caps"
+    IO (Ptr Caps)
+
+
+capsFixate ::
+    (MonadIO m) =>
+    Caps                                    -- _obj
+    -> m Caps                               -- result
+capsFixate _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_caps_fixate _obj'
+    checkUnexpectedReturnNULL "gst_caps_fixate" result
+    result' <- (wrapBoxed Caps) result
+    touchManagedPtr _obj
+    return result'
+
+data CapsFixateMethodInfo
+instance (signature ~ (m Caps), MonadIO m) => MethodInfo CapsFixateMethodInfo Caps signature where
+    overloadedMethod _ = capsFixate
+
+-- method Caps::foreach
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "func", argType = TInterface "Gst" "CapsForeachFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_caps_foreach" gst_caps_foreach :: 
+    Ptr Caps ->                             -- _obj : TInterface "Gst" "Caps"
+    FunPtr CapsForeachFuncC ->              -- func : TInterface "Gst" "CapsForeachFunc"
+    Ptr () ->                               -- user_data : TBasicType TVoid
+    IO CInt
+
+
+capsForeach ::
+    (MonadIO m) =>
+    Caps                                    -- _obj
+    -> CapsForeachFunc                      -- func
+    -> m Bool                               -- result
+capsForeach _obj func = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    func' <- mkCapsForeachFunc (capsForeachFuncWrapper Nothing func)
+    let userData = nullPtr
+    result <- gst_caps_foreach _obj' func' userData
+    let result' = (/= 0) result
+    safeFreeFunPtr $ castFunPtrToPtr func'
+    touchManagedPtr _obj
+    return result'
+
+data CapsForeachMethodInfo
+instance (signature ~ (CapsForeachFunc -> m Bool), MonadIO m) => MethodInfo CapsForeachMethodInfo Caps signature where
+    overloadedMethod _ = capsForeach
+
+-- method Caps::get_features
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "CapsFeatures"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_caps_get_features" gst_caps_get_features :: 
+    Ptr Caps ->                             -- _obj : TInterface "Gst" "Caps"
+    Word32 ->                               -- index : TBasicType TUInt32
+    IO (Ptr CapsFeatures)
+
+
+capsGetFeatures ::
+    (MonadIO m) =>
+    Caps                                    -- _obj
+    -> Word32                               -- index
+    -> m CapsFeatures                       -- result
+capsGetFeatures _obj index = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_caps_get_features _obj' index
+    checkUnexpectedReturnNULL "gst_caps_get_features" result
+    result' <- (newBoxed CapsFeatures) result
+    touchManagedPtr _obj
+    return result'
+
+data CapsGetFeaturesMethodInfo
+instance (signature ~ (Word32 -> m CapsFeatures), MonadIO m) => MethodInfo CapsGetFeaturesMethodInfo Caps signature where
+    overloadedMethod _ = capsGetFeatures
+
+-- method Caps::get_size
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUInt32
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_caps_get_size" gst_caps_get_size :: 
+    Ptr Caps ->                             -- _obj : TInterface "Gst" "Caps"
+    IO Word32
+
+
+capsGetSize ::
+    (MonadIO m) =>
+    Caps                                    -- _obj
+    -> m Word32                             -- result
+capsGetSize _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_caps_get_size _obj'
+    touchManagedPtr _obj
+    return result
+
+data CapsGetSizeMethodInfo
+instance (signature ~ (m Word32), MonadIO m) => MethodInfo CapsGetSizeMethodInfo Caps signature where
+    overloadedMethod _ = capsGetSize
+
+-- method Caps::get_structure
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Structure"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_caps_get_structure" gst_caps_get_structure :: 
+    Ptr Caps ->                             -- _obj : TInterface "Gst" "Caps"
+    Word32 ->                               -- index : TBasicType TUInt32
+    IO (Ptr Structure)
+
+
+capsGetStructure ::
+    (MonadIO m) =>
+    Caps                                    -- _obj
+    -> Word32                               -- index
+    -> m Structure                          -- result
+capsGetStructure _obj index = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_caps_get_structure _obj' index
+    checkUnexpectedReturnNULL "gst_caps_get_structure" result
+    result' <- (newBoxed Structure) result
+    touchManagedPtr _obj
+    return result'
+
+data CapsGetStructureMethodInfo
+instance (signature ~ (Word32 -> m Structure), MonadIO m) => MethodInfo CapsGetStructureMethodInfo Caps signature where
+    overloadedMethod _ = capsGetStructure
+
+-- method Caps::intersect
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps2", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Caps"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_caps_intersect" gst_caps_intersect :: 
+    Ptr Caps ->                             -- _obj : TInterface "Gst" "Caps"
+    Ptr Caps ->                             -- caps2 : TInterface "Gst" "Caps"
+    IO (Ptr Caps)
+
+
+capsIntersect ::
+    (MonadIO m) =>
+    Caps                                    -- _obj
+    -> Caps                                 -- caps2
+    -> m Caps                               -- result
+capsIntersect _obj caps2 = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let caps2' = unsafeManagedPtrGetPtr caps2
+    result <- gst_caps_intersect _obj' caps2'
+    checkUnexpectedReturnNULL "gst_caps_intersect" result
+    result' <- (wrapBoxed Caps) result
+    touchManagedPtr _obj
+    touchManagedPtr caps2
+    return result'
+
+data CapsIntersectMethodInfo
+instance (signature ~ (Caps -> m Caps), MonadIO m) => MethodInfo CapsIntersectMethodInfo Caps signature where
+    overloadedMethod _ = capsIntersect
+
+-- method Caps::intersect_full
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps2", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mode", argType = TInterface "Gst" "CapsIntersectMode", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Caps"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_caps_intersect_full" gst_caps_intersect_full :: 
+    Ptr Caps ->                             -- _obj : TInterface "Gst" "Caps"
+    Ptr Caps ->                             -- caps2 : TInterface "Gst" "Caps"
+    CUInt ->                                -- mode : TInterface "Gst" "CapsIntersectMode"
+    IO (Ptr Caps)
+
+
+capsIntersectFull ::
+    (MonadIO m) =>
+    Caps                                    -- _obj
+    -> Caps                                 -- caps2
+    -> CapsIntersectMode                    -- mode
+    -> m Caps                               -- result
+capsIntersectFull _obj caps2 mode = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let caps2' = unsafeManagedPtrGetPtr caps2
+    let mode' = (fromIntegral . fromEnum) mode
+    result <- gst_caps_intersect_full _obj' caps2' mode'
+    checkUnexpectedReturnNULL "gst_caps_intersect_full" result
+    result' <- (wrapBoxed Caps) result
+    touchManagedPtr _obj
+    touchManagedPtr caps2
+    return result'
+
+data CapsIntersectFullMethodInfo
+instance (signature ~ (Caps -> CapsIntersectMode -> m Caps), MonadIO m) => MethodInfo CapsIntersectFullMethodInfo Caps signature where
+    overloadedMethod _ = capsIntersectFull
+
+-- method Caps::is_always_compatible
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps2", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_caps_is_always_compatible" gst_caps_is_always_compatible :: 
+    Ptr Caps ->                             -- _obj : TInterface "Gst" "Caps"
+    Ptr Caps ->                             -- caps2 : TInterface "Gst" "Caps"
+    IO CInt
+
+
+capsIsAlwaysCompatible ::
+    (MonadIO m) =>
+    Caps                                    -- _obj
+    -> Caps                                 -- caps2
+    -> m Bool                               -- result
+capsIsAlwaysCompatible _obj caps2 = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let caps2' = unsafeManagedPtrGetPtr caps2
+    result <- gst_caps_is_always_compatible _obj' caps2'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    touchManagedPtr caps2
+    return result'
+
+data CapsIsAlwaysCompatibleMethodInfo
+instance (signature ~ (Caps -> m Bool), MonadIO m) => MethodInfo CapsIsAlwaysCompatibleMethodInfo Caps signature where
+    overloadedMethod _ = capsIsAlwaysCompatible
+
+-- method Caps::is_any
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_caps_is_any" gst_caps_is_any :: 
+    Ptr Caps ->                             -- _obj : TInterface "Gst" "Caps"
+    IO CInt
+
+
+capsIsAny ::
+    (MonadIO m) =>
+    Caps                                    -- _obj
+    -> m Bool                               -- result
+capsIsAny _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_caps_is_any _obj'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data CapsIsAnyMethodInfo
+instance (signature ~ (m Bool), MonadIO m) => MethodInfo CapsIsAnyMethodInfo Caps signature where
+    overloadedMethod _ = capsIsAny
+
+-- method Caps::is_empty
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_caps_is_empty" gst_caps_is_empty :: 
+    Ptr Caps ->                             -- _obj : TInterface "Gst" "Caps"
+    IO CInt
+
+
+capsIsEmpty ::
+    (MonadIO m) =>
+    Caps                                    -- _obj
+    -> m Bool                               -- result
+capsIsEmpty _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_caps_is_empty _obj'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data CapsIsEmptyMethodInfo
+instance (signature ~ (m Bool), MonadIO m) => MethodInfo CapsIsEmptyMethodInfo Caps signature where
+    overloadedMethod _ = capsIsEmpty
+
+-- method Caps::is_equal
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps2", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_caps_is_equal" gst_caps_is_equal :: 
+    Ptr Caps ->                             -- _obj : TInterface "Gst" "Caps"
+    Ptr Caps ->                             -- caps2 : TInterface "Gst" "Caps"
+    IO CInt
+
+
+capsIsEqual ::
+    (MonadIO m) =>
+    Caps                                    -- _obj
+    -> Caps                                 -- caps2
+    -> m Bool                               -- result
+capsIsEqual _obj caps2 = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let caps2' = unsafeManagedPtrGetPtr caps2
+    result <- gst_caps_is_equal _obj' caps2'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    touchManagedPtr caps2
+    return result'
+
+data CapsIsEqualMethodInfo
+instance (signature ~ (Caps -> m Bool), MonadIO m) => MethodInfo CapsIsEqualMethodInfo Caps signature where
+    overloadedMethod _ = capsIsEqual
+
+-- method Caps::is_equal_fixed
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps2", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_caps_is_equal_fixed" gst_caps_is_equal_fixed :: 
+    Ptr Caps ->                             -- _obj : TInterface "Gst" "Caps"
+    Ptr Caps ->                             -- caps2 : TInterface "Gst" "Caps"
+    IO CInt
+
+
+capsIsEqualFixed ::
+    (MonadIO m) =>
+    Caps                                    -- _obj
+    -> Caps                                 -- caps2
+    -> m Bool                               -- result
+capsIsEqualFixed _obj caps2 = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let caps2' = unsafeManagedPtrGetPtr caps2
+    result <- gst_caps_is_equal_fixed _obj' caps2'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    touchManagedPtr caps2
+    return result'
+
+data CapsIsEqualFixedMethodInfo
+instance (signature ~ (Caps -> m Bool), MonadIO m) => MethodInfo CapsIsEqualFixedMethodInfo Caps signature where
+    overloadedMethod _ = capsIsEqualFixed
+
+-- method Caps::is_fixed
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_caps_is_fixed" gst_caps_is_fixed :: 
+    Ptr Caps ->                             -- _obj : TInterface "Gst" "Caps"
+    IO CInt
+
+
+capsIsFixed ::
+    (MonadIO m) =>
+    Caps                                    -- _obj
+    -> m Bool                               -- result
+capsIsFixed _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_caps_is_fixed _obj'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data CapsIsFixedMethodInfo
+instance (signature ~ (m Bool), MonadIO m) => MethodInfo CapsIsFixedMethodInfo Caps signature where
+    overloadedMethod _ = capsIsFixed
+
+-- method Caps::is_strictly_equal
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps2", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_caps_is_strictly_equal" gst_caps_is_strictly_equal :: 
+    Ptr Caps ->                             -- _obj : TInterface "Gst" "Caps"
+    Ptr Caps ->                             -- caps2 : TInterface "Gst" "Caps"
+    IO CInt
+
+
+capsIsStrictlyEqual ::
+    (MonadIO m) =>
+    Caps                                    -- _obj
+    -> Caps                                 -- caps2
+    -> m Bool                               -- result
+capsIsStrictlyEqual _obj caps2 = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let caps2' = unsafeManagedPtrGetPtr caps2
+    result <- gst_caps_is_strictly_equal _obj' caps2'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    touchManagedPtr caps2
+    return result'
+
+data CapsIsStrictlyEqualMethodInfo
+instance (signature ~ (Caps -> m Bool), MonadIO m) => MethodInfo CapsIsStrictlyEqualMethodInfo Caps signature where
+    overloadedMethod _ = capsIsStrictlyEqual
+
+-- method Caps::is_subset
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "superset", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_caps_is_subset" gst_caps_is_subset :: 
+    Ptr Caps ->                             -- _obj : TInterface "Gst" "Caps"
+    Ptr Caps ->                             -- superset : TInterface "Gst" "Caps"
+    IO CInt
+
+
+capsIsSubset ::
+    (MonadIO m) =>
+    Caps                                    -- _obj
+    -> Caps                                 -- superset
+    -> m Bool                               -- result
+capsIsSubset _obj superset = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let superset' = unsafeManagedPtrGetPtr superset
+    result <- gst_caps_is_subset _obj' superset'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    touchManagedPtr superset
+    return result'
+
+data CapsIsSubsetMethodInfo
+instance (signature ~ (Caps -> m Bool), MonadIO m) => MethodInfo CapsIsSubsetMethodInfo Caps signature where
+    overloadedMethod _ = capsIsSubset
+
+-- method Caps::is_subset_structure
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "structure", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_caps_is_subset_structure" gst_caps_is_subset_structure :: 
+    Ptr Caps ->                             -- _obj : TInterface "Gst" "Caps"
+    Ptr Structure ->                        -- structure : TInterface "Gst" "Structure"
+    IO CInt
+
+
+capsIsSubsetStructure ::
+    (MonadIO m) =>
+    Caps                                    -- _obj
+    -> Structure                            -- structure
+    -> m Bool                               -- result
+capsIsSubsetStructure _obj structure = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let structure' = unsafeManagedPtrGetPtr structure
+    result <- gst_caps_is_subset_structure _obj' structure'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    touchManagedPtr structure
+    return result'
+
+data CapsIsSubsetStructureMethodInfo
+instance (signature ~ (Structure -> m Bool), MonadIO m) => MethodInfo CapsIsSubsetStructureMethodInfo Caps signature where
+    overloadedMethod _ = capsIsSubsetStructure
+
+-- method Caps::is_subset_structure_full
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "structure", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "features", argType = TInterface "Gst" "CapsFeatures", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_caps_is_subset_structure_full" gst_caps_is_subset_structure_full :: 
+    Ptr Caps ->                             -- _obj : TInterface "Gst" "Caps"
+    Ptr Structure ->                        -- structure : TInterface "Gst" "Structure"
+    Ptr CapsFeatures ->                     -- features : TInterface "Gst" "CapsFeatures"
+    IO CInt
+
+
+capsIsSubsetStructureFull ::
+    (MonadIO m) =>
+    Caps                                    -- _obj
+    -> Structure                            -- structure
+    -> Maybe (CapsFeatures)                 -- features
+    -> m Bool                               -- result
+capsIsSubsetStructureFull _obj structure features = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let structure' = unsafeManagedPtrGetPtr structure
+    maybeFeatures <- case features of
+        Nothing -> return nullPtr
+        Just jFeatures -> do
+            let jFeatures' = unsafeManagedPtrGetPtr jFeatures
+            return jFeatures'
+    result <- gst_caps_is_subset_structure_full _obj' structure' maybeFeatures
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    touchManagedPtr structure
+    whenJust features touchManagedPtr
+    return result'
+
+data CapsIsSubsetStructureFullMethodInfo
+instance (signature ~ (Structure -> Maybe (CapsFeatures) -> m Bool), MonadIO m) => MethodInfo CapsIsSubsetStructureFullMethodInfo Caps signature where
+    overloadedMethod _ = capsIsSubsetStructureFull
+
+-- method Caps::map_in_place
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "func", argType = TInterface "Gst" "CapsMapFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_caps_map_in_place" gst_caps_map_in_place :: 
+    Ptr Caps ->                             -- _obj : TInterface "Gst" "Caps"
+    FunPtr CapsMapFuncC ->                  -- func : TInterface "Gst" "CapsMapFunc"
+    Ptr () ->                               -- user_data : TBasicType TVoid
+    IO CInt
+
+
+capsMapInPlace ::
+    (MonadIO m) =>
+    Caps                                    -- _obj
+    -> CapsMapFunc                          -- func
+    -> m Bool                               -- result
+capsMapInPlace _obj func = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    func' <- mkCapsMapFunc (capsMapFuncWrapper Nothing func)
+    let userData = nullPtr
+    result <- gst_caps_map_in_place _obj' func' userData
+    let result' = (/= 0) result
+    safeFreeFunPtr $ castFunPtrToPtr func'
+    touchManagedPtr _obj
+    return result'
+
+data CapsMapInPlaceMethodInfo
+instance (signature ~ (CapsMapFunc -> m Bool), MonadIO m) => MethodInfo CapsMapInPlaceMethodInfo Caps signature where
+    overloadedMethod _ = capsMapInPlace
+
+-- method Caps::merge
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps2", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Caps"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_caps_merge" gst_caps_merge :: 
+    Ptr Caps ->                             -- _obj : TInterface "Gst" "Caps"
+    Ptr Caps ->                             -- caps2 : TInterface "Gst" "Caps"
+    IO (Ptr Caps)
+
+
+capsMerge ::
+    (MonadIO m) =>
+    Caps                                    -- _obj
+    -> Caps                                 -- caps2
+    -> m Caps                               -- result
+capsMerge _obj caps2 = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    caps2' <- copyBoxed caps2
+    result <- gst_caps_merge _obj' caps2'
+    checkUnexpectedReturnNULL "gst_caps_merge" result
+    result' <- (wrapBoxed Caps) result
+    touchManagedPtr _obj
+    touchManagedPtr caps2
+    return result'
+
+data CapsMergeMethodInfo
+instance (signature ~ (Caps -> m Caps), MonadIO m) => MethodInfo CapsMergeMethodInfo Caps signature where
+    overloadedMethod _ = capsMerge
+
+-- method Caps::merge_structure
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "structure", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Caps"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_caps_merge_structure" gst_caps_merge_structure :: 
+    Ptr Caps ->                             -- _obj : TInterface "Gst" "Caps"
+    Ptr Structure ->                        -- structure : TInterface "Gst" "Structure"
+    IO (Ptr Caps)
+
+
+capsMergeStructure ::
+    (MonadIO m) =>
+    Caps                                    -- _obj
+    -> Structure                            -- structure
+    -> m Caps                               -- result
+capsMergeStructure _obj structure = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    structure' <- copyBoxed structure
+    result <- gst_caps_merge_structure _obj' structure'
+    checkUnexpectedReturnNULL "gst_caps_merge_structure" result
+    result' <- (wrapBoxed Caps) result
+    touchManagedPtr _obj
+    touchManagedPtr structure
+    return result'
+
+data CapsMergeStructureMethodInfo
+instance (signature ~ (Structure -> m Caps), MonadIO m) => MethodInfo CapsMergeStructureMethodInfo Caps signature where
+    overloadedMethod _ = capsMergeStructure
+
+-- method Caps::merge_structure_full
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "structure", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "features", argType = TInterface "Gst" "CapsFeatures", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Caps"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_caps_merge_structure_full" gst_caps_merge_structure_full :: 
+    Ptr Caps ->                             -- _obj : TInterface "Gst" "Caps"
+    Ptr Structure ->                        -- structure : TInterface "Gst" "Structure"
+    Ptr CapsFeatures ->                     -- features : TInterface "Gst" "CapsFeatures"
+    IO (Ptr Caps)
+
+
+capsMergeStructureFull ::
+    (MonadIO m) =>
+    Caps                                    -- _obj
+    -> Structure                            -- structure
+    -> Maybe (CapsFeatures)                 -- features
+    -> m Caps                               -- result
+capsMergeStructureFull _obj structure features = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    structure' <- copyBoxed structure
+    maybeFeatures <- case features of
+        Nothing -> return nullPtr
+        Just jFeatures -> do
+            jFeatures' <- copyBoxed jFeatures
+            return jFeatures'
+    result <- gst_caps_merge_structure_full _obj' structure' maybeFeatures
+    checkUnexpectedReturnNULL "gst_caps_merge_structure_full" result
+    result' <- (wrapBoxed Caps) result
+    touchManagedPtr _obj
+    touchManagedPtr structure
+    whenJust features touchManagedPtr
+    return result'
+
+data CapsMergeStructureFullMethodInfo
+instance (signature ~ (Structure -> Maybe (CapsFeatures) -> m Caps), MonadIO m) => MethodInfo CapsMergeStructureFullMethodInfo Caps signature where
+    overloadedMethod _ = capsMergeStructureFull
+
+-- method Caps::normalize
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Caps"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_caps_normalize" gst_caps_normalize :: 
+    Ptr Caps ->                             -- _obj : TInterface "Gst" "Caps"
+    IO (Ptr Caps)
+
+
+capsNormalize ::
+    (MonadIO m) =>
+    Caps                                    -- _obj
+    -> m Caps                               -- result
+capsNormalize _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_caps_normalize _obj'
+    checkUnexpectedReturnNULL "gst_caps_normalize" result
+    result' <- (wrapBoxed Caps) result
+    touchManagedPtr _obj
+    return result'
+
+data CapsNormalizeMethodInfo
+instance (signature ~ (m Caps), MonadIO m) => MethodInfo CapsNormalizeMethodInfo Caps signature where
+    overloadedMethod _ = capsNormalize
+
+-- method Caps::remove_structure
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "idx", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_caps_remove_structure" gst_caps_remove_structure :: 
+    Ptr Caps ->                             -- _obj : TInterface "Gst" "Caps"
+    Word32 ->                               -- idx : TBasicType TUInt32
+    IO ()
+
+
+capsRemoveStructure ::
+    (MonadIO m) =>
+    Caps                                    -- _obj
+    -> Word32                               -- idx
+    -> m ()                                 -- result
+capsRemoveStructure _obj idx = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    gst_caps_remove_structure _obj' idx
+    touchManagedPtr _obj
+    return ()
+
+data CapsRemoveStructureMethodInfo
+instance (signature ~ (Word32 -> m ()), MonadIO m) => MethodInfo CapsRemoveStructureMethodInfo Caps signature where
+    overloadedMethod _ = capsRemoveStructure
+
+-- method Caps::set_features
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "features", argType = TInterface "Gst" "CapsFeatures", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_caps_set_features" gst_caps_set_features :: 
+    Ptr Caps ->                             -- _obj : TInterface "Gst" "Caps"
+    Word32 ->                               -- index : TBasicType TUInt32
+    Ptr CapsFeatures ->                     -- features : TInterface "Gst" "CapsFeatures"
+    IO ()
+
+
+capsSetFeatures ::
+    (MonadIO m) =>
+    Caps                                    -- _obj
+    -> Word32                               -- index
+    -> Maybe (CapsFeatures)                 -- features
+    -> m ()                                 -- result
+capsSetFeatures _obj index features = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    maybeFeatures <- case features of
+        Nothing -> return nullPtr
+        Just jFeatures -> do
+            jFeatures' <- copyBoxed jFeatures
+            return jFeatures'
+    gst_caps_set_features _obj' index maybeFeatures
+    touchManagedPtr _obj
+    whenJust features touchManagedPtr
+    return ()
+
+data CapsSetFeaturesMethodInfo
+instance (signature ~ (Word32 -> Maybe (CapsFeatures) -> m ()), MonadIO m) => MethodInfo CapsSetFeaturesMethodInfo Caps signature where
+    overloadedMethod _ = capsSetFeatures
+
+-- method Caps::set_value
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "field", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_caps_set_value" gst_caps_set_value :: 
+    Ptr Caps ->                             -- _obj : TInterface "Gst" "Caps"
+    CString ->                              -- field : TBasicType TUTF8
+    Ptr GValue ->                           -- value : TInterface "GObject" "Value"
+    IO ()
+
+
+capsSetValue ::
+    (MonadIO m) =>
+    Caps                                    -- _obj
+    -> T.Text                               -- field
+    -> GValue                               -- value
+    -> m ()                                 -- result
+capsSetValue _obj field value = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    field' <- textToCString field
+    let value' = unsafeManagedPtrGetPtr value
+    gst_caps_set_value _obj' field' value'
+    touchManagedPtr _obj
+    touchManagedPtr value
+    freeMem field'
+    return ()
+
+data CapsSetValueMethodInfo
+instance (signature ~ (T.Text -> GValue -> m ()), MonadIO m) => MethodInfo CapsSetValueMethodInfo Caps signature where
+    overloadedMethod _ = capsSetValue
+
+-- method Caps::simplify
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Caps"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_caps_simplify" gst_caps_simplify :: 
+    Ptr Caps ->                             -- _obj : TInterface "Gst" "Caps"
+    IO (Ptr Caps)
+
+
+capsSimplify ::
+    (MonadIO m) =>
+    Caps                                    -- _obj
+    -> m Caps                               -- result
+capsSimplify _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_caps_simplify _obj'
+    checkUnexpectedReturnNULL "gst_caps_simplify" result
+    result' <- (wrapBoxed Caps) result
+    touchManagedPtr _obj
+    return result'
+
+data CapsSimplifyMethodInfo
+instance (signature ~ (m Caps), MonadIO m) => MethodInfo CapsSimplifyMethodInfo Caps signature where
+    overloadedMethod _ = capsSimplify
+
+-- method Caps::steal_structure
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Structure"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_caps_steal_structure" gst_caps_steal_structure :: 
+    Ptr Caps ->                             -- _obj : TInterface "Gst" "Caps"
+    Word32 ->                               -- index : TBasicType TUInt32
+    IO (Ptr Structure)
+
+
+capsStealStructure ::
+    (MonadIO m) =>
+    Caps                                    -- _obj
+    -> Word32                               -- index
+    -> m Structure                          -- result
+capsStealStructure _obj index = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_caps_steal_structure _obj' index
+    checkUnexpectedReturnNULL "gst_caps_steal_structure" result
+    result' <- (wrapBoxed Structure) result
+    touchManagedPtr _obj
+    return result'
+
+data CapsStealStructureMethodInfo
+instance (signature ~ (Word32 -> m Structure), MonadIO m) => MethodInfo CapsStealStructureMethodInfo Caps signature where
+    overloadedMethod _ = capsStealStructure
+
+-- method Caps::subtract
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "subtrahend", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Caps"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_caps_subtract" gst_caps_subtract :: 
+    Ptr Caps ->                             -- _obj : TInterface "Gst" "Caps"
+    Ptr Caps ->                             -- subtrahend : TInterface "Gst" "Caps"
+    IO (Ptr Caps)
+
+
+capsSubtract ::
+    (MonadIO m) =>
+    Caps                                    -- _obj
+    -> Caps                                 -- subtrahend
+    -> m Caps                               -- result
+capsSubtract _obj subtrahend = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let subtrahend' = unsafeManagedPtrGetPtr subtrahend
+    result <- gst_caps_subtract _obj' subtrahend'
+    checkUnexpectedReturnNULL "gst_caps_subtract" result
+    result' <- (wrapBoxed Caps) result
+    touchManagedPtr _obj
+    touchManagedPtr subtrahend
+    return result'
+
+data CapsSubtractMethodInfo
+instance (signature ~ (Caps -> m Caps), MonadIO m) => MethodInfo CapsSubtractMethodInfo Caps signature where
+    overloadedMethod _ = capsSubtract
+
+-- method Caps::to_string
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUTF8
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_caps_to_string" gst_caps_to_string :: 
+    Ptr Caps ->                             -- _obj : TInterface "Gst" "Caps"
+    IO CString
+
+
+capsToString ::
+    (MonadIO m) =>
+    Caps                                    -- _obj
+    -> m T.Text                             -- result
+capsToString _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_caps_to_string _obj'
+    checkUnexpectedReturnNULL "gst_caps_to_string" result
+    result' <- cstringToText result
+    freeMem result
+    touchManagedPtr _obj
+    return result'
+
+data CapsToStringMethodInfo
+instance (signature ~ (m T.Text), MonadIO m) => MethodInfo CapsToStringMethodInfo Caps signature where
+    overloadedMethod _ = capsToString
+
+-- method Caps::truncate
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Caps"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_caps_truncate" gst_caps_truncate :: 
+    Ptr Caps ->                             -- _obj : TInterface "Gst" "Caps"
+    IO (Ptr Caps)
+
+
+capsTruncate ::
+    (MonadIO m) =>
+    Caps                                    -- _obj
+    -> m Caps                               -- result
+capsTruncate _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_caps_truncate _obj'
+    checkUnexpectedReturnNULL "gst_caps_truncate" result
+    result' <- (wrapBoxed Caps) result
+    touchManagedPtr _obj
+    return result'
+
+data CapsTruncateMethodInfo
+instance (signature ~ (m Caps), MonadIO m) => MethodInfo CapsTruncateMethodInfo Caps signature where
+    overloadedMethod _ = capsTruncate
+
+-- method Caps::from_string
+-- method type : MemberFunction
+-- Args : [Arg {argCName = "string", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Caps"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_caps_from_string" gst_caps_from_string :: 
+    CString ->                              -- string : TBasicType TUTF8
+    IO (Ptr Caps)
+
+
+capsFromString ::
+    (MonadIO m) =>
+    T.Text                                  -- string
+    -> m Caps                               -- result
+capsFromString string = liftIO $ do
+    string' <- textToCString string
+    result <- gst_caps_from_string string'
+    checkUnexpectedReturnNULL "gst_caps_from_string" result
+    result' <- (wrapBoxed Caps) result
+    freeMem string'
+    return result'
+
+type family ResolveCapsMethod (t :: Symbol) (o :: *) :: * where
+    ResolveCapsMethod "append" o = CapsAppendMethodInfo
+    ResolveCapsMethod "appendStructure" o = CapsAppendStructureMethodInfo
+    ResolveCapsMethod "appendStructureFull" o = CapsAppendStructureFullMethodInfo
+    ResolveCapsMethod "canIntersect" o = CapsCanIntersectMethodInfo
+    ResolveCapsMethod "copyNth" o = CapsCopyNthMethodInfo
+    ResolveCapsMethod "filterAndMapInPlace" o = CapsFilterAndMapInPlaceMethodInfo
+    ResolveCapsMethod "fixate" o = CapsFixateMethodInfo
+    ResolveCapsMethod "foreach" o = CapsForeachMethodInfo
+    ResolveCapsMethod "intersect" o = CapsIntersectMethodInfo
+    ResolveCapsMethod "intersectFull" o = CapsIntersectFullMethodInfo
+    ResolveCapsMethod "isAlwaysCompatible" o = CapsIsAlwaysCompatibleMethodInfo
+    ResolveCapsMethod "isAny" o = CapsIsAnyMethodInfo
+    ResolveCapsMethod "isEmpty" o = CapsIsEmptyMethodInfo
+    ResolveCapsMethod "isEqual" o = CapsIsEqualMethodInfo
+    ResolveCapsMethod "isEqualFixed" o = CapsIsEqualFixedMethodInfo
+    ResolveCapsMethod "isFixed" o = CapsIsFixedMethodInfo
+    ResolveCapsMethod "isStrictlyEqual" o = CapsIsStrictlyEqualMethodInfo
+    ResolveCapsMethod "isSubset" o = CapsIsSubsetMethodInfo
+    ResolveCapsMethod "isSubsetStructure" o = CapsIsSubsetStructureMethodInfo
+    ResolveCapsMethod "isSubsetStructureFull" o = CapsIsSubsetStructureFullMethodInfo
+    ResolveCapsMethod "mapInPlace" o = CapsMapInPlaceMethodInfo
+    ResolveCapsMethod "merge" o = CapsMergeMethodInfo
+    ResolveCapsMethod "mergeStructure" o = CapsMergeStructureMethodInfo
+    ResolveCapsMethod "mergeStructureFull" o = CapsMergeStructureFullMethodInfo
+    ResolveCapsMethod "normalize" o = CapsNormalizeMethodInfo
+    ResolveCapsMethod "removeStructure" o = CapsRemoveStructureMethodInfo
+    ResolveCapsMethod "simplify" o = CapsSimplifyMethodInfo
+    ResolveCapsMethod "stealStructure" o = CapsStealStructureMethodInfo
+    ResolveCapsMethod "subtract" o = CapsSubtractMethodInfo
+    ResolveCapsMethod "toString" o = CapsToStringMethodInfo
+    ResolveCapsMethod "truncate" o = CapsTruncateMethodInfo
+    ResolveCapsMethod "getFeatures" o = CapsGetFeaturesMethodInfo
+    ResolveCapsMethod "getSize" o = CapsGetSizeMethodInfo
+    ResolveCapsMethod "getStructure" o = CapsGetStructureMethodInfo
+    ResolveCapsMethod "setFeatures" o = CapsSetFeaturesMethodInfo
+    ResolveCapsMethod "setValue" o = CapsSetValueMethodInfo
+    ResolveCapsMethod l o = MethodResolutionFailed l o
+
+instance (info ~ ResolveCapsMethod t Caps, MethodInfo info Caps p) => IsLabelProxy t (Caps -> p) where
+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)
+
+#if MIN_VERSION_base(4,9,0)
+instance (info ~ ResolveCapsMethod t Caps, MethodInfo info Caps p) => IsLabel t (Caps -> p) where
+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)
+#endif
+
+
diff --git a/GI/Gst/Structs/Caps.hs-boot b/GI/Gst/Structs/Caps.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/Caps.hs-boot
@@ -0,0 +1,47 @@
+module GI.Gst.Structs.Caps where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+newtype Caps = Caps (ForeignPtr Caps)
+instance BoxedObject Caps where
+data CapsAppendMethodInfo
+data CapsAppendStructureMethodInfo
+data CapsAppendStructureFullMethodInfo
+data CapsCanIntersectMethodInfo
+data CapsCopyNthMethodInfo
+data CapsFilterAndMapInPlaceMethodInfo
+data CapsFixateMethodInfo
+data CapsForeachMethodInfo
+data CapsGetFeaturesMethodInfo
+data CapsGetSizeMethodInfo
+data CapsGetStructureMethodInfo
+data CapsIntersectMethodInfo
+data CapsIntersectFullMethodInfo
+data CapsIsAlwaysCompatibleMethodInfo
+data CapsIsAnyMethodInfo
+data CapsIsEmptyMethodInfo
+data CapsIsEqualMethodInfo
+data CapsIsEqualFixedMethodInfo
+data CapsIsFixedMethodInfo
+data CapsIsStrictlyEqualMethodInfo
+data CapsIsSubsetMethodInfo
+data CapsIsSubsetStructureMethodInfo
+data CapsIsSubsetStructureFullMethodInfo
+data CapsMapInPlaceMethodInfo
+data CapsMergeMethodInfo
+data CapsMergeStructureMethodInfo
+data CapsMergeStructureFullMethodInfo
+data CapsNormalizeMethodInfo
+data CapsRemoveStructureMethodInfo
+data CapsSetFeaturesMethodInfo
+data CapsSetValueMethodInfo
+data CapsSimplifyMethodInfo
+data CapsStealStructureMethodInfo
+data CapsSubtractMethodInfo
+data CapsToStringMethodInfo
+data CapsTruncateMethodInfo
diff --git a/GI/Gst/Structs/CapsFeatures.hs b/GI/Gst/Structs/CapsFeatures.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/CapsFeatures.hs
@@ -0,0 +1,686 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+
+#GstCapsFeatures can optionally be set on a #GstCaps to add requirements
+for additional features for a specific #GstStructure. Caps structures with
+the same name but with a non-equal set of caps features are not compatible.
+If a pad supports multiple sets of features it has to add multiple equal
+structures with different feature sets to the caps.
+
+Empty #GstCapsFeatures are equivalent with the #GstCapsFeatures that only
+contain #GST_CAPS_FEATURE_MEMORY_SYSTEM_MEMORY. ANY #GstCapsFeatures as
+created by gst_caps_features_new_any() are equal to any other #GstCapsFeatures
+and can be used to specify that any #GstCapsFeatures would be supported, e.g.
+for elements that don't touch buffer memory. #GstCaps with ANY #GstCapsFeatures
+are considered non-fixed and during negotiation some #GstCapsFeatures have
+to be selected.
+
+Examples for caps features would be the requirement of a specific #GstMemory
+types or the requirement of having a specific #GstMeta on the buffer. Features
+are given as a string of the format "memory:GstMemoryTypeName" or
+"meta:GstMetaAPIName".
+-}
+
+module GI.Gst.Structs.CapsFeatures
+    ( 
+
+-- * Exported types
+    CapsFeatures(..)                        ,
+    noCapsFeatures                          ,
+
+
+ -- * Methods
+-- ** capsFeaturesAdd
+    CapsFeaturesAddMethodInfo               ,
+    capsFeaturesAdd                         ,
+
+
+-- ** capsFeaturesAddId
+    CapsFeaturesAddIdMethodInfo             ,
+    capsFeaturesAddId                       ,
+
+
+-- ** capsFeaturesContains
+    CapsFeaturesContainsMethodInfo          ,
+    capsFeaturesContains                    ,
+
+
+-- ** capsFeaturesContainsId
+    CapsFeaturesContainsIdMethodInfo        ,
+    capsFeaturesContainsId                  ,
+
+
+-- ** capsFeaturesCopy
+    CapsFeaturesCopyMethodInfo              ,
+    capsFeaturesCopy                        ,
+
+
+-- ** capsFeaturesFree
+    CapsFeaturesFreeMethodInfo              ,
+    capsFeaturesFree                        ,
+
+
+-- ** capsFeaturesFromString
+    capsFeaturesFromString                  ,
+
+
+-- ** capsFeaturesGetNth
+    CapsFeaturesGetNthMethodInfo            ,
+    capsFeaturesGetNth                      ,
+
+
+-- ** capsFeaturesGetNthId
+    CapsFeaturesGetNthIdMethodInfo          ,
+    capsFeaturesGetNthId                    ,
+
+
+-- ** capsFeaturesGetSize
+    CapsFeaturesGetSizeMethodInfo           ,
+    capsFeaturesGetSize                     ,
+
+
+-- ** capsFeaturesIsAny
+    CapsFeaturesIsAnyMethodInfo             ,
+    capsFeaturesIsAny                       ,
+
+
+-- ** capsFeaturesIsEqual
+    CapsFeaturesIsEqualMethodInfo           ,
+    capsFeaturesIsEqual                     ,
+
+
+-- ** capsFeaturesNewAny
+    capsFeaturesNewAny                      ,
+
+
+-- ** capsFeaturesNewEmpty
+    capsFeaturesNewEmpty                    ,
+
+
+-- ** capsFeaturesRemove
+    CapsFeaturesRemoveMethodInfo            ,
+    capsFeaturesRemove                      ,
+
+
+-- ** capsFeaturesRemoveId
+    CapsFeaturesRemoveIdMethodInfo          ,
+    capsFeaturesRemoveId                    ,
+
+
+-- ** capsFeaturesSetParentRefcount
+    CapsFeaturesSetParentRefcountMethodInfo ,
+    capsFeaturesSetParentRefcount           ,
+
+
+-- ** capsFeaturesToString
+    CapsFeaturesToStringMethodInfo          ,
+    capsFeaturesToString                    ,
+
+
+
+
+    ) where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+import GI.Gst.Callbacks
+
+newtype CapsFeatures = CapsFeatures (ForeignPtr CapsFeatures)
+foreign import ccall "gst_caps_features_get_type" c_gst_caps_features_get_type :: 
+    IO GType
+
+instance BoxedObject CapsFeatures where
+    boxedType _ = c_gst_caps_features_get_type
+
+noCapsFeatures :: Maybe CapsFeatures
+noCapsFeatures = Nothing
+
+-- method CapsFeatures::new_any
+-- method type : Constructor
+-- Args : []
+-- Lengths : []
+-- returnType : TInterface "Gst" "CapsFeatures"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_caps_features_new_any" gst_caps_features_new_any :: 
+    IO (Ptr CapsFeatures)
+
+
+capsFeaturesNewAny ::
+    (MonadIO m) =>
+    m CapsFeatures                          -- result
+capsFeaturesNewAny  = liftIO $ do
+    result <- gst_caps_features_new_any
+    checkUnexpectedReturnNULL "gst_caps_features_new_any" result
+    result' <- (wrapBoxed CapsFeatures) result
+    return result'
+
+-- method CapsFeatures::new_empty
+-- method type : Constructor
+-- Args : []
+-- Lengths : []
+-- returnType : TInterface "Gst" "CapsFeatures"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_caps_features_new_empty" gst_caps_features_new_empty :: 
+    IO (Ptr CapsFeatures)
+
+
+capsFeaturesNewEmpty ::
+    (MonadIO m) =>
+    m CapsFeatures                          -- result
+capsFeaturesNewEmpty  = liftIO $ do
+    result <- gst_caps_features_new_empty
+    checkUnexpectedReturnNULL "gst_caps_features_new_empty" result
+    result' <- (wrapBoxed CapsFeatures) result
+    return result'
+
+-- method CapsFeatures::add
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "CapsFeatures", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "feature", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_caps_features_add" gst_caps_features_add :: 
+    Ptr CapsFeatures ->                     -- _obj : TInterface "Gst" "CapsFeatures"
+    CString ->                              -- feature : TBasicType TUTF8
+    IO ()
+
+
+capsFeaturesAdd ::
+    (MonadIO m) =>
+    CapsFeatures                            -- _obj
+    -> T.Text                               -- feature
+    -> m ()                                 -- result
+capsFeaturesAdd _obj feature = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    feature' <- textToCString feature
+    gst_caps_features_add _obj' feature'
+    touchManagedPtr _obj
+    freeMem feature'
+    return ()
+
+data CapsFeaturesAddMethodInfo
+instance (signature ~ (T.Text -> m ()), MonadIO m) => MethodInfo CapsFeaturesAddMethodInfo CapsFeatures signature where
+    overloadedMethod _ = capsFeaturesAdd
+
+-- method CapsFeatures::add_id
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "CapsFeatures", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "feature", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_caps_features_add_id" gst_caps_features_add_id :: 
+    Ptr CapsFeatures ->                     -- _obj : TInterface "Gst" "CapsFeatures"
+    Word32 ->                               -- feature : TBasicType TUInt32
+    IO ()
+
+
+capsFeaturesAddId ::
+    (MonadIO m) =>
+    CapsFeatures                            -- _obj
+    -> Word32                               -- feature
+    -> m ()                                 -- result
+capsFeaturesAddId _obj feature = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    gst_caps_features_add_id _obj' feature
+    touchManagedPtr _obj
+    return ()
+
+data CapsFeaturesAddIdMethodInfo
+instance (signature ~ (Word32 -> m ()), MonadIO m) => MethodInfo CapsFeaturesAddIdMethodInfo CapsFeatures signature where
+    overloadedMethod _ = capsFeaturesAddId
+
+-- method CapsFeatures::contains
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "CapsFeatures", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "feature", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_caps_features_contains" gst_caps_features_contains :: 
+    Ptr CapsFeatures ->                     -- _obj : TInterface "Gst" "CapsFeatures"
+    CString ->                              -- feature : TBasicType TUTF8
+    IO CInt
+
+
+capsFeaturesContains ::
+    (MonadIO m) =>
+    CapsFeatures                            -- _obj
+    -> T.Text                               -- feature
+    -> m Bool                               -- result
+capsFeaturesContains _obj feature = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    feature' <- textToCString feature
+    result <- gst_caps_features_contains _obj' feature'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    freeMem feature'
+    return result'
+
+data CapsFeaturesContainsMethodInfo
+instance (signature ~ (T.Text -> m Bool), MonadIO m) => MethodInfo CapsFeaturesContainsMethodInfo CapsFeatures signature where
+    overloadedMethod _ = capsFeaturesContains
+
+-- method CapsFeatures::contains_id
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "CapsFeatures", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "feature", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_caps_features_contains_id" gst_caps_features_contains_id :: 
+    Ptr CapsFeatures ->                     -- _obj : TInterface "Gst" "CapsFeatures"
+    Word32 ->                               -- feature : TBasicType TUInt32
+    IO CInt
+
+
+capsFeaturesContainsId ::
+    (MonadIO m) =>
+    CapsFeatures                            -- _obj
+    -> Word32                               -- feature
+    -> m Bool                               -- result
+capsFeaturesContainsId _obj feature = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_caps_features_contains_id _obj' feature
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data CapsFeaturesContainsIdMethodInfo
+instance (signature ~ (Word32 -> m Bool), MonadIO m) => MethodInfo CapsFeaturesContainsIdMethodInfo CapsFeatures signature where
+    overloadedMethod _ = capsFeaturesContainsId
+
+-- method CapsFeatures::copy
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "CapsFeatures", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "CapsFeatures"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_caps_features_copy" gst_caps_features_copy :: 
+    Ptr CapsFeatures ->                     -- _obj : TInterface "Gst" "CapsFeatures"
+    IO (Ptr CapsFeatures)
+
+
+capsFeaturesCopy ::
+    (MonadIO m) =>
+    CapsFeatures                            -- _obj
+    -> m CapsFeatures                       -- result
+capsFeaturesCopy _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_caps_features_copy _obj'
+    checkUnexpectedReturnNULL "gst_caps_features_copy" result
+    result' <- (wrapBoxed CapsFeatures) result
+    touchManagedPtr _obj
+    return result'
+
+data CapsFeaturesCopyMethodInfo
+instance (signature ~ (m CapsFeatures), MonadIO m) => MethodInfo CapsFeaturesCopyMethodInfo CapsFeatures signature where
+    overloadedMethod _ = capsFeaturesCopy
+
+-- method CapsFeatures::free
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "CapsFeatures", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_caps_features_free" gst_caps_features_free :: 
+    Ptr CapsFeatures ->                     -- _obj : TInterface "Gst" "CapsFeatures"
+    IO ()
+
+
+capsFeaturesFree ::
+    (MonadIO m) =>
+    CapsFeatures                            -- _obj
+    -> m ()                                 -- result
+capsFeaturesFree _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    gst_caps_features_free _obj'
+    touchManagedPtr _obj
+    return ()
+
+data CapsFeaturesFreeMethodInfo
+instance (signature ~ (m ()), MonadIO m) => MethodInfo CapsFeaturesFreeMethodInfo CapsFeatures signature where
+    overloadedMethod _ = capsFeaturesFree
+
+-- method CapsFeatures::get_nth
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "CapsFeatures", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "i", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUTF8
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_caps_features_get_nth" gst_caps_features_get_nth :: 
+    Ptr CapsFeatures ->                     -- _obj : TInterface "Gst" "CapsFeatures"
+    Word32 ->                               -- i : TBasicType TUInt32
+    IO CString
+
+
+capsFeaturesGetNth ::
+    (MonadIO m) =>
+    CapsFeatures                            -- _obj
+    -> Word32                               -- i
+    -> m T.Text                             -- result
+capsFeaturesGetNth _obj i = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_caps_features_get_nth _obj' i
+    checkUnexpectedReturnNULL "gst_caps_features_get_nth" result
+    result' <- cstringToText result
+    touchManagedPtr _obj
+    return result'
+
+data CapsFeaturesGetNthMethodInfo
+instance (signature ~ (Word32 -> m T.Text), MonadIO m) => MethodInfo CapsFeaturesGetNthMethodInfo CapsFeatures signature where
+    overloadedMethod _ = capsFeaturesGetNth
+
+-- method CapsFeatures::get_nth_id
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "CapsFeatures", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "i", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUInt32
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_caps_features_get_nth_id" gst_caps_features_get_nth_id :: 
+    Ptr CapsFeatures ->                     -- _obj : TInterface "Gst" "CapsFeatures"
+    Word32 ->                               -- i : TBasicType TUInt32
+    IO Word32
+
+
+capsFeaturesGetNthId ::
+    (MonadIO m) =>
+    CapsFeatures                            -- _obj
+    -> Word32                               -- i
+    -> m Word32                             -- result
+capsFeaturesGetNthId _obj i = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_caps_features_get_nth_id _obj' i
+    touchManagedPtr _obj
+    return result
+
+data CapsFeaturesGetNthIdMethodInfo
+instance (signature ~ (Word32 -> m Word32), MonadIO m) => MethodInfo CapsFeaturesGetNthIdMethodInfo CapsFeatures signature where
+    overloadedMethod _ = capsFeaturesGetNthId
+
+-- method CapsFeatures::get_size
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "CapsFeatures", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUInt32
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_caps_features_get_size" gst_caps_features_get_size :: 
+    Ptr CapsFeatures ->                     -- _obj : TInterface "Gst" "CapsFeatures"
+    IO Word32
+
+
+capsFeaturesGetSize ::
+    (MonadIO m) =>
+    CapsFeatures                            -- _obj
+    -> m Word32                             -- result
+capsFeaturesGetSize _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_caps_features_get_size _obj'
+    touchManagedPtr _obj
+    return result
+
+data CapsFeaturesGetSizeMethodInfo
+instance (signature ~ (m Word32), MonadIO m) => MethodInfo CapsFeaturesGetSizeMethodInfo CapsFeatures signature where
+    overloadedMethod _ = capsFeaturesGetSize
+
+-- method CapsFeatures::is_any
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "CapsFeatures", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_caps_features_is_any" gst_caps_features_is_any :: 
+    Ptr CapsFeatures ->                     -- _obj : TInterface "Gst" "CapsFeatures"
+    IO CInt
+
+
+capsFeaturesIsAny ::
+    (MonadIO m) =>
+    CapsFeatures                            -- _obj
+    -> m Bool                               -- result
+capsFeaturesIsAny _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_caps_features_is_any _obj'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data CapsFeaturesIsAnyMethodInfo
+instance (signature ~ (m Bool), MonadIO m) => MethodInfo CapsFeaturesIsAnyMethodInfo CapsFeatures signature where
+    overloadedMethod _ = capsFeaturesIsAny
+
+-- method CapsFeatures::is_equal
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "CapsFeatures", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "features2", argType = TInterface "Gst" "CapsFeatures", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_caps_features_is_equal" gst_caps_features_is_equal :: 
+    Ptr CapsFeatures ->                     -- _obj : TInterface "Gst" "CapsFeatures"
+    Ptr CapsFeatures ->                     -- features2 : TInterface "Gst" "CapsFeatures"
+    IO CInt
+
+
+capsFeaturesIsEqual ::
+    (MonadIO m) =>
+    CapsFeatures                            -- _obj
+    -> CapsFeatures                         -- features2
+    -> m Bool                               -- result
+capsFeaturesIsEqual _obj features2 = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let features2' = unsafeManagedPtrGetPtr features2
+    result <- gst_caps_features_is_equal _obj' features2'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    touchManagedPtr features2
+    return result'
+
+data CapsFeaturesIsEqualMethodInfo
+instance (signature ~ (CapsFeatures -> m Bool), MonadIO m) => MethodInfo CapsFeaturesIsEqualMethodInfo CapsFeatures signature where
+    overloadedMethod _ = capsFeaturesIsEqual
+
+-- method CapsFeatures::remove
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "CapsFeatures", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "feature", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_caps_features_remove" gst_caps_features_remove :: 
+    Ptr CapsFeatures ->                     -- _obj : TInterface "Gst" "CapsFeatures"
+    CString ->                              -- feature : TBasicType TUTF8
+    IO ()
+
+
+capsFeaturesRemove ::
+    (MonadIO m) =>
+    CapsFeatures                            -- _obj
+    -> T.Text                               -- feature
+    -> m ()                                 -- result
+capsFeaturesRemove _obj feature = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    feature' <- textToCString feature
+    gst_caps_features_remove _obj' feature'
+    touchManagedPtr _obj
+    freeMem feature'
+    return ()
+
+data CapsFeaturesRemoveMethodInfo
+instance (signature ~ (T.Text -> m ()), MonadIO m) => MethodInfo CapsFeaturesRemoveMethodInfo CapsFeatures signature where
+    overloadedMethod _ = capsFeaturesRemove
+
+-- method CapsFeatures::remove_id
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "CapsFeatures", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "feature", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_caps_features_remove_id" gst_caps_features_remove_id :: 
+    Ptr CapsFeatures ->                     -- _obj : TInterface "Gst" "CapsFeatures"
+    Word32 ->                               -- feature : TBasicType TUInt32
+    IO ()
+
+
+capsFeaturesRemoveId ::
+    (MonadIO m) =>
+    CapsFeatures                            -- _obj
+    -> Word32                               -- feature
+    -> m ()                                 -- result
+capsFeaturesRemoveId _obj feature = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    gst_caps_features_remove_id _obj' feature
+    touchManagedPtr _obj
+    return ()
+
+data CapsFeaturesRemoveIdMethodInfo
+instance (signature ~ (Word32 -> m ()), MonadIO m) => MethodInfo CapsFeaturesRemoveIdMethodInfo CapsFeatures signature where
+    overloadedMethod _ = capsFeaturesRemoveId
+
+-- method CapsFeatures::set_parent_refcount
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "CapsFeatures", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "refcount", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_caps_features_set_parent_refcount" gst_caps_features_set_parent_refcount :: 
+    Ptr CapsFeatures ->                     -- _obj : TInterface "Gst" "CapsFeatures"
+    Int32 ->                                -- refcount : TBasicType TInt32
+    IO CInt
+
+
+capsFeaturesSetParentRefcount ::
+    (MonadIO m) =>
+    CapsFeatures                            -- _obj
+    -> Int32                                -- refcount
+    -> m Bool                               -- result
+capsFeaturesSetParentRefcount _obj refcount = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_caps_features_set_parent_refcount _obj' refcount
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data CapsFeaturesSetParentRefcountMethodInfo
+instance (signature ~ (Int32 -> m Bool), MonadIO m) => MethodInfo CapsFeaturesSetParentRefcountMethodInfo CapsFeatures signature where
+    overloadedMethod _ = capsFeaturesSetParentRefcount
+
+-- method CapsFeatures::to_string
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "CapsFeatures", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUTF8
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_caps_features_to_string" gst_caps_features_to_string :: 
+    Ptr CapsFeatures ->                     -- _obj : TInterface "Gst" "CapsFeatures"
+    IO CString
+
+
+capsFeaturesToString ::
+    (MonadIO m) =>
+    CapsFeatures                            -- _obj
+    -> m T.Text                             -- result
+capsFeaturesToString _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_caps_features_to_string _obj'
+    checkUnexpectedReturnNULL "gst_caps_features_to_string" result
+    result' <- cstringToText result
+    freeMem result
+    touchManagedPtr _obj
+    return result'
+
+data CapsFeaturesToStringMethodInfo
+instance (signature ~ (m T.Text), MonadIO m) => MethodInfo CapsFeaturesToStringMethodInfo CapsFeatures signature where
+    overloadedMethod _ = capsFeaturesToString
+
+-- method CapsFeatures::from_string
+-- method type : MemberFunction
+-- Args : [Arg {argCName = "features", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "CapsFeatures"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_caps_features_from_string" gst_caps_features_from_string :: 
+    CString ->                              -- features : TBasicType TUTF8
+    IO (Ptr CapsFeatures)
+
+
+capsFeaturesFromString ::
+    (MonadIO m) =>
+    T.Text                                  -- features
+    -> m CapsFeatures                       -- result
+capsFeaturesFromString features = liftIO $ do
+    features' <- textToCString features
+    result <- gst_caps_features_from_string features'
+    checkUnexpectedReturnNULL "gst_caps_features_from_string" result
+    result' <- (wrapBoxed CapsFeatures) result
+    freeMem features'
+    return result'
+
+type family ResolveCapsFeaturesMethod (t :: Symbol) (o :: *) :: * where
+    ResolveCapsFeaturesMethod "add" o = CapsFeaturesAddMethodInfo
+    ResolveCapsFeaturesMethod "addId" o = CapsFeaturesAddIdMethodInfo
+    ResolveCapsFeaturesMethod "contains" o = CapsFeaturesContainsMethodInfo
+    ResolveCapsFeaturesMethod "containsId" o = CapsFeaturesContainsIdMethodInfo
+    ResolveCapsFeaturesMethod "copy" o = CapsFeaturesCopyMethodInfo
+    ResolveCapsFeaturesMethod "free" o = CapsFeaturesFreeMethodInfo
+    ResolveCapsFeaturesMethod "isAny" o = CapsFeaturesIsAnyMethodInfo
+    ResolveCapsFeaturesMethod "isEqual" o = CapsFeaturesIsEqualMethodInfo
+    ResolveCapsFeaturesMethod "remove" o = CapsFeaturesRemoveMethodInfo
+    ResolveCapsFeaturesMethod "removeId" o = CapsFeaturesRemoveIdMethodInfo
+    ResolveCapsFeaturesMethod "toString" o = CapsFeaturesToStringMethodInfo
+    ResolveCapsFeaturesMethod "getNth" o = CapsFeaturesGetNthMethodInfo
+    ResolveCapsFeaturesMethod "getNthId" o = CapsFeaturesGetNthIdMethodInfo
+    ResolveCapsFeaturesMethod "getSize" o = CapsFeaturesGetSizeMethodInfo
+    ResolveCapsFeaturesMethod "setParentRefcount" o = CapsFeaturesSetParentRefcountMethodInfo
+    ResolveCapsFeaturesMethod l o = MethodResolutionFailed l o
+
+instance (info ~ ResolveCapsFeaturesMethod t CapsFeatures, MethodInfo info CapsFeatures p) => IsLabelProxy t (CapsFeatures -> p) where
+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)
+
+#if MIN_VERSION_base(4,9,0)
+instance (info ~ ResolveCapsFeaturesMethod t CapsFeatures, MethodInfo info CapsFeatures p) => IsLabel t (CapsFeatures -> p) where
+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)
+#endif
+
+
diff --git a/GI/Gst/Structs/CapsFeatures.hs-boot b/GI/Gst/Structs/CapsFeatures.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/CapsFeatures.hs-boot
@@ -0,0 +1,26 @@
+module GI.Gst.Structs.CapsFeatures where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+newtype CapsFeatures = CapsFeatures (ForeignPtr CapsFeatures)
+instance BoxedObject CapsFeatures where
+data CapsFeaturesAddMethodInfo
+data CapsFeaturesAddIdMethodInfo
+data CapsFeaturesContainsMethodInfo
+data CapsFeaturesContainsIdMethodInfo
+data CapsFeaturesCopyMethodInfo
+data CapsFeaturesFreeMethodInfo
+data CapsFeaturesGetNthMethodInfo
+data CapsFeaturesGetNthIdMethodInfo
+data CapsFeaturesGetSizeMethodInfo
+data CapsFeaturesIsAnyMethodInfo
+data CapsFeaturesIsEqualMethodInfo
+data CapsFeaturesRemoveMethodInfo
+data CapsFeaturesRemoveIdMethodInfo
+data CapsFeaturesSetParentRefcountMethodInfo
+data CapsFeaturesToStringMethodInfo
diff --git a/GI/Gst/Structs/ClockEntry.hs b/GI/Gst/Structs/ClockEntry.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/ClockEntry.hs
@@ -0,0 +1,147 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+
+All pending timeouts or periodic notifies are converted into
+an entry.
+Note that GstClockEntry should be treated as an opaque structure. It must
+not be extended or allocated using a custom allocator.
+-}
+
+module GI.Gst.Structs.ClockEntry
+    ( 
+
+-- * Exported types
+    ClockEntry(..)                          ,
+    newZeroClockEntry                       ,
+    noClockEntry                            ,
+
+
+ -- * Properties
+-- ** Clock
+    clockEntryReadClock                     ,
+
+
+-- ** Interval
+    clockEntryReadInterval                  ,
+
+
+-- ** Refcount
+    clockEntryReadRefcount                  ,
+
+
+-- ** Status
+    clockEntryReadStatus                    ,
+
+
+-- ** Time
+    clockEntryReadTime                      ,
+
+
+-- ** Type
+    clockEntryReadType                      ,
+
+
+-- ** Unscheduled
+    clockEntryReadUnscheduled               ,
+
+
+-- ** UserData
+    clockEntryReadUserData                  ,
+
+
+-- ** WokenUp
+    clockEntryReadWokenUp                   ,
+
+
+
+
+    ) where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+import GI.Gst.Callbacks
+
+newtype ClockEntry = ClockEntry (ForeignPtr ClockEntry)
+-- | Construct a `ClockEntry` struct initialized to zero.
+newZeroClockEntry :: MonadIO m => m ClockEntry
+newZeroClockEntry = liftIO $ callocBytes 112 >>= wrapPtr ClockEntry
+
+noClockEntry :: Maybe ClockEntry
+noClockEntry = Nothing
+
+clockEntryReadRefcount :: ClockEntry -> IO Int32
+clockEntryReadRefcount s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 0) :: IO Int32
+    return val
+
+clockEntryReadClock :: ClockEntry -> IO Clock
+clockEntryReadClock s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 8) :: IO (Ptr Clock)
+    val' <- (newObject Clock) val
+    return val'
+
+clockEntryReadType :: ClockEntry -> IO ClockEntryType
+clockEntryReadType s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 16) :: IO CUInt
+    let val' = (toEnum . fromIntegral) val
+    return val'
+
+clockEntryReadTime :: ClockEntry -> IO Word64
+clockEntryReadTime s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 24) :: IO Word64
+    return val
+
+clockEntryReadInterval :: ClockEntry -> IO Word64
+clockEntryReadInterval s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 32) :: IO Word64
+    return val
+
+clockEntryReadStatus :: ClockEntry -> IO ClockReturn
+clockEntryReadStatus s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 40) :: IO CUInt
+    let val' = (toEnum . fromIntegral) val
+    return val'
+
+-- XXX Skipped getter for "ClockEntry:func" :: Not implemented: "Wrapping foreign callbacks is not supported yet"
+
+clockEntryReadUserData :: ClockEntry -> IO (Ptr ())
+clockEntryReadUserData s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 56) :: IO (Ptr ())
+    return val
+
+-- XXX Skipped getter for "ClockEntry:destroy_data" :: Not implemented: "Wrapping foreign callbacks is not supported yet"
+
+clockEntryReadUnscheduled :: ClockEntry -> IO Bool
+clockEntryReadUnscheduled s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 72) :: IO CInt
+    let val' = (/= 0) val
+    return val'
+
+clockEntryReadWokenUp :: ClockEntry -> IO Bool
+clockEntryReadWokenUp s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 76) :: IO CInt
+    let val' = (/= 0) val
+    return val'
+
+type family ResolveClockEntryMethod (t :: Symbol) (o :: *) :: * where
+    ResolveClockEntryMethod l o = MethodResolutionFailed l o
+
+instance (info ~ ResolveClockEntryMethod t ClockEntry, MethodInfo info ClockEntry p) => IsLabelProxy t (ClockEntry -> p) where
+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)
+
+#if MIN_VERSION_base(4,9,0)
+instance (info ~ ResolveClockEntryMethod t ClockEntry, MethodInfo info ClockEntry p) => IsLabel t (ClockEntry -> p) where
+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)
+#endif
+
+
diff --git a/GI/Gst/Structs/ClockEntry.hs-boot b/GI/Gst/Structs/ClockEntry.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/ClockEntry.hs-boot
@@ -0,0 +1,10 @@
+module GI.Gst.Structs.ClockEntry where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+newtype ClockEntry = ClockEntry (ForeignPtr ClockEntry)
diff --git a/GI/Gst/Structs/Context.hs b/GI/Gst/Structs/Context.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/Context.hs
@@ -0,0 +1,285 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+
+#GstContext is a container object used to store contexts like a device
+context, a display server connection and similar concepts that should
+be shared between multiple elements.
+
+Applications can set a context on a complete pipeline by using
+gst_element_set_context(), which will then be propagated to all
+child elements. Elements can handle these in #GstElementClass.set_context()
+and merge them with the context information they already have.
+
+When an element needs a context it will do the following actions in this
+order until one step succeeds:
+1. Check if the element already has a context
+2. Query downstream with GST_QUERY_CONTEXT for the context
+3. Query upstream with GST_QUERY_CONTEXT for the context
+4. Post a GST_MESSAGE_NEED_CONTEXT message on the bus with the required
+   context types and afterwards check if a usable context was set now
+5. Create a context by itself and post a GST_MESSAGE_HAVE_CONTEXT message
+   on the bus.
+
+Bins will catch GST_MESSAGE_NEED_CONTEXT messages and will set any previously
+known context on the element that asks for it if possible. Otherwise the
+application should provide one if it can.
+-}
+
+module GI.Gst.Structs.Context
+    ( 
+
+-- * Exported types
+    Context(..)                             ,
+    noContext                               ,
+
+
+ -- * Methods
+-- ** contextGetContextType
+    ContextGetContextTypeMethodInfo         ,
+    contextGetContextType                   ,
+
+
+-- ** contextGetStructure
+    ContextGetStructureMethodInfo           ,
+    contextGetStructure                     ,
+
+
+-- ** contextHasContextType
+    ContextHasContextTypeMethodInfo         ,
+    contextHasContextType                   ,
+
+
+-- ** contextIsPersistent
+    ContextIsPersistentMethodInfo           ,
+    contextIsPersistent                     ,
+
+
+-- ** contextNew
+    contextNew                              ,
+
+
+-- ** contextWritableStructure
+    ContextWritableStructureMethodInfo      ,
+    contextWritableStructure                ,
+
+
+
+
+    ) where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+import GI.Gst.Callbacks
+
+newtype Context = Context (ForeignPtr Context)
+foreign import ccall "gst_context_get_type" c_gst_context_get_type :: 
+    IO GType
+
+instance BoxedObject Context where
+    boxedType _ = c_gst_context_get_type
+
+noContext :: Maybe Context
+noContext = Nothing
+
+-- method Context::new
+-- method type : Constructor
+-- Args : [Arg {argCName = "context_type", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "persistent", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Context"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_context_new" gst_context_new :: 
+    CString ->                              -- context_type : TBasicType TUTF8
+    CInt ->                                 -- persistent : TBasicType TBoolean
+    IO (Ptr Context)
+
+
+contextNew ::
+    (MonadIO m) =>
+    T.Text                                  -- contextType
+    -> Bool                                 -- persistent
+    -> m Context                            -- result
+contextNew contextType persistent = liftIO $ do
+    contextType' <- textToCString contextType
+    let persistent' = (fromIntegral . fromEnum) persistent
+    result <- gst_context_new contextType' persistent'
+    checkUnexpectedReturnNULL "gst_context_new" result
+    result' <- (wrapBoxed Context) result
+    freeMem contextType'
+    return result'
+
+-- method Context::get_context_type
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUTF8
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_context_get_context_type" gst_context_get_context_type :: 
+    Ptr Context ->                          -- _obj : TInterface "Gst" "Context"
+    IO CString
+
+
+contextGetContextType ::
+    (MonadIO m) =>
+    Context                                 -- _obj
+    -> m T.Text                             -- result
+contextGetContextType _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_context_get_context_type _obj'
+    checkUnexpectedReturnNULL "gst_context_get_context_type" result
+    result' <- cstringToText result
+    touchManagedPtr _obj
+    return result'
+
+data ContextGetContextTypeMethodInfo
+instance (signature ~ (m T.Text), MonadIO m) => MethodInfo ContextGetContextTypeMethodInfo Context signature where
+    overloadedMethod _ = contextGetContextType
+
+-- method Context::get_structure
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Structure"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_context_get_structure" gst_context_get_structure :: 
+    Ptr Context ->                          -- _obj : TInterface "Gst" "Context"
+    IO (Ptr Structure)
+
+
+contextGetStructure ::
+    (MonadIO m) =>
+    Context                                 -- _obj
+    -> m Structure                          -- result
+contextGetStructure _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_context_get_structure _obj'
+    checkUnexpectedReturnNULL "gst_context_get_structure" result
+    result' <- (newBoxed Structure) result
+    touchManagedPtr _obj
+    return result'
+
+data ContextGetStructureMethodInfo
+instance (signature ~ (m Structure), MonadIO m) => MethodInfo ContextGetStructureMethodInfo Context signature where
+    overloadedMethod _ = contextGetStructure
+
+-- method Context::has_context_type
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "context_type", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_context_has_context_type" gst_context_has_context_type :: 
+    Ptr Context ->                          -- _obj : TInterface "Gst" "Context"
+    CString ->                              -- context_type : TBasicType TUTF8
+    IO CInt
+
+
+contextHasContextType ::
+    (MonadIO m) =>
+    Context                                 -- _obj
+    -> T.Text                               -- contextType
+    -> m Bool                               -- result
+contextHasContextType _obj contextType = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    contextType' <- textToCString contextType
+    result <- gst_context_has_context_type _obj' contextType'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    freeMem contextType'
+    return result'
+
+data ContextHasContextTypeMethodInfo
+instance (signature ~ (T.Text -> m Bool), MonadIO m) => MethodInfo ContextHasContextTypeMethodInfo Context signature where
+    overloadedMethod _ = contextHasContextType
+
+-- method Context::is_persistent
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_context_is_persistent" gst_context_is_persistent :: 
+    Ptr Context ->                          -- _obj : TInterface "Gst" "Context"
+    IO CInt
+
+
+contextIsPersistent ::
+    (MonadIO m) =>
+    Context                                 -- _obj
+    -> m Bool                               -- result
+contextIsPersistent _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_context_is_persistent _obj'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data ContextIsPersistentMethodInfo
+instance (signature ~ (m Bool), MonadIO m) => MethodInfo ContextIsPersistentMethodInfo Context signature where
+    overloadedMethod _ = contextIsPersistent
+
+-- method Context::writable_structure
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Structure"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_context_writable_structure" gst_context_writable_structure :: 
+    Ptr Context ->                          -- _obj : TInterface "Gst" "Context"
+    IO (Ptr Structure)
+
+
+contextWritableStructure ::
+    (MonadIO m) =>
+    Context                                 -- _obj
+    -> m Structure                          -- result
+contextWritableStructure _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_context_writable_structure _obj'
+    checkUnexpectedReturnNULL "gst_context_writable_structure" result
+    result' <- (wrapBoxed Structure) result
+    touchManagedPtr _obj
+    return result'
+
+data ContextWritableStructureMethodInfo
+instance (signature ~ (m Structure), MonadIO m) => MethodInfo ContextWritableStructureMethodInfo Context signature where
+    overloadedMethod _ = contextWritableStructure
+
+type family ResolveContextMethod (t :: Symbol) (o :: *) :: * where
+    ResolveContextMethod "hasContextType" o = ContextHasContextTypeMethodInfo
+    ResolveContextMethod "isPersistent" o = ContextIsPersistentMethodInfo
+    ResolveContextMethod "writableStructure" o = ContextWritableStructureMethodInfo
+    ResolveContextMethod "getContextType" o = ContextGetContextTypeMethodInfo
+    ResolveContextMethod "getStructure" o = ContextGetStructureMethodInfo
+    ResolveContextMethod l o = MethodResolutionFailed l o
+
+instance (info ~ ResolveContextMethod t Context, MethodInfo info Context p) => IsLabelProxy t (Context -> p) where
+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)
+
+#if MIN_VERSION_base(4,9,0)
+instance (info ~ ResolveContextMethod t Context, MethodInfo info Context p) => IsLabel t (Context -> p) where
+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)
+#endif
+
+
diff --git a/GI/Gst/Structs/Context.hs-boot b/GI/Gst/Structs/Context.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/Context.hs-boot
@@ -0,0 +1,16 @@
+module GI.Gst.Structs.Context where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+newtype Context = Context (ForeignPtr Context)
+instance BoxedObject Context where
+data ContextGetContextTypeMethodInfo
+data ContextGetStructureMethodInfo
+data ContextHasContextTypeMethodInfo
+data ContextIsPersistentMethodInfo
+data ContextWritableStructureMethodInfo
diff --git a/GI/Gst/Structs/DateTime.hs b/GI/Gst/Structs/DateTime.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/DateTime.hs
@@ -0,0 +1,963 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+
+Struct to store date, time and timezone information altogether.
+#GstDateTime is refcounted and immutable.
+
+Date information is handled using the proleptic Gregorian calendar.
+
+Provides basic creation functions and accessor functions to its fields.
+-}
+
+module GI.Gst.Structs.DateTime
+    ( 
+
+-- * Exported types
+    DateTime(..)                            ,
+    noDateTime                              ,
+
+
+ -- * Methods
+-- ** dateTimeGetDay
+    DateTimeGetDayMethodInfo                ,
+    dateTimeGetDay                          ,
+
+
+-- ** dateTimeGetHour
+    DateTimeGetHourMethodInfo               ,
+    dateTimeGetHour                         ,
+
+
+-- ** dateTimeGetMicrosecond
+    DateTimeGetMicrosecondMethodInfo        ,
+    dateTimeGetMicrosecond                  ,
+
+
+-- ** dateTimeGetMinute
+    DateTimeGetMinuteMethodInfo             ,
+    dateTimeGetMinute                       ,
+
+
+-- ** dateTimeGetMonth
+    DateTimeGetMonthMethodInfo              ,
+    dateTimeGetMonth                        ,
+
+
+-- ** dateTimeGetSecond
+    DateTimeGetSecondMethodInfo             ,
+    dateTimeGetSecond                       ,
+
+
+-- ** dateTimeGetTimeZoneOffset
+    DateTimeGetTimeZoneOffsetMethodInfo     ,
+    dateTimeGetTimeZoneOffset               ,
+
+
+-- ** dateTimeGetYear
+    DateTimeGetYearMethodInfo               ,
+    dateTimeGetYear                         ,
+
+
+-- ** dateTimeHasDay
+    DateTimeHasDayMethodInfo                ,
+    dateTimeHasDay                          ,
+
+
+-- ** dateTimeHasMonth
+    DateTimeHasMonthMethodInfo              ,
+    dateTimeHasMonth                        ,
+
+
+-- ** dateTimeHasSecond
+    DateTimeHasSecondMethodInfo             ,
+    dateTimeHasSecond                       ,
+
+
+-- ** dateTimeHasTime
+    DateTimeHasTimeMethodInfo               ,
+    dateTimeHasTime                         ,
+
+
+-- ** dateTimeHasYear
+    DateTimeHasYearMethodInfo               ,
+    dateTimeHasYear                         ,
+
+
+-- ** dateTimeNew
+    dateTimeNew                             ,
+
+
+-- ** dateTimeNewFromGDateTime
+    dateTimeNewFromGDateTime                ,
+
+
+-- ** dateTimeNewFromIso8601String
+    dateTimeNewFromIso8601String            ,
+
+
+-- ** dateTimeNewFromUnixEpochLocalTime
+    dateTimeNewFromUnixEpochLocalTime       ,
+
+
+-- ** dateTimeNewFromUnixEpochUtc
+    dateTimeNewFromUnixEpochUtc             ,
+
+
+-- ** dateTimeNewLocalTime
+    dateTimeNewLocalTime                    ,
+
+
+-- ** dateTimeNewNowLocalTime
+    dateTimeNewNowLocalTime                 ,
+
+
+-- ** dateTimeNewNowUtc
+    dateTimeNewNowUtc                       ,
+
+
+-- ** dateTimeNewY
+    dateTimeNewY                            ,
+
+
+-- ** dateTimeNewYm
+    dateTimeNewYm                           ,
+
+
+-- ** dateTimeNewYmd
+    dateTimeNewYmd                          ,
+
+
+-- ** dateTimeRef
+    DateTimeRefMethodInfo                   ,
+    dateTimeRef                             ,
+
+
+-- ** dateTimeToGDateTime
+    DateTimeToGDateTimeMethodInfo           ,
+    dateTimeToGDateTime                     ,
+
+
+-- ** dateTimeToIso8601String
+    DateTimeToIso8601StringMethodInfo       ,
+    dateTimeToIso8601String                 ,
+
+
+-- ** dateTimeUnref
+    DateTimeUnrefMethodInfo                 ,
+    dateTimeUnref                           ,
+
+
+
+
+    ) where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+import GI.Gst.Callbacks
+import qualified GI.GLib as GLib
+
+newtype DateTime = DateTime (ForeignPtr DateTime)
+foreign import ccall "gst_date_time_get_type" c_gst_date_time_get_type :: 
+    IO GType
+
+instance BoxedObject DateTime where
+    boxedType _ = c_gst_date_time_get_type
+
+noDateTime :: Maybe DateTime
+noDateTime = Nothing
+
+-- method DateTime::new
+-- method type : Constructor
+-- Args : [Arg {argCName = "tzoffset", argType = TBasicType TFloat, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "year", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "month", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "day", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "hour", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "minute", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "seconds", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "DateTime"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_date_time_new" gst_date_time_new :: 
+    CFloat ->                               -- tzoffset : TBasicType TFloat
+    Int32 ->                                -- year : TBasicType TInt32
+    Int32 ->                                -- month : TBasicType TInt32
+    Int32 ->                                -- day : TBasicType TInt32
+    Int32 ->                                -- hour : TBasicType TInt32
+    Int32 ->                                -- minute : TBasicType TInt32
+    CDouble ->                              -- seconds : TBasicType TDouble
+    IO (Ptr DateTime)
+
+
+dateTimeNew ::
+    (MonadIO m) =>
+    Float                                   -- tzoffset
+    -> Int32                                -- year
+    -> Int32                                -- month
+    -> Int32                                -- day
+    -> Int32                                -- hour
+    -> Int32                                -- minute
+    -> Double                               -- seconds
+    -> m DateTime                           -- result
+dateTimeNew tzoffset year month day hour minute seconds = liftIO $ do
+    let tzoffset' = realToFrac tzoffset
+    let seconds' = realToFrac seconds
+    result <- gst_date_time_new tzoffset' year month day hour minute seconds'
+    checkUnexpectedReturnNULL "gst_date_time_new" result
+    result' <- (wrapBoxed DateTime) result
+    return result'
+
+-- method DateTime::new_from_g_date_time
+-- method type : Constructor
+-- Args : [Arg {argCName = "dt", argType = TInterface "GLib" "DateTime", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "DateTime"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_date_time_new_from_g_date_time" gst_date_time_new_from_g_date_time :: 
+    Ptr GLib.DateTime ->                    -- dt : TInterface "GLib" "DateTime"
+    IO (Ptr DateTime)
+
+
+dateTimeNewFromGDateTime ::
+    (MonadIO m) =>
+    GLib.DateTime                           -- dt
+    -> m DateTime                           -- result
+dateTimeNewFromGDateTime dt = liftIO $ do
+    dt' <- copyBoxed dt
+    result <- gst_date_time_new_from_g_date_time dt'
+    checkUnexpectedReturnNULL "gst_date_time_new_from_g_date_time" result
+    result' <- (wrapBoxed DateTime) result
+    touchManagedPtr dt
+    return result'
+
+-- method DateTime::new_from_iso8601_string
+-- method type : Constructor
+-- Args : [Arg {argCName = "string", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "DateTime"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_date_time_new_from_iso8601_string" gst_date_time_new_from_iso8601_string :: 
+    CString ->                              -- string : TBasicType TUTF8
+    IO (Ptr DateTime)
+
+
+dateTimeNewFromIso8601String ::
+    (MonadIO m) =>
+    T.Text                                  -- string
+    -> m DateTime                           -- result
+dateTimeNewFromIso8601String string = liftIO $ do
+    string' <- textToCString string
+    result <- gst_date_time_new_from_iso8601_string string'
+    checkUnexpectedReturnNULL "gst_date_time_new_from_iso8601_string" result
+    result' <- (wrapBoxed DateTime) result
+    freeMem string'
+    return result'
+
+-- method DateTime::new_from_unix_epoch_local_time
+-- method type : Constructor
+-- Args : [Arg {argCName = "secs", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "DateTime"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_date_time_new_from_unix_epoch_local_time" gst_date_time_new_from_unix_epoch_local_time :: 
+    Int64 ->                                -- secs : TBasicType TInt64
+    IO (Ptr DateTime)
+
+
+dateTimeNewFromUnixEpochLocalTime ::
+    (MonadIO m) =>
+    Int64                                   -- secs
+    -> m DateTime                           -- result
+dateTimeNewFromUnixEpochLocalTime secs = liftIO $ do
+    result <- gst_date_time_new_from_unix_epoch_local_time secs
+    checkUnexpectedReturnNULL "gst_date_time_new_from_unix_epoch_local_time" result
+    result' <- (wrapBoxed DateTime) result
+    return result'
+
+-- method DateTime::new_from_unix_epoch_utc
+-- method type : Constructor
+-- Args : [Arg {argCName = "secs", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "DateTime"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_date_time_new_from_unix_epoch_utc" gst_date_time_new_from_unix_epoch_utc :: 
+    Int64 ->                                -- secs : TBasicType TInt64
+    IO (Ptr DateTime)
+
+
+dateTimeNewFromUnixEpochUtc ::
+    (MonadIO m) =>
+    Int64                                   -- secs
+    -> m DateTime                           -- result
+dateTimeNewFromUnixEpochUtc secs = liftIO $ do
+    result <- gst_date_time_new_from_unix_epoch_utc secs
+    checkUnexpectedReturnNULL "gst_date_time_new_from_unix_epoch_utc" result
+    result' <- (wrapBoxed DateTime) result
+    return result'
+
+-- method DateTime::new_local_time
+-- method type : Constructor
+-- Args : [Arg {argCName = "year", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "month", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "day", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "hour", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "minute", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "seconds", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "DateTime"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_date_time_new_local_time" gst_date_time_new_local_time :: 
+    Int32 ->                                -- year : TBasicType TInt32
+    Int32 ->                                -- month : TBasicType TInt32
+    Int32 ->                                -- day : TBasicType TInt32
+    Int32 ->                                -- hour : TBasicType TInt32
+    Int32 ->                                -- minute : TBasicType TInt32
+    CDouble ->                              -- seconds : TBasicType TDouble
+    IO (Ptr DateTime)
+
+
+dateTimeNewLocalTime ::
+    (MonadIO m) =>
+    Int32                                   -- year
+    -> Int32                                -- month
+    -> Int32                                -- day
+    -> Int32                                -- hour
+    -> Int32                                -- minute
+    -> Double                               -- seconds
+    -> m DateTime                           -- result
+dateTimeNewLocalTime year month day hour minute seconds = liftIO $ do
+    let seconds' = realToFrac seconds
+    result <- gst_date_time_new_local_time year month day hour minute seconds'
+    checkUnexpectedReturnNULL "gst_date_time_new_local_time" result
+    result' <- (wrapBoxed DateTime) result
+    return result'
+
+-- method DateTime::new_now_local_time
+-- method type : Constructor
+-- Args : []
+-- Lengths : []
+-- returnType : TInterface "Gst" "DateTime"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_date_time_new_now_local_time" gst_date_time_new_now_local_time :: 
+    IO (Ptr DateTime)
+
+
+dateTimeNewNowLocalTime ::
+    (MonadIO m) =>
+    m DateTime                              -- result
+dateTimeNewNowLocalTime  = liftIO $ do
+    result <- gst_date_time_new_now_local_time
+    checkUnexpectedReturnNULL "gst_date_time_new_now_local_time" result
+    result' <- (wrapBoxed DateTime) result
+    return result'
+
+-- method DateTime::new_now_utc
+-- method type : Constructor
+-- Args : []
+-- Lengths : []
+-- returnType : TInterface "Gst" "DateTime"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_date_time_new_now_utc" gst_date_time_new_now_utc :: 
+    IO (Ptr DateTime)
+
+
+dateTimeNewNowUtc ::
+    (MonadIO m) =>
+    m DateTime                              -- result
+dateTimeNewNowUtc  = liftIO $ do
+    result <- gst_date_time_new_now_utc
+    checkUnexpectedReturnNULL "gst_date_time_new_now_utc" result
+    result' <- (wrapBoxed DateTime) result
+    return result'
+
+-- method DateTime::new_y
+-- method type : Constructor
+-- Args : [Arg {argCName = "year", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "DateTime"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_date_time_new_y" gst_date_time_new_y :: 
+    Int32 ->                                -- year : TBasicType TInt32
+    IO (Ptr DateTime)
+
+
+dateTimeNewY ::
+    (MonadIO m) =>
+    Int32                                   -- year
+    -> m DateTime                           -- result
+dateTimeNewY year = liftIO $ do
+    result <- gst_date_time_new_y year
+    checkUnexpectedReturnNULL "gst_date_time_new_y" result
+    result' <- (wrapBoxed DateTime) result
+    return result'
+
+-- method DateTime::new_ym
+-- method type : Constructor
+-- Args : [Arg {argCName = "year", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "month", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "DateTime"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_date_time_new_ym" gst_date_time_new_ym :: 
+    Int32 ->                                -- year : TBasicType TInt32
+    Int32 ->                                -- month : TBasicType TInt32
+    IO (Ptr DateTime)
+
+
+dateTimeNewYm ::
+    (MonadIO m) =>
+    Int32                                   -- year
+    -> Int32                                -- month
+    -> m DateTime                           -- result
+dateTimeNewYm year month = liftIO $ do
+    result <- gst_date_time_new_ym year month
+    checkUnexpectedReturnNULL "gst_date_time_new_ym" result
+    result' <- (wrapBoxed DateTime) result
+    return result'
+
+-- method DateTime::new_ymd
+-- method type : Constructor
+-- Args : [Arg {argCName = "year", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "month", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "day", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "DateTime"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_date_time_new_ymd" gst_date_time_new_ymd :: 
+    Int32 ->                                -- year : TBasicType TInt32
+    Int32 ->                                -- month : TBasicType TInt32
+    Int32 ->                                -- day : TBasicType TInt32
+    IO (Ptr DateTime)
+
+
+dateTimeNewYmd ::
+    (MonadIO m) =>
+    Int32                                   -- year
+    -> Int32                                -- month
+    -> Int32                                -- day
+    -> m DateTime                           -- result
+dateTimeNewYmd year month day = liftIO $ do
+    result <- gst_date_time_new_ymd year month day
+    checkUnexpectedReturnNULL "gst_date_time_new_ymd" result
+    result' <- (wrapBoxed DateTime) result
+    return result'
+
+-- method DateTime::get_day
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DateTime", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TInt32
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_date_time_get_day" gst_date_time_get_day :: 
+    Ptr DateTime ->                         -- _obj : TInterface "Gst" "DateTime"
+    IO Int32
+
+
+dateTimeGetDay ::
+    (MonadIO m) =>
+    DateTime                                -- _obj
+    -> m Int32                              -- result
+dateTimeGetDay _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_date_time_get_day _obj'
+    touchManagedPtr _obj
+    return result
+
+data DateTimeGetDayMethodInfo
+instance (signature ~ (m Int32), MonadIO m) => MethodInfo DateTimeGetDayMethodInfo DateTime signature where
+    overloadedMethod _ = dateTimeGetDay
+
+-- method DateTime::get_hour
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DateTime", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TInt32
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_date_time_get_hour" gst_date_time_get_hour :: 
+    Ptr DateTime ->                         -- _obj : TInterface "Gst" "DateTime"
+    IO Int32
+
+
+dateTimeGetHour ::
+    (MonadIO m) =>
+    DateTime                                -- _obj
+    -> m Int32                              -- result
+dateTimeGetHour _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_date_time_get_hour _obj'
+    touchManagedPtr _obj
+    return result
+
+data DateTimeGetHourMethodInfo
+instance (signature ~ (m Int32), MonadIO m) => MethodInfo DateTimeGetHourMethodInfo DateTime signature where
+    overloadedMethod _ = dateTimeGetHour
+
+-- method DateTime::get_microsecond
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DateTime", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TInt32
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_date_time_get_microsecond" gst_date_time_get_microsecond :: 
+    Ptr DateTime ->                         -- _obj : TInterface "Gst" "DateTime"
+    IO Int32
+
+
+dateTimeGetMicrosecond ::
+    (MonadIO m) =>
+    DateTime                                -- _obj
+    -> m Int32                              -- result
+dateTimeGetMicrosecond _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_date_time_get_microsecond _obj'
+    touchManagedPtr _obj
+    return result
+
+data DateTimeGetMicrosecondMethodInfo
+instance (signature ~ (m Int32), MonadIO m) => MethodInfo DateTimeGetMicrosecondMethodInfo DateTime signature where
+    overloadedMethod _ = dateTimeGetMicrosecond
+
+-- method DateTime::get_minute
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DateTime", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TInt32
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_date_time_get_minute" gst_date_time_get_minute :: 
+    Ptr DateTime ->                         -- _obj : TInterface "Gst" "DateTime"
+    IO Int32
+
+
+dateTimeGetMinute ::
+    (MonadIO m) =>
+    DateTime                                -- _obj
+    -> m Int32                              -- result
+dateTimeGetMinute _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_date_time_get_minute _obj'
+    touchManagedPtr _obj
+    return result
+
+data DateTimeGetMinuteMethodInfo
+instance (signature ~ (m Int32), MonadIO m) => MethodInfo DateTimeGetMinuteMethodInfo DateTime signature where
+    overloadedMethod _ = dateTimeGetMinute
+
+-- method DateTime::get_month
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DateTime", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TInt32
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_date_time_get_month" gst_date_time_get_month :: 
+    Ptr DateTime ->                         -- _obj : TInterface "Gst" "DateTime"
+    IO Int32
+
+
+dateTimeGetMonth ::
+    (MonadIO m) =>
+    DateTime                                -- _obj
+    -> m Int32                              -- result
+dateTimeGetMonth _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_date_time_get_month _obj'
+    touchManagedPtr _obj
+    return result
+
+data DateTimeGetMonthMethodInfo
+instance (signature ~ (m Int32), MonadIO m) => MethodInfo DateTimeGetMonthMethodInfo DateTime signature where
+    overloadedMethod _ = dateTimeGetMonth
+
+-- method DateTime::get_second
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DateTime", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TInt32
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_date_time_get_second" gst_date_time_get_second :: 
+    Ptr DateTime ->                         -- _obj : TInterface "Gst" "DateTime"
+    IO Int32
+
+
+dateTimeGetSecond ::
+    (MonadIO m) =>
+    DateTime                                -- _obj
+    -> m Int32                              -- result
+dateTimeGetSecond _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_date_time_get_second _obj'
+    touchManagedPtr _obj
+    return result
+
+data DateTimeGetSecondMethodInfo
+instance (signature ~ (m Int32), MonadIO m) => MethodInfo DateTimeGetSecondMethodInfo DateTime signature where
+    overloadedMethod _ = dateTimeGetSecond
+
+-- method DateTime::get_time_zone_offset
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DateTime", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TFloat
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_date_time_get_time_zone_offset" gst_date_time_get_time_zone_offset :: 
+    Ptr DateTime ->                         -- _obj : TInterface "Gst" "DateTime"
+    IO CFloat
+
+
+dateTimeGetTimeZoneOffset ::
+    (MonadIO m) =>
+    DateTime                                -- _obj
+    -> m Float                              -- result
+dateTimeGetTimeZoneOffset _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_date_time_get_time_zone_offset _obj'
+    let result' = realToFrac result
+    touchManagedPtr _obj
+    return result'
+
+data DateTimeGetTimeZoneOffsetMethodInfo
+instance (signature ~ (m Float), MonadIO m) => MethodInfo DateTimeGetTimeZoneOffsetMethodInfo DateTime signature where
+    overloadedMethod _ = dateTimeGetTimeZoneOffset
+
+-- method DateTime::get_year
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DateTime", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TInt32
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_date_time_get_year" gst_date_time_get_year :: 
+    Ptr DateTime ->                         -- _obj : TInterface "Gst" "DateTime"
+    IO Int32
+
+
+dateTimeGetYear ::
+    (MonadIO m) =>
+    DateTime                                -- _obj
+    -> m Int32                              -- result
+dateTimeGetYear _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_date_time_get_year _obj'
+    touchManagedPtr _obj
+    return result
+
+data DateTimeGetYearMethodInfo
+instance (signature ~ (m Int32), MonadIO m) => MethodInfo DateTimeGetYearMethodInfo DateTime signature where
+    overloadedMethod _ = dateTimeGetYear
+
+-- method DateTime::has_day
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DateTime", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_date_time_has_day" gst_date_time_has_day :: 
+    Ptr DateTime ->                         -- _obj : TInterface "Gst" "DateTime"
+    IO CInt
+
+
+dateTimeHasDay ::
+    (MonadIO m) =>
+    DateTime                                -- _obj
+    -> m Bool                               -- result
+dateTimeHasDay _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_date_time_has_day _obj'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data DateTimeHasDayMethodInfo
+instance (signature ~ (m Bool), MonadIO m) => MethodInfo DateTimeHasDayMethodInfo DateTime signature where
+    overloadedMethod _ = dateTimeHasDay
+
+-- method DateTime::has_month
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DateTime", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_date_time_has_month" gst_date_time_has_month :: 
+    Ptr DateTime ->                         -- _obj : TInterface "Gst" "DateTime"
+    IO CInt
+
+
+dateTimeHasMonth ::
+    (MonadIO m) =>
+    DateTime                                -- _obj
+    -> m Bool                               -- result
+dateTimeHasMonth _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_date_time_has_month _obj'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data DateTimeHasMonthMethodInfo
+instance (signature ~ (m Bool), MonadIO m) => MethodInfo DateTimeHasMonthMethodInfo DateTime signature where
+    overloadedMethod _ = dateTimeHasMonth
+
+-- method DateTime::has_second
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DateTime", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_date_time_has_second" gst_date_time_has_second :: 
+    Ptr DateTime ->                         -- _obj : TInterface "Gst" "DateTime"
+    IO CInt
+
+
+dateTimeHasSecond ::
+    (MonadIO m) =>
+    DateTime                                -- _obj
+    -> m Bool                               -- result
+dateTimeHasSecond _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_date_time_has_second _obj'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data DateTimeHasSecondMethodInfo
+instance (signature ~ (m Bool), MonadIO m) => MethodInfo DateTimeHasSecondMethodInfo DateTime signature where
+    overloadedMethod _ = dateTimeHasSecond
+
+-- method DateTime::has_time
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DateTime", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_date_time_has_time" gst_date_time_has_time :: 
+    Ptr DateTime ->                         -- _obj : TInterface "Gst" "DateTime"
+    IO CInt
+
+
+dateTimeHasTime ::
+    (MonadIO m) =>
+    DateTime                                -- _obj
+    -> m Bool                               -- result
+dateTimeHasTime _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_date_time_has_time _obj'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data DateTimeHasTimeMethodInfo
+instance (signature ~ (m Bool), MonadIO m) => MethodInfo DateTimeHasTimeMethodInfo DateTime signature where
+    overloadedMethod _ = dateTimeHasTime
+
+-- method DateTime::has_year
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DateTime", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_date_time_has_year" gst_date_time_has_year :: 
+    Ptr DateTime ->                         -- _obj : TInterface "Gst" "DateTime"
+    IO CInt
+
+
+dateTimeHasYear ::
+    (MonadIO m) =>
+    DateTime                                -- _obj
+    -> m Bool                               -- result
+dateTimeHasYear _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_date_time_has_year _obj'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data DateTimeHasYearMethodInfo
+instance (signature ~ (m Bool), MonadIO m) => MethodInfo DateTimeHasYearMethodInfo DateTime signature where
+    overloadedMethod _ = dateTimeHasYear
+
+-- method DateTime::ref
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DateTime", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "DateTime"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_date_time_ref" gst_date_time_ref :: 
+    Ptr DateTime ->                         -- _obj : TInterface "Gst" "DateTime"
+    IO (Ptr DateTime)
+
+
+dateTimeRef ::
+    (MonadIO m) =>
+    DateTime                                -- _obj
+    -> m DateTime                           -- result
+dateTimeRef _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_date_time_ref _obj'
+    checkUnexpectedReturnNULL "gst_date_time_ref" result
+    result' <- (wrapBoxed DateTime) result
+    touchManagedPtr _obj
+    return result'
+
+data DateTimeRefMethodInfo
+instance (signature ~ (m DateTime), MonadIO m) => MethodInfo DateTimeRefMethodInfo DateTime signature where
+    overloadedMethod _ = dateTimeRef
+
+-- method DateTime::to_g_date_time
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DateTime", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "GLib" "DateTime"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_date_time_to_g_date_time" gst_date_time_to_g_date_time :: 
+    Ptr DateTime ->                         -- _obj : TInterface "Gst" "DateTime"
+    IO (Ptr GLib.DateTime)
+
+
+dateTimeToGDateTime ::
+    (MonadIO m) =>
+    DateTime                                -- _obj
+    -> m GLib.DateTime                      -- result
+dateTimeToGDateTime _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_date_time_to_g_date_time _obj'
+    checkUnexpectedReturnNULL "gst_date_time_to_g_date_time" result
+    result' <- (wrapBoxed GLib.DateTime) result
+    touchManagedPtr _obj
+    return result'
+
+data DateTimeToGDateTimeMethodInfo
+instance (signature ~ (m GLib.DateTime), MonadIO m) => MethodInfo DateTimeToGDateTimeMethodInfo DateTime signature where
+    overloadedMethod _ = dateTimeToGDateTime
+
+-- method DateTime::to_iso8601_string
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DateTime", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUTF8
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_date_time_to_iso8601_string" gst_date_time_to_iso8601_string :: 
+    Ptr DateTime ->                         -- _obj : TInterface "Gst" "DateTime"
+    IO CString
+
+
+dateTimeToIso8601String ::
+    (MonadIO m) =>
+    DateTime                                -- _obj
+    -> m T.Text                             -- result
+dateTimeToIso8601String _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_date_time_to_iso8601_string _obj'
+    checkUnexpectedReturnNULL "gst_date_time_to_iso8601_string" result
+    result' <- cstringToText result
+    freeMem result
+    touchManagedPtr _obj
+    return result'
+
+data DateTimeToIso8601StringMethodInfo
+instance (signature ~ (m T.Text), MonadIO m) => MethodInfo DateTimeToIso8601StringMethodInfo DateTime signature where
+    overloadedMethod _ = dateTimeToIso8601String
+
+-- method DateTime::unref
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DateTime", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_date_time_unref" gst_date_time_unref :: 
+    Ptr DateTime ->                         -- _obj : TInterface "Gst" "DateTime"
+    IO ()
+
+
+dateTimeUnref ::
+    (MonadIO m) =>
+    DateTime                                -- _obj
+    -> m ()                                 -- result
+dateTimeUnref _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    gst_date_time_unref _obj'
+    touchManagedPtr _obj
+    return ()
+
+data DateTimeUnrefMethodInfo
+instance (signature ~ (m ()), MonadIO m) => MethodInfo DateTimeUnrefMethodInfo DateTime signature where
+    overloadedMethod _ = dateTimeUnref
+
+type family ResolveDateTimeMethod (t :: Symbol) (o :: *) :: * where
+    ResolveDateTimeMethod "hasDay" o = DateTimeHasDayMethodInfo
+    ResolveDateTimeMethod "hasMonth" o = DateTimeHasMonthMethodInfo
+    ResolveDateTimeMethod "hasSecond" o = DateTimeHasSecondMethodInfo
+    ResolveDateTimeMethod "hasTime" o = DateTimeHasTimeMethodInfo
+    ResolveDateTimeMethod "hasYear" o = DateTimeHasYearMethodInfo
+    ResolveDateTimeMethod "ref" o = DateTimeRefMethodInfo
+    ResolveDateTimeMethod "toGDateTime" o = DateTimeToGDateTimeMethodInfo
+    ResolveDateTimeMethod "toIso8601String" o = DateTimeToIso8601StringMethodInfo
+    ResolveDateTimeMethod "unref" o = DateTimeUnrefMethodInfo
+    ResolveDateTimeMethod "getDay" o = DateTimeGetDayMethodInfo
+    ResolveDateTimeMethod "getHour" o = DateTimeGetHourMethodInfo
+    ResolveDateTimeMethod "getMicrosecond" o = DateTimeGetMicrosecondMethodInfo
+    ResolveDateTimeMethod "getMinute" o = DateTimeGetMinuteMethodInfo
+    ResolveDateTimeMethod "getMonth" o = DateTimeGetMonthMethodInfo
+    ResolveDateTimeMethod "getSecond" o = DateTimeGetSecondMethodInfo
+    ResolveDateTimeMethod "getTimeZoneOffset" o = DateTimeGetTimeZoneOffsetMethodInfo
+    ResolveDateTimeMethod "getYear" o = DateTimeGetYearMethodInfo
+    ResolveDateTimeMethod l o = MethodResolutionFailed l o
+
+instance (info ~ ResolveDateTimeMethod t DateTime, MethodInfo info DateTime p) => IsLabelProxy t (DateTime -> p) where
+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)
+
+#if MIN_VERSION_base(4,9,0)
+instance (info ~ ResolveDateTimeMethod t DateTime, MethodInfo info DateTime p) => IsLabel t (DateTime -> p) where
+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)
+#endif
+
+
diff --git a/GI/Gst/Structs/DateTime.hs-boot b/GI/Gst/Structs/DateTime.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/DateTime.hs-boot
@@ -0,0 +1,28 @@
+module GI.Gst.Structs.DateTime where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+newtype DateTime = DateTime (ForeignPtr DateTime)
+instance BoxedObject DateTime where
+data DateTimeGetDayMethodInfo
+data DateTimeGetHourMethodInfo
+data DateTimeGetMicrosecondMethodInfo
+data DateTimeGetMinuteMethodInfo
+data DateTimeGetMonthMethodInfo
+data DateTimeGetSecondMethodInfo
+data DateTimeGetTimeZoneOffsetMethodInfo
+data DateTimeGetYearMethodInfo
+data DateTimeHasDayMethodInfo
+data DateTimeHasMonthMethodInfo
+data DateTimeHasSecondMethodInfo
+data DateTimeHasTimeMethodInfo
+data DateTimeHasYearMethodInfo
+data DateTimeRefMethodInfo
+data DateTimeToGDateTimeMethodInfo
+data DateTimeToIso8601StringMethodInfo
+data DateTimeUnrefMethodInfo
diff --git a/GI/Gst/Structs/DebugCategory.hs b/GI/Gst/Structs/DebugCategory.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/DebugCategory.hs
@@ -0,0 +1,294 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+
+This is the struct that describes the categories. Once initialized with
+#GST_DEBUG_CATEGORY_INIT, its values can't be changed anymore.
+-}
+
+module GI.Gst.Structs.DebugCategory
+    ( 
+
+-- * Exported types
+    DebugCategory(..)                       ,
+    newZeroDebugCategory                    ,
+    noDebugCategory                         ,
+
+
+ -- * Methods
+-- ** debugCategoryFree
+    DebugCategoryFreeMethodInfo             ,
+    debugCategoryFree                       ,
+
+
+-- ** debugCategoryGetColor
+    DebugCategoryGetColorMethodInfo         ,
+    debugCategoryGetColor                   ,
+
+
+-- ** debugCategoryGetDescription
+    DebugCategoryGetDescriptionMethodInfo   ,
+    debugCategoryGetDescription             ,
+
+
+-- ** debugCategoryGetName
+    DebugCategoryGetNameMethodInfo          ,
+    debugCategoryGetName                    ,
+
+
+-- ** debugCategoryGetThreshold
+    DebugCategoryGetThresholdMethodInfo     ,
+    debugCategoryGetThreshold               ,
+
+
+-- ** debugCategoryResetThreshold
+    DebugCategoryResetThresholdMethodInfo   ,
+    debugCategoryResetThreshold             ,
+
+
+-- ** debugCategorySetThreshold
+    DebugCategorySetThresholdMethodInfo     ,
+    debugCategorySetThreshold               ,
+
+
+
+
+    ) where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+import GI.Gst.Callbacks
+
+newtype DebugCategory = DebugCategory (ForeignPtr DebugCategory)
+-- | Construct a `DebugCategory` struct initialized to zero.
+newZeroDebugCategory :: MonadIO m => m DebugCategory
+newZeroDebugCategory = liftIO $ callocBytes 24 >>= wrapPtr DebugCategory
+
+noDebugCategory :: Maybe DebugCategory
+noDebugCategory = Nothing
+
+-- method DebugCategory::free
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DebugCategory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_debug_category_free" gst_debug_category_free :: 
+    Ptr DebugCategory ->                    -- _obj : TInterface "Gst" "DebugCategory"
+    IO ()
+
+
+debugCategoryFree ::
+    (MonadIO m) =>
+    DebugCategory                           -- _obj
+    -> m ()                                 -- result
+debugCategoryFree _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    gst_debug_category_free _obj'
+    touchManagedPtr _obj
+    return ()
+
+data DebugCategoryFreeMethodInfo
+instance (signature ~ (m ()), MonadIO m) => MethodInfo DebugCategoryFreeMethodInfo DebugCategory signature where
+    overloadedMethod _ = debugCategoryFree
+
+-- method DebugCategory::get_color
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DebugCategory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUInt32
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_debug_category_get_color" gst_debug_category_get_color :: 
+    Ptr DebugCategory ->                    -- _obj : TInterface "Gst" "DebugCategory"
+    IO Word32
+
+
+debugCategoryGetColor ::
+    (MonadIO m) =>
+    DebugCategory                           -- _obj
+    -> m Word32                             -- result
+debugCategoryGetColor _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_debug_category_get_color _obj'
+    touchManagedPtr _obj
+    return result
+
+data DebugCategoryGetColorMethodInfo
+instance (signature ~ (m Word32), MonadIO m) => MethodInfo DebugCategoryGetColorMethodInfo DebugCategory signature where
+    overloadedMethod _ = debugCategoryGetColor
+
+-- method DebugCategory::get_description
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DebugCategory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUTF8
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_debug_category_get_description" gst_debug_category_get_description :: 
+    Ptr DebugCategory ->                    -- _obj : TInterface "Gst" "DebugCategory"
+    IO CString
+
+
+debugCategoryGetDescription ::
+    (MonadIO m) =>
+    DebugCategory                           -- _obj
+    -> m T.Text                             -- result
+debugCategoryGetDescription _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_debug_category_get_description _obj'
+    checkUnexpectedReturnNULL "gst_debug_category_get_description" result
+    result' <- cstringToText result
+    touchManagedPtr _obj
+    return result'
+
+data DebugCategoryGetDescriptionMethodInfo
+instance (signature ~ (m T.Text), MonadIO m) => MethodInfo DebugCategoryGetDescriptionMethodInfo DebugCategory signature where
+    overloadedMethod _ = debugCategoryGetDescription
+
+-- method DebugCategory::get_name
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DebugCategory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUTF8
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_debug_category_get_name" gst_debug_category_get_name :: 
+    Ptr DebugCategory ->                    -- _obj : TInterface "Gst" "DebugCategory"
+    IO CString
+
+
+debugCategoryGetName ::
+    (MonadIO m) =>
+    DebugCategory                           -- _obj
+    -> m T.Text                             -- result
+debugCategoryGetName _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_debug_category_get_name _obj'
+    checkUnexpectedReturnNULL "gst_debug_category_get_name" result
+    result' <- cstringToText result
+    touchManagedPtr _obj
+    return result'
+
+data DebugCategoryGetNameMethodInfo
+instance (signature ~ (m T.Text), MonadIO m) => MethodInfo DebugCategoryGetNameMethodInfo DebugCategory signature where
+    overloadedMethod _ = debugCategoryGetName
+
+-- method DebugCategory::get_threshold
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DebugCategory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "DebugLevel"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_debug_category_get_threshold" gst_debug_category_get_threshold :: 
+    Ptr DebugCategory ->                    -- _obj : TInterface "Gst" "DebugCategory"
+    IO CUInt
+
+
+debugCategoryGetThreshold ::
+    (MonadIO m) =>
+    DebugCategory                           -- _obj
+    -> m DebugLevel                         -- result
+debugCategoryGetThreshold _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_debug_category_get_threshold _obj'
+    let result' = (toEnum . fromIntegral) result
+    touchManagedPtr _obj
+    return result'
+
+data DebugCategoryGetThresholdMethodInfo
+instance (signature ~ (m DebugLevel), MonadIO m) => MethodInfo DebugCategoryGetThresholdMethodInfo DebugCategory signature where
+    overloadedMethod _ = debugCategoryGetThreshold
+
+-- method DebugCategory::reset_threshold
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DebugCategory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_debug_category_reset_threshold" gst_debug_category_reset_threshold :: 
+    Ptr DebugCategory ->                    -- _obj : TInterface "Gst" "DebugCategory"
+    IO ()
+
+
+debugCategoryResetThreshold ::
+    (MonadIO m) =>
+    DebugCategory                           -- _obj
+    -> m ()                                 -- result
+debugCategoryResetThreshold _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    gst_debug_category_reset_threshold _obj'
+    touchManagedPtr _obj
+    return ()
+
+data DebugCategoryResetThresholdMethodInfo
+instance (signature ~ (m ()), MonadIO m) => MethodInfo DebugCategoryResetThresholdMethodInfo DebugCategory signature where
+    overloadedMethod _ = debugCategoryResetThreshold
+
+-- method DebugCategory::set_threshold
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DebugCategory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "level", argType = TInterface "Gst" "DebugLevel", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_debug_category_set_threshold" gst_debug_category_set_threshold :: 
+    Ptr DebugCategory ->                    -- _obj : TInterface "Gst" "DebugCategory"
+    CUInt ->                                -- level : TInterface "Gst" "DebugLevel"
+    IO ()
+
+
+debugCategorySetThreshold ::
+    (MonadIO m) =>
+    DebugCategory                           -- _obj
+    -> DebugLevel                           -- level
+    -> m ()                                 -- result
+debugCategorySetThreshold _obj level = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let level' = (fromIntegral . fromEnum) level
+    gst_debug_category_set_threshold _obj' level'
+    touchManagedPtr _obj
+    return ()
+
+data DebugCategorySetThresholdMethodInfo
+instance (signature ~ (DebugLevel -> m ()), MonadIO m) => MethodInfo DebugCategorySetThresholdMethodInfo DebugCategory signature where
+    overloadedMethod _ = debugCategorySetThreshold
+
+type family ResolveDebugCategoryMethod (t :: Symbol) (o :: *) :: * where
+    ResolveDebugCategoryMethod "free" o = DebugCategoryFreeMethodInfo
+    ResolveDebugCategoryMethod "resetThreshold" o = DebugCategoryResetThresholdMethodInfo
+    ResolveDebugCategoryMethod "getColor" o = DebugCategoryGetColorMethodInfo
+    ResolveDebugCategoryMethod "getDescription" o = DebugCategoryGetDescriptionMethodInfo
+    ResolveDebugCategoryMethod "getName" o = DebugCategoryGetNameMethodInfo
+    ResolveDebugCategoryMethod "getThreshold" o = DebugCategoryGetThresholdMethodInfo
+    ResolveDebugCategoryMethod "setThreshold" o = DebugCategorySetThresholdMethodInfo
+    ResolveDebugCategoryMethod l o = MethodResolutionFailed l o
+
+instance (info ~ ResolveDebugCategoryMethod t DebugCategory, MethodInfo info DebugCategory p) => IsLabelProxy t (DebugCategory -> p) where
+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)
+
+#if MIN_VERSION_base(4,9,0)
+instance (info ~ ResolveDebugCategoryMethod t DebugCategory, MethodInfo info DebugCategory p) => IsLabel t (DebugCategory -> p) where
+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)
+#endif
+
+
diff --git a/GI/Gst/Structs/DebugCategory.hs-boot b/GI/Gst/Structs/DebugCategory.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/DebugCategory.hs-boot
@@ -0,0 +1,17 @@
+module GI.Gst.Structs.DebugCategory where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+newtype DebugCategory = DebugCategory (ForeignPtr DebugCategory)
+data DebugCategoryFreeMethodInfo
+data DebugCategoryGetColorMethodInfo
+data DebugCategoryGetDescriptionMethodInfo
+data DebugCategoryGetNameMethodInfo
+data DebugCategoryGetThresholdMethodInfo
+data DebugCategoryResetThresholdMethodInfo
+data DebugCategorySetThresholdMethodInfo
diff --git a/GI/Gst/Structs/DebugMessage.hs b/GI/Gst/Structs/DebugMessage.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/DebugMessage.hs
@@ -0,0 +1,82 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+-}
+
+module GI.Gst.Structs.DebugMessage
+    ( 
+
+-- * Exported types
+    DebugMessage(..)                        ,
+    noDebugMessage                          ,
+
+
+ -- * Methods
+-- ** debugMessageGet
+    DebugMessageGetMethodInfo               ,
+    debugMessageGet                         ,
+
+
+
+
+    ) where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+import GI.Gst.Callbacks
+
+newtype DebugMessage = DebugMessage (ForeignPtr DebugMessage)
+noDebugMessage :: Maybe DebugMessage
+noDebugMessage = Nothing
+
+-- method DebugMessage::get
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "DebugMessage", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUTF8
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_debug_message_get" gst_debug_message_get :: 
+    Ptr DebugMessage ->                     -- _obj : TInterface "Gst" "DebugMessage"
+    IO CString
+
+
+debugMessageGet ::
+    (MonadIO m) =>
+    DebugMessage                            -- _obj
+    -> m T.Text                             -- result
+debugMessageGet _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_debug_message_get _obj'
+    checkUnexpectedReturnNULL "gst_debug_message_get" result
+    result' <- cstringToText result
+    touchManagedPtr _obj
+    return result'
+
+data DebugMessageGetMethodInfo
+instance (signature ~ (m T.Text), MonadIO m) => MethodInfo DebugMessageGetMethodInfo DebugMessage signature where
+    overloadedMethod _ = debugMessageGet
+
+type family ResolveDebugMessageMethod (t :: Symbol) (o :: *) :: * where
+    ResolveDebugMessageMethod "get" o = DebugMessageGetMethodInfo
+    ResolveDebugMessageMethod l o = MethodResolutionFailed l o
+
+instance (info ~ ResolveDebugMessageMethod t DebugMessage, MethodInfo info DebugMessage p) => IsLabelProxy t (DebugMessage -> p) where
+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)
+
+#if MIN_VERSION_base(4,9,0)
+instance (info ~ ResolveDebugMessageMethod t DebugMessage, MethodInfo info DebugMessage p) => IsLabel t (DebugMessage -> p) where
+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)
+#endif
+
+
diff --git a/GI/Gst/Structs/DebugMessage.hs-boot b/GI/Gst/Structs/DebugMessage.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/DebugMessage.hs-boot
@@ -0,0 +1,11 @@
+module GI.Gst.Structs.DebugMessage where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+newtype DebugMessage = DebugMessage (ForeignPtr DebugMessage)
+data DebugMessageGetMethodInfo
diff --git a/GI/Gst/Structs/Event.hs b/GI/Gst/Structs/Event.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/Event.hs
@@ -0,0 +1,1915 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+
+The event class provides factory methods to construct events for sending
+and functions to query (parse) received events.
+
+Events are usually created with gst_event_new_*() which takes event-type
+specific parameters as arguments.
+To send an event application will usually use gst_element_send_event() and
+elements will use gst_pad_send_event() or gst_pad_push_event().
+The event should be unreffed with gst_event_unref() if it has not been sent.
+
+Events that have been received can be parsed with their respective
+gst_event_parse_*() functions. It is valid to pass %NULL for unwanted details.
+
+Events are passed between elements in parallel to the data stream. Some events
+are serialized with buffers, others are not. Some events only travel downstream,
+others only upstream. Some events can travel both upstream and downstream.
+
+The events are used to signal special conditions in the datastream such as
+EOS (end of stream) or the start of a new stream-segment.
+Events are also used to flush the pipeline of any pending data.
+
+Most of the event API is used inside plugins. Applications usually only
+construct and use seek events.
+To do that gst_event_new_seek() is used to create a seek event. It takes
+the needed parameters to specify seeking time and mode.
+|[
+  GstEvent *event;
+  gboolean result;
+  ...
+  // construct a seek event to play the media from second 2 to 5, flush
+  // the pipeline to decrease latency.
+  event = gst_event_new_seek (1.0,
+     GST_FORMAT_TIME,
+     GST_SEEK_FLAG_FLUSH,
+     GST_SEEK_TYPE_SET, 2 * GST_SECOND,
+     GST_SEEK_TYPE_SET, 5 * GST_SECOND);
+  ...
+  result = gst_element_send_event (pipeline, event);
+  if (!result)
+    g_warning ("seek failed");
+  ...
+]|
+-}
+
+module GI.Gst.Structs.Event
+    ( 
+
+-- * Exported types
+    Event(..)                               ,
+    newZeroEvent                            ,
+    noEvent                                 ,
+
+
+ -- * Methods
+-- ** eventCopySegment
+    EventCopySegmentMethodInfo              ,
+    eventCopySegment                        ,
+
+
+-- ** eventGetRunningTimeOffset
+    EventGetRunningTimeOffsetMethodInfo     ,
+    eventGetRunningTimeOffset               ,
+
+
+-- ** eventGetSeqnum
+    EventGetSeqnumMethodInfo                ,
+    eventGetSeqnum                          ,
+
+
+-- ** eventGetStructure
+    EventGetStructureMethodInfo             ,
+    eventGetStructure                       ,
+
+
+-- ** eventHasName
+    EventHasNameMethodInfo                  ,
+    eventHasName                            ,
+
+
+-- ** eventNewBufferSize
+    eventNewBufferSize                      ,
+
+
+-- ** eventNewCaps
+    eventNewCaps                            ,
+
+
+-- ** eventNewCustom
+    eventNewCustom                          ,
+
+
+-- ** eventNewEos
+    eventNewEos                             ,
+
+
+-- ** eventNewFlushStart
+    eventNewFlushStart                      ,
+
+
+-- ** eventNewFlushStop
+    eventNewFlushStop                       ,
+
+
+-- ** eventNewGap
+    eventNewGap                             ,
+
+
+-- ** eventNewLatency
+    eventNewLatency                         ,
+
+
+-- ** eventNewNavigation
+    eventNewNavigation                      ,
+
+
+-- ** eventNewProtection
+    eventNewProtection                      ,
+
+
+-- ** eventNewQos
+    eventNewQos                             ,
+
+
+-- ** eventNewReconfigure
+    eventNewReconfigure                     ,
+
+
+-- ** eventNewSeek
+    eventNewSeek                            ,
+
+
+-- ** eventNewSegment
+    eventNewSegment                         ,
+
+
+-- ** eventNewSegmentDone
+    eventNewSegmentDone                     ,
+
+
+-- ** eventNewSinkMessage
+    eventNewSinkMessage                     ,
+
+
+-- ** eventNewStep
+    eventNewStep                            ,
+
+
+-- ** eventNewStreamStart
+    eventNewStreamStart                     ,
+
+
+-- ** eventNewTag
+    eventNewTag                             ,
+
+
+-- ** eventNewToc
+    eventNewToc                             ,
+
+
+-- ** eventNewTocSelect
+    eventNewTocSelect                       ,
+
+
+-- ** eventParseBufferSize
+    EventParseBufferSizeMethodInfo          ,
+    eventParseBufferSize                    ,
+
+
+-- ** eventParseCaps
+    EventParseCapsMethodInfo                ,
+    eventParseCaps                          ,
+
+
+-- ** eventParseFlushStop
+    EventParseFlushStopMethodInfo           ,
+    eventParseFlushStop                     ,
+
+
+-- ** eventParseGap
+    EventParseGapMethodInfo                 ,
+    eventParseGap                           ,
+
+
+-- ** eventParseGroupId
+    EventParseGroupIdMethodInfo             ,
+    eventParseGroupId                       ,
+
+
+-- ** eventParseLatency
+    EventParseLatencyMethodInfo             ,
+    eventParseLatency                       ,
+
+
+-- ** eventParseProtection
+    EventParseProtectionMethodInfo          ,
+    eventParseProtection                    ,
+
+
+-- ** eventParseQos
+    EventParseQosMethodInfo                 ,
+    eventParseQos                           ,
+
+
+-- ** eventParseSeek
+    EventParseSeekMethodInfo                ,
+    eventParseSeek                          ,
+
+
+-- ** eventParseSegment
+    EventParseSegmentMethodInfo             ,
+    eventParseSegment                       ,
+
+
+-- ** eventParseSegmentDone
+    EventParseSegmentDoneMethodInfo         ,
+    eventParseSegmentDone                   ,
+
+
+-- ** eventParseSinkMessage
+    EventParseSinkMessageMethodInfo         ,
+    eventParseSinkMessage                   ,
+
+
+-- ** eventParseStep
+    EventParseStepMethodInfo                ,
+    eventParseStep                          ,
+
+
+-- ** eventParseStreamFlags
+    EventParseStreamFlagsMethodInfo         ,
+    eventParseStreamFlags                   ,
+
+
+-- ** eventParseStreamStart
+    EventParseStreamStartMethodInfo         ,
+    eventParseStreamStart                   ,
+
+
+-- ** eventParseTag
+    EventParseTagMethodInfo                 ,
+    eventParseTag                           ,
+
+
+-- ** eventParseToc
+    EventParseTocMethodInfo                 ,
+    eventParseToc                           ,
+
+
+-- ** eventParseTocSelect
+    EventParseTocSelectMethodInfo           ,
+    eventParseTocSelect                     ,
+
+
+-- ** eventSetGroupId
+    EventSetGroupIdMethodInfo               ,
+    eventSetGroupId                         ,
+
+
+-- ** eventSetRunningTimeOffset
+    EventSetRunningTimeOffsetMethodInfo     ,
+    eventSetRunningTimeOffset               ,
+
+
+-- ** eventSetSeqnum
+    EventSetSeqnumMethodInfo                ,
+    eventSetSeqnum                          ,
+
+
+-- ** eventSetStreamFlags
+    EventSetStreamFlagsMethodInfo           ,
+    eventSetStreamFlags                     ,
+
+
+-- ** eventWritableStructure
+    EventWritableStructureMethodInfo        ,
+    eventWritableStructure                  ,
+
+
+
+
+ -- * Properties
+-- ** MiniObject
+    eventReadMiniObject                     ,
+
+
+-- ** Seqnum
+    eventReadSeqnum                         ,
+
+
+-- ** Timestamp
+    eventReadTimestamp                      ,
+
+
+-- ** Type
+    eventReadType                           ,
+
+
+
+
+    ) where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+import GI.Gst.Callbacks
+
+newtype Event = Event (ForeignPtr Event)
+foreign import ccall "gst_event_get_type" c_gst_event_get_type :: 
+    IO GType
+
+instance BoxedObject Event where
+    boxedType _ = c_gst_event_get_type
+
+-- | Construct a `Event` struct initialized to zero.
+newZeroEvent :: MonadIO m => m Event
+newZeroEvent = liftIO $ callocBoxedBytes 88 >>= wrapBoxed Event
+
+noEvent :: Maybe Event
+noEvent = Nothing
+
+eventReadMiniObject :: Event -> IO MiniObject
+eventReadMiniObject s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 0) :: IO (Ptr MiniObject)
+    val' <- (newPtr 64 MiniObject) val
+    return val'
+
+eventReadType :: Event -> IO EventType
+eventReadType s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 64) :: IO CUInt
+    let val' = (toEnum . fromIntegral) val
+    return val'
+
+eventReadTimestamp :: Event -> IO Word64
+eventReadTimestamp s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 72) :: IO Word64
+    return val
+
+eventReadSeqnum :: Event -> IO Word32
+eventReadSeqnum s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 80) :: IO Word32
+    return val
+
+-- method Event::new_buffer_size
+-- method type : Constructor
+-- Args : [Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "minsize", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "maxsize", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "async", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Event"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_event_new_buffer_size" gst_event_new_buffer_size :: 
+    CUInt ->                                -- format : TInterface "Gst" "Format"
+    Int64 ->                                -- minsize : TBasicType TInt64
+    Int64 ->                                -- maxsize : TBasicType TInt64
+    CInt ->                                 -- async : TBasicType TBoolean
+    IO (Ptr Event)
+
+
+eventNewBufferSize ::
+    (MonadIO m) =>
+    Format                                  -- format
+    -> Int64                                -- minsize
+    -> Int64                                -- maxsize
+    -> Bool                                 -- async
+    -> m Event                              -- result
+eventNewBufferSize format minsize maxsize async = liftIO $ do
+    let format' = (fromIntegral . fromEnum) format
+    let async' = (fromIntegral . fromEnum) async
+    result <- gst_event_new_buffer_size format' minsize maxsize async'
+    checkUnexpectedReturnNULL "gst_event_new_buffer_size" result
+    result' <- (wrapBoxed Event) result
+    return result'
+
+-- method Event::new_caps
+-- method type : Constructor
+-- Args : [Arg {argCName = "caps", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Event"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_event_new_caps" gst_event_new_caps :: 
+    Ptr Caps ->                             -- caps : TInterface "Gst" "Caps"
+    IO (Ptr Event)
+
+
+eventNewCaps ::
+    (MonadIO m) =>
+    Caps                                    -- caps
+    -> m Event                              -- result
+eventNewCaps caps = liftIO $ do
+    let caps' = unsafeManagedPtrGetPtr caps
+    result <- gst_event_new_caps caps'
+    checkUnexpectedReturnNULL "gst_event_new_caps" result
+    result' <- (wrapBoxed Event) result
+    touchManagedPtr caps
+    return result'
+
+-- method Event::new_custom
+-- method type : Constructor
+-- Args : [Arg {argCName = "type", argType = TInterface "Gst" "EventType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "structure", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Event"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_event_new_custom" gst_event_new_custom :: 
+    CUInt ->                                -- type : TInterface "Gst" "EventType"
+    Ptr Structure ->                        -- structure : TInterface "Gst" "Structure"
+    IO (Ptr Event)
+
+
+eventNewCustom ::
+    (MonadIO m) =>
+    EventType                               -- type_
+    -> Structure                            -- structure
+    -> m Event                              -- result
+eventNewCustom type_ structure = liftIO $ do
+    let type_' = (fromIntegral . fromEnum) type_
+    structure' <- copyBoxed structure
+    result <- gst_event_new_custom type_' structure'
+    checkUnexpectedReturnNULL "gst_event_new_custom" result
+    result' <- (wrapBoxed Event) result
+    touchManagedPtr structure
+    return result'
+
+-- method Event::new_eos
+-- method type : Constructor
+-- Args : []
+-- Lengths : []
+-- returnType : TInterface "Gst" "Event"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_event_new_eos" gst_event_new_eos :: 
+    IO (Ptr Event)
+
+
+eventNewEos ::
+    (MonadIO m) =>
+    m Event                                 -- result
+eventNewEos  = liftIO $ do
+    result <- gst_event_new_eos
+    checkUnexpectedReturnNULL "gst_event_new_eos" result
+    result' <- (wrapBoxed Event) result
+    return result'
+
+-- method Event::new_flush_start
+-- method type : Constructor
+-- Args : []
+-- Lengths : []
+-- returnType : TInterface "Gst" "Event"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_event_new_flush_start" gst_event_new_flush_start :: 
+    IO (Ptr Event)
+
+
+eventNewFlushStart ::
+    (MonadIO m) =>
+    m Event                                 -- result
+eventNewFlushStart  = liftIO $ do
+    result <- gst_event_new_flush_start
+    checkUnexpectedReturnNULL "gst_event_new_flush_start" result
+    result' <- (wrapBoxed Event) result
+    return result'
+
+-- method Event::new_flush_stop
+-- method type : Constructor
+-- Args : [Arg {argCName = "reset_time", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Event"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_event_new_flush_stop" gst_event_new_flush_stop :: 
+    CInt ->                                 -- reset_time : TBasicType TBoolean
+    IO (Ptr Event)
+
+
+eventNewFlushStop ::
+    (MonadIO m) =>
+    Bool                                    -- resetTime
+    -> m Event                              -- result
+eventNewFlushStop resetTime = liftIO $ do
+    let resetTime' = (fromIntegral . fromEnum) resetTime
+    result <- gst_event_new_flush_stop resetTime'
+    checkUnexpectedReturnNULL "gst_event_new_flush_stop" result
+    result' <- (wrapBoxed Event) result
+    return result'
+
+-- method Event::new_gap
+-- method type : Constructor
+-- Args : [Arg {argCName = "timestamp", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "duration", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Event"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_event_new_gap" gst_event_new_gap :: 
+    Word64 ->                               -- timestamp : TBasicType TUInt64
+    Word64 ->                               -- duration : TBasicType TUInt64
+    IO (Ptr Event)
+
+
+eventNewGap ::
+    (MonadIO m) =>
+    Word64                                  -- timestamp
+    -> Word64                               -- duration
+    -> m Event                              -- result
+eventNewGap timestamp duration = liftIO $ do
+    result <- gst_event_new_gap timestamp duration
+    checkUnexpectedReturnNULL "gst_event_new_gap" result
+    result' <- (wrapBoxed Event) result
+    return result'
+
+-- method Event::new_latency
+-- method type : Constructor
+-- Args : [Arg {argCName = "latency", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Event"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_event_new_latency" gst_event_new_latency :: 
+    Word64 ->                               -- latency : TBasicType TUInt64
+    IO (Ptr Event)
+
+
+eventNewLatency ::
+    (MonadIO m) =>
+    Word64                                  -- latency
+    -> m Event                              -- result
+eventNewLatency latency = liftIO $ do
+    result <- gst_event_new_latency latency
+    checkUnexpectedReturnNULL "gst_event_new_latency" result
+    result' <- (wrapBoxed Event) result
+    return result'
+
+-- method Event::new_navigation
+-- method type : Constructor
+-- Args : [Arg {argCName = "structure", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Event"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_event_new_navigation" gst_event_new_navigation :: 
+    Ptr Structure ->                        -- structure : TInterface "Gst" "Structure"
+    IO (Ptr Event)
+
+
+eventNewNavigation ::
+    (MonadIO m) =>
+    Structure                               -- structure
+    -> m Event                              -- result
+eventNewNavigation structure = liftIO $ do
+    structure' <- copyBoxed structure
+    result <- gst_event_new_navigation structure'
+    checkUnexpectedReturnNULL "gst_event_new_navigation" result
+    result' <- (wrapBoxed Event) result
+    touchManagedPtr structure
+    return result'
+
+-- method Event::new_protection
+-- method type : Constructor
+-- Args : [Arg {argCName = "system_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "origin", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Event"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_event_new_protection" gst_event_new_protection :: 
+    CString ->                              -- system_id : TBasicType TUTF8
+    Ptr Buffer ->                           -- data : TInterface "Gst" "Buffer"
+    CString ->                              -- origin : TBasicType TUTF8
+    IO (Ptr Event)
+
+
+eventNewProtection ::
+    (MonadIO m) =>
+    T.Text                                  -- systemId
+    -> Buffer                               -- data_
+    -> T.Text                               -- origin
+    -> m Event                              -- result
+eventNewProtection systemId data_ origin = liftIO $ do
+    systemId' <- textToCString systemId
+    let data_' = unsafeManagedPtrGetPtr data_
+    origin' <- textToCString origin
+    result <- gst_event_new_protection systemId' data_' origin'
+    checkUnexpectedReturnNULL "gst_event_new_protection" result
+    result' <- (wrapBoxed Event) result
+    touchManagedPtr data_
+    freeMem systemId'
+    freeMem origin'
+    return result'
+
+-- method Event::new_qos
+-- method type : Constructor
+-- Args : [Arg {argCName = "type", argType = TInterface "Gst" "QOSType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "proportion", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "diff", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "timestamp", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Event"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_event_new_qos" gst_event_new_qos :: 
+    CUInt ->                                -- type : TInterface "Gst" "QOSType"
+    CDouble ->                              -- proportion : TBasicType TDouble
+    Int64 ->                                -- diff : TBasicType TInt64
+    Word64 ->                               -- timestamp : TBasicType TUInt64
+    IO (Ptr Event)
+
+
+eventNewQos ::
+    (MonadIO m) =>
+    QOSType                                 -- type_
+    -> Double                               -- proportion
+    -> Int64                                -- diff
+    -> Word64                               -- timestamp
+    -> m Event                              -- result
+eventNewQos type_ proportion diff timestamp = liftIO $ do
+    let type_' = (fromIntegral . fromEnum) type_
+    let proportion' = realToFrac proportion
+    result <- gst_event_new_qos type_' proportion' diff timestamp
+    checkUnexpectedReturnNULL "gst_event_new_qos" result
+    result' <- (wrapBoxed Event) result
+    return result'
+
+-- method Event::new_reconfigure
+-- method type : Constructor
+-- Args : []
+-- Lengths : []
+-- returnType : TInterface "Gst" "Event"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_event_new_reconfigure" gst_event_new_reconfigure :: 
+    IO (Ptr Event)
+
+
+eventNewReconfigure ::
+    (MonadIO m) =>
+    m Event                                 -- result
+eventNewReconfigure  = liftIO $ do
+    result <- gst_event_new_reconfigure
+    checkUnexpectedReturnNULL "gst_event_new_reconfigure" result
+    result' <- (wrapBoxed Event) result
+    return result'
+
+-- method Event::new_seek
+-- method type : Constructor
+-- Args : [Arg {argCName = "rate", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface "Gst" "SeekFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start_type", argType = TInterface "Gst" "SeekType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stop_type", argType = TInterface "Gst" "SeekType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stop", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Event"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_event_new_seek" gst_event_new_seek :: 
+    CDouble ->                              -- rate : TBasicType TDouble
+    CUInt ->                                -- format : TInterface "Gst" "Format"
+    CUInt ->                                -- flags : TInterface "Gst" "SeekFlags"
+    CUInt ->                                -- start_type : TInterface "Gst" "SeekType"
+    Int64 ->                                -- start : TBasicType TInt64
+    CUInt ->                                -- stop_type : TInterface "Gst" "SeekType"
+    Int64 ->                                -- stop : TBasicType TInt64
+    IO (Ptr Event)
+
+
+eventNewSeek ::
+    (MonadIO m) =>
+    Double                                  -- rate
+    -> Format                               -- format
+    -> [SeekFlags]                          -- flags
+    -> SeekType                             -- startType
+    -> Int64                                -- start
+    -> SeekType                             -- stopType
+    -> Int64                                -- stop
+    -> m Event                              -- result
+eventNewSeek rate format flags startType start stopType stop = liftIO $ do
+    let rate' = realToFrac rate
+    let format' = (fromIntegral . fromEnum) format
+    let flags' = gflagsToWord flags
+    let startType' = (fromIntegral . fromEnum) startType
+    let stopType' = (fromIntegral . fromEnum) stopType
+    result <- gst_event_new_seek rate' format' flags' startType' start stopType' stop
+    checkUnexpectedReturnNULL "gst_event_new_seek" result
+    result' <- (wrapBoxed Event) result
+    return result'
+
+-- method Event::new_segment
+-- method type : Constructor
+-- Args : [Arg {argCName = "segment", argType = TInterface "Gst" "Segment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Event"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_event_new_segment" gst_event_new_segment :: 
+    Ptr Segment ->                          -- segment : TInterface "Gst" "Segment"
+    IO (Ptr Event)
+
+
+eventNewSegment ::
+    (MonadIO m) =>
+    Segment                                 -- segment
+    -> m Event                              -- result
+eventNewSegment segment = liftIO $ do
+    let segment' = unsafeManagedPtrGetPtr segment
+    result <- gst_event_new_segment segment'
+    checkUnexpectedReturnNULL "gst_event_new_segment" result
+    result' <- (wrapBoxed Event) result
+    touchManagedPtr segment
+    return result'
+
+-- method Event::new_segment_done
+-- method type : Constructor
+-- Args : [Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "position", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Event"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_event_new_segment_done" gst_event_new_segment_done :: 
+    CUInt ->                                -- format : TInterface "Gst" "Format"
+    Int64 ->                                -- position : TBasicType TInt64
+    IO (Ptr Event)
+
+
+eventNewSegmentDone ::
+    (MonadIO m) =>
+    Format                                  -- format
+    -> Int64                                -- position
+    -> m Event                              -- result
+eventNewSegmentDone format position = liftIO $ do
+    let format' = (fromIntegral . fromEnum) format
+    result <- gst_event_new_segment_done format' position
+    checkUnexpectedReturnNULL "gst_event_new_segment_done" result
+    result' <- (wrapBoxed Event) result
+    return result'
+
+-- method Event::new_sink_message
+-- method type : Constructor
+-- Args : [Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "msg", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Event"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_event_new_sink_message" gst_event_new_sink_message :: 
+    CString ->                              -- name : TBasicType TUTF8
+    Ptr Message ->                          -- msg : TInterface "Gst" "Message"
+    IO (Ptr Event)
+
+
+eventNewSinkMessage ::
+    (MonadIO m) =>
+    T.Text                                  -- name
+    -> Message                              -- msg
+    -> m Event                              -- result
+eventNewSinkMessage name msg = liftIO $ do
+    name' <- textToCString name
+    let msg' = unsafeManagedPtrGetPtr msg
+    result <- gst_event_new_sink_message name' msg'
+    checkUnexpectedReturnNULL "gst_event_new_sink_message" result
+    result' <- (wrapBoxed Event) result
+    touchManagedPtr msg
+    freeMem name'
+    return result'
+
+-- method Event::new_step
+-- method type : Constructor
+-- Args : [Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "amount", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "rate", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flush", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "intermediate", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Event"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_event_new_step" gst_event_new_step :: 
+    CUInt ->                                -- format : TInterface "Gst" "Format"
+    Word64 ->                               -- amount : TBasicType TUInt64
+    CDouble ->                              -- rate : TBasicType TDouble
+    CInt ->                                 -- flush : TBasicType TBoolean
+    CInt ->                                 -- intermediate : TBasicType TBoolean
+    IO (Ptr Event)
+
+
+eventNewStep ::
+    (MonadIO m) =>
+    Format                                  -- format
+    -> Word64                               -- amount
+    -> Double                               -- rate
+    -> Bool                                 -- flush
+    -> Bool                                 -- intermediate
+    -> m Event                              -- result
+eventNewStep format amount rate flush intermediate = liftIO $ do
+    let format' = (fromIntegral . fromEnum) format
+    let rate' = realToFrac rate
+    let flush' = (fromIntegral . fromEnum) flush
+    let intermediate' = (fromIntegral . fromEnum) intermediate
+    result <- gst_event_new_step format' amount rate' flush' intermediate'
+    checkUnexpectedReturnNULL "gst_event_new_step" result
+    result' <- (wrapBoxed Event) result
+    return result'
+
+-- method Event::new_stream_start
+-- method type : Constructor
+-- Args : [Arg {argCName = "stream_id", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Event"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_event_new_stream_start" gst_event_new_stream_start :: 
+    CString ->                              -- stream_id : TBasicType TUTF8
+    IO (Ptr Event)
+
+
+eventNewStreamStart ::
+    (MonadIO m) =>
+    T.Text                                  -- streamId
+    -> m Event                              -- result
+eventNewStreamStart streamId = liftIO $ do
+    streamId' <- textToCString streamId
+    result <- gst_event_new_stream_start streamId'
+    checkUnexpectedReturnNULL "gst_event_new_stream_start" result
+    result' <- (wrapBoxed Event) result
+    freeMem streamId'
+    return result'
+
+-- method Event::new_tag
+-- method type : Constructor
+-- Args : [Arg {argCName = "taglist", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Event"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_event_new_tag" gst_event_new_tag :: 
+    Ptr TagList ->                          -- taglist : TInterface "Gst" "TagList"
+    IO (Ptr Event)
+
+
+eventNewTag ::
+    (MonadIO m) =>
+    TagList                                 -- taglist
+    -> m Event                              -- result
+eventNewTag taglist = liftIO $ do
+    taglist' <- copyBoxed taglist
+    result <- gst_event_new_tag taglist'
+    checkUnexpectedReturnNULL "gst_event_new_tag" result
+    result' <- (wrapBoxed Event) result
+    touchManagedPtr taglist
+    return result'
+
+-- method Event::new_toc
+-- method type : Constructor
+-- Args : [Arg {argCName = "toc", argType = TInterface "Gst" "Toc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "updated", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Event"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_event_new_toc" gst_event_new_toc :: 
+    Ptr Toc ->                              -- toc : TInterface "Gst" "Toc"
+    CInt ->                                 -- updated : TBasicType TBoolean
+    IO (Ptr Event)
+
+
+eventNewToc ::
+    (MonadIO m) =>
+    Toc                                     -- toc
+    -> Bool                                 -- updated
+    -> m Event                              -- result
+eventNewToc toc updated = liftIO $ do
+    let toc' = unsafeManagedPtrGetPtr toc
+    let updated' = (fromIntegral . fromEnum) updated
+    result <- gst_event_new_toc toc' updated'
+    checkUnexpectedReturnNULL "gst_event_new_toc" result
+    result' <- (wrapBoxed Event) result
+    touchManagedPtr toc
+    return result'
+
+-- method Event::new_toc_select
+-- method type : Constructor
+-- Args : [Arg {argCName = "uid", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Event"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_event_new_toc_select" gst_event_new_toc_select :: 
+    CString ->                              -- uid : TBasicType TUTF8
+    IO (Ptr Event)
+
+
+eventNewTocSelect ::
+    (MonadIO m) =>
+    T.Text                                  -- uid
+    -> m Event                              -- result
+eventNewTocSelect uid = liftIO $ do
+    uid' <- textToCString uid
+    result <- gst_event_new_toc_select uid'
+    checkUnexpectedReturnNULL "gst_event_new_toc_select" result
+    result' <- (wrapBoxed Event) result
+    freeMem uid'
+    return result'
+
+-- method Event::copy_segment
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "segment", argType = TInterface "Gst" "Segment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_event_copy_segment" gst_event_copy_segment :: 
+    Ptr Event ->                            -- _obj : TInterface "Gst" "Event"
+    Ptr Segment ->                          -- segment : TInterface "Gst" "Segment"
+    IO ()
+
+
+eventCopySegment ::
+    (MonadIO m) =>
+    Event                                   -- _obj
+    -> Segment                              -- segment
+    -> m ()                                 -- result
+eventCopySegment _obj segment = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let segment' = unsafeManagedPtrGetPtr segment
+    gst_event_copy_segment _obj' segment'
+    touchManagedPtr _obj
+    touchManagedPtr segment
+    return ()
+
+data EventCopySegmentMethodInfo
+instance (signature ~ (Segment -> m ()), MonadIO m) => MethodInfo EventCopySegmentMethodInfo Event signature where
+    overloadedMethod _ = eventCopySegment
+
+-- method Event::get_running_time_offset
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TInt64
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_event_get_running_time_offset" gst_event_get_running_time_offset :: 
+    Ptr Event ->                            -- _obj : TInterface "Gst" "Event"
+    IO Int64
+
+
+eventGetRunningTimeOffset ::
+    (MonadIO m) =>
+    Event                                   -- _obj
+    -> m Int64                              -- result
+eventGetRunningTimeOffset _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_event_get_running_time_offset _obj'
+    touchManagedPtr _obj
+    return result
+
+data EventGetRunningTimeOffsetMethodInfo
+instance (signature ~ (m Int64), MonadIO m) => MethodInfo EventGetRunningTimeOffsetMethodInfo Event signature where
+    overloadedMethod _ = eventGetRunningTimeOffset
+
+-- method Event::get_seqnum
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUInt32
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_event_get_seqnum" gst_event_get_seqnum :: 
+    Ptr Event ->                            -- _obj : TInterface "Gst" "Event"
+    IO Word32
+
+
+eventGetSeqnum ::
+    (MonadIO m) =>
+    Event                                   -- _obj
+    -> m Word32                             -- result
+eventGetSeqnum _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_event_get_seqnum _obj'
+    touchManagedPtr _obj
+    return result
+
+data EventGetSeqnumMethodInfo
+instance (signature ~ (m Word32), MonadIO m) => MethodInfo EventGetSeqnumMethodInfo Event signature where
+    overloadedMethod _ = eventGetSeqnum
+
+-- method Event::get_structure
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Structure"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_event_get_structure" gst_event_get_structure :: 
+    Ptr Event ->                            -- _obj : TInterface "Gst" "Event"
+    IO (Ptr Structure)
+
+
+eventGetStructure ::
+    (MonadIO m) =>
+    Event                                   -- _obj
+    -> m Structure                          -- result
+eventGetStructure _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_event_get_structure _obj'
+    checkUnexpectedReturnNULL "gst_event_get_structure" result
+    result' <- (newBoxed Structure) result
+    touchManagedPtr _obj
+    return result'
+
+data EventGetStructureMethodInfo
+instance (signature ~ (m Structure), MonadIO m) => MethodInfo EventGetStructureMethodInfo Event signature where
+    overloadedMethod _ = eventGetStructure
+
+-- method Event::has_name
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_event_has_name" gst_event_has_name :: 
+    Ptr Event ->                            -- _obj : TInterface "Gst" "Event"
+    CString ->                              -- name : TBasicType TUTF8
+    IO CInt
+
+
+eventHasName ::
+    (MonadIO m) =>
+    Event                                   -- _obj
+    -> T.Text                               -- name
+    -> m Bool                               -- result
+eventHasName _obj name = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    name' <- textToCString name
+    result <- gst_event_has_name _obj' name'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    freeMem name'
+    return result'
+
+data EventHasNameMethodInfo
+instance (signature ~ (T.Text -> m Bool), MonadIO m) => MethodInfo EventHasNameMethodInfo Event signature where
+    overloadedMethod _ = eventHasName
+
+-- method Event::parse_buffer_size
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "minsize", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "maxsize", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "async", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_event_parse_buffer_size" gst_event_parse_buffer_size :: 
+    Ptr Event ->                            -- _obj : TInterface "Gst" "Event"
+    Ptr CUInt ->                            -- format : TInterface "Gst" "Format"
+    Ptr Int64 ->                            -- minsize : TBasicType TInt64
+    Ptr Int64 ->                            -- maxsize : TBasicType TInt64
+    Ptr CInt ->                             -- async : TBasicType TBoolean
+    IO ()
+
+
+eventParseBufferSize ::
+    (MonadIO m) =>
+    Event                                   -- _obj
+    -> m (Format,Int64,Int64,Bool)          -- result
+eventParseBufferSize _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    format <- allocMem :: IO (Ptr CUInt)
+    minsize <- allocMem :: IO (Ptr Int64)
+    maxsize <- allocMem :: IO (Ptr Int64)
+    async <- allocMem :: IO (Ptr CInt)
+    gst_event_parse_buffer_size _obj' format minsize maxsize async
+    format' <- peek format
+    let format'' = (toEnum . fromIntegral) format'
+    minsize' <- peek minsize
+    maxsize' <- peek maxsize
+    async' <- peek async
+    let async'' = (/= 0) async'
+    touchManagedPtr _obj
+    freeMem format
+    freeMem minsize
+    freeMem maxsize
+    freeMem async
+    return (format'', minsize', maxsize', async'')
+
+data EventParseBufferSizeMethodInfo
+instance (signature ~ (m (Format,Int64,Int64,Bool)), MonadIO m) => MethodInfo EventParseBufferSizeMethodInfo Event signature where
+    overloadedMethod _ = eventParseBufferSize
+
+-- method Event::parse_caps
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps", argType = TInterface "Gst" "Caps", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_event_parse_caps" gst_event_parse_caps :: 
+    Ptr Event ->                            -- _obj : TInterface "Gst" "Event"
+    Ptr Caps ->                             -- caps : TInterface "Gst" "Caps"
+    IO ()
+
+
+eventParseCaps ::
+    (MonadIO m) =>
+    Event                                   -- _obj
+    -> m (Caps)                             -- result
+eventParseCaps _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    caps <- callocBoxedBytes 64 :: IO (Ptr Caps)
+    gst_event_parse_caps _obj' caps
+    caps' <- (wrapBoxed Caps) caps
+    touchManagedPtr _obj
+    return caps'
+
+data EventParseCapsMethodInfo
+instance (signature ~ (m (Caps)), MonadIO m) => MethodInfo EventParseCapsMethodInfo Event signature where
+    overloadedMethod _ = eventParseCaps
+
+-- method Event::parse_flush_stop
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "reset_time", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_event_parse_flush_stop" gst_event_parse_flush_stop :: 
+    Ptr Event ->                            -- _obj : TInterface "Gst" "Event"
+    Ptr CInt ->                             -- reset_time : TBasicType TBoolean
+    IO ()
+
+
+eventParseFlushStop ::
+    (MonadIO m) =>
+    Event                                   -- _obj
+    -> m (Bool)                             -- result
+eventParseFlushStop _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    resetTime <- allocMem :: IO (Ptr CInt)
+    gst_event_parse_flush_stop _obj' resetTime
+    resetTime' <- peek resetTime
+    let resetTime'' = (/= 0) resetTime'
+    touchManagedPtr _obj
+    freeMem resetTime
+    return resetTime''
+
+data EventParseFlushStopMethodInfo
+instance (signature ~ (m (Bool)), MonadIO m) => MethodInfo EventParseFlushStopMethodInfo Event signature where
+    overloadedMethod _ = eventParseFlushStop
+
+-- method Event::parse_gap
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "timestamp", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "duration", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_event_parse_gap" gst_event_parse_gap :: 
+    Ptr Event ->                            -- _obj : TInterface "Gst" "Event"
+    Ptr Word64 ->                           -- timestamp : TBasicType TUInt64
+    Ptr Word64 ->                           -- duration : TBasicType TUInt64
+    IO ()
+
+
+eventParseGap ::
+    (MonadIO m) =>
+    Event                                   -- _obj
+    -> m (Word64,Word64)                    -- result
+eventParseGap _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    timestamp <- allocMem :: IO (Ptr Word64)
+    duration <- allocMem :: IO (Ptr Word64)
+    gst_event_parse_gap _obj' timestamp duration
+    timestamp' <- peek timestamp
+    duration' <- peek duration
+    touchManagedPtr _obj
+    freeMem timestamp
+    freeMem duration
+    return (timestamp', duration')
+
+data EventParseGapMethodInfo
+instance (signature ~ (m (Word64,Word64)), MonadIO m) => MethodInfo EventParseGapMethodInfo Event signature where
+    overloadedMethod _ = eventParseGap
+
+-- method Event::parse_group_id
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "group_id", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_event_parse_group_id" gst_event_parse_group_id :: 
+    Ptr Event ->                            -- _obj : TInterface "Gst" "Event"
+    Ptr Word32 ->                           -- group_id : TBasicType TUInt32
+    IO CInt
+
+
+eventParseGroupId ::
+    (MonadIO m) =>
+    Event                                   -- _obj
+    -> m (Bool,Word32)                      -- result
+eventParseGroupId _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    groupId <- allocMem :: IO (Ptr Word32)
+    result <- gst_event_parse_group_id _obj' groupId
+    let result' = (/= 0) result
+    groupId' <- peek groupId
+    touchManagedPtr _obj
+    freeMem groupId
+    return (result', groupId')
+
+data EventParseGroupIdMethodInfo
+instance (signature ~ (m (Bool,Word32)), MonadIO m) => MethodInfo EventParseGroupIdMethodInfo Event signature where
+    overloadedMethod _ = eventParseGroupId
+
+-- method Event::parse_latency
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "latency", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_event_parse_latency" gst_event_parse_latency :: 
+    Ptr Event ->                            -- _obj : TInterface "Gst" "Event"
+    Ptr Word64 ->                           -- latency : TBasicType TUInt64
+    IO ()
+
+
+eventParseLatency ::
+    (MonadIO m) =>
+    Event                                   -- _obj
+    -> m (Word64)                           -- result
+eventParseLatency _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    latency <- allocMem :: IO (Ptr Word64)
+    gst_event_parse_latency _obj' latency
+    latency' <- peek latency
+    touchManagedPtr _obj
+    freeMem latency
+    return latency'
+
+data EventParseLatencyMethodInfo
+instance (signature ~ (m (Word64)), MonadIO m) => MethodInfo EventParseLatencyMethodInfo Event signature where
+    overloadedMethod _ = eventParseLatency
+
+-- method Event::parse_protection
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "system_id", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TInterface "Gst" "Buffer", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "origin", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_event_parse_protection" gst_event_parse_protection :: 
+    Ptr Event ->                            -- _obj : TInterface "Gst" "Event"
+    Ptr CString ->                          -- system_id : TBasicType TUTF8
+    Ptr Buffer ->                           -- data : TInterface "Gst" "Buffer"
+    CString ->                              -- origin : TBasicType TUTF8
+    IO ()
+
+
+eventParseProtection ::
+    (MonadIO m) =>
+    Event                                   -- _obj
+    -> Maybe (T.Text)                       -- origin
+    -> m (T.Text,Buffer)                    -- result
+eventParseProtection _obj origin = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    systemId <- allocMem :: IO (Ptr CString)
+    data_ <- callocBoxedBytes 112 :: IO (Ptr Buffer)
+    maybeOrigin <- case origin of
+        Nothing -> return nullPtr
+        Just jOrigin -> do
+            jOrigin' <- textToCString jOrigin
+            return jOrigin'
+    gst_event_parse_protection _obj' systemId data_ maybeOrigin
+    systemId' <- peek systemId
+    systemId'' <- cstringToText systemId'
+    data_' <- (wrapBoxed Buffer) data_
+    touchManagedPtr _obj
+    freeMem systemId
+    freeMem maybeOrigin
+    return (systemId'', data_')
+
+data EventParseProtectionMethodInfo
+instance (signature ~ (Maybe (T.Text) -> m (T.Text,Buffer)), MonadIO m) => MethodInfo EventParseProtectionMethodInfo Event signature where
+    overloadedMethod _ = eventParseProtection
+
+-- method Event::parse_qos
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "type", argType = TInterface "Gst" "QOSType", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "proportion", argType = TBasicType TDouble, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "diff", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "timestamp", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_event_parse_qos" gst_event_parse_qos :: 
+    Ptr Event ->                            -- _obj : TInterface "Gst" "Event"
+    Ptr CUInt ->                            -- type : TInterface "Gst" "QOSType"
+    Ptr CDouble ->                          -- proportion : TBasicType TDouble
+    Ptr Int64 ->                            -- diff : TBasicType TInt64
+    Ptr Word64 ->                           -- timestamp : TBasicType TUInt64
+    IO ()
+
+
+eventParseQos ::
+    (MonadIO m) =>
+    Event                                   -- _obj
+    -> m (QOSType,Double,Int64,Word64)      -- result
+eventParseQos _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    type_ <- allocMem :: IO (Ptr CUInt)
+    proportion <- allocMem :: IO (Ptr CDouble)
+    diff <- allocMem :: IO (Ptr Int64)
+    timestamp <- allocMem :: IO (Ptr Word64)
+    gst_event_parse_qos _obj' type_ proportion diff timestamp
+    type_' <- peek type_
+    let type_'' = (toEnum . fromIntegral) type_'
+    proportion' <- peek proportion
+    let proportion'' = realToFrac proportion'
+    diff' <- peek diff
+    timestamp' <- peek timestamp
+    touchManagedPtr _obj
+    freeMem type_
+    freeMem proportion
+    freeMem diff
+    freeMem timestamp
+    return (type_'', proportion'', diff', timestamp')
+
+data EventParseQosMethodInfo
+instance (signature ~ (m (QOSType,Double,Int64,Word64)), MonadIO m) => MethodInfo EventParseQosMethodInfo Event signature where
+    overloadedMethod _ = eventParseQos
+
+-- method Event::parse_seek
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "rate", argType = TBasicType TDouble, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "flags", argType = TInterface "Gst" "SeekFlags", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "start_type", argType = TInterface "Gst" "SeekType", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "start", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "stop_type", argType = TInterface "Gst" "SeekType", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "stop", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_event_parse_seek" gst_event_parse_seek :: 
+    Ptr Event ->                            -- _obj : TInterface "Gst" "Event"
+    Ptr CDouble ->                          -- rate : TBasicType TDouble
+    Ptr CUInt ->                            -- format : TInterface "Gst" "Format"
+    Ptr CUInt ->                            -- flags : TInterface "Gst" "SeekFlags"
+    Ptr CUInt ->                            -- start_type : TInterface "Gst" "SeekType"
+    Ptr Int64 ->                            -- start : TBasicType TInt64
+    Ptr CUInt ->                            -- stop_type : TInterface "Gst" "SeekType"
+    Ptr Int64 ->                            -- stop : TBasicType TInt64
+    IO ()
+
+
+eventParseSeek ::
+    (MonadIO m) =>
+    Event                                   -- _obj
+    -> m (Double,Format,[SeekFlags],SeekType,Int64,SeekType,Int64)-- result
+eventParseSeek _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    rate <- allocMem :: IO (Ptr CDouble)
+    format <- allocMem :: IO (Ptr CUInt)
+    flags <- allocMem :: IO (Ptr CUInt)
+    startType <- allocMem :: IO (Ptr CUInt)
+    start <- allocMem :: IO (Ptr Int64)
+    stopType <- allocMem :: IO (Ptr CUInt)
+    stop <- allocMem :: IO (Ptr Int64)
+    gst_event_parse_seek _obj' rate format flags startType start stopType stop
+    rate' <- peek rate
+    let rate'' = realToFrac rate'
+    format' <- peek format
+    let format'' = (toEnum . fromIntegral) format'
+    flags' <- peek flags
+    let flags'' = wordToGFlags flags'
+    startType' <- peek startType
+    let startType'' = (toEnum . fromIntegral) startType'
+    start' <- peek start
+    stopType' <- peek stopType
+    let stopType'' = (toEnum . fromIntegral) stopType'
+    stop' <- peek stop
+    touchManagedPtr _obj
+    freeMem rate
+    freeMem format
+    freeMem flags
+    freeMem startType
+    freeMem start
+    freeMem stopType
+    freeMem stop
+    return (rate'', format'', flags'', startType'', start', stopType'', stop')
+
+data EventParseSeekMethodInfo
+instance (signature ~ (m (Double,Format,[SeekFlags],SeekType,Int64,SeekType,Int64)), MonadIO m) => MethodInfo EventParseSeekMethodInfo Event signature where
+    overloadedMethod _ = eventParseSeek
+
+-- method Event::parse_segment
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "segment", argType = TInterface "Gst" "Segment", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_event_parse_segment" gst_event_parse_segment :: 
+    Ptr Event ->                            -- _obj : TInterface "Gst" "Event"
+    Ptr Segment ->                          -- segment : TInterface "Gst" "Segment"
+    IO ()
+
+
+eventParseSegment ::
+    (MonadIO m) =>
+    Event                                   -- _obj
+    -> m (Segment)                          -- result
+eventParseSegment _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    segment <- callocBoxedBytes 120 :: IO (Ptr Segment)
+    gst_event_parse_segment _obj' segment
+    segment' <- (wrapBoxed Segment) segment
+    touchManagedPtr _obj
+    return segment'
+
+data EventParseSegmentMethodInfo
+instance (signature ~ (m (Segment)), MonadIO m) => MethodInfo EventParseSegmentMethodInfo Event signature where
+    overloadedMethod _ = eventParseSegment
+
+-- method Event::parse_segment_done
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "position", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_event_parse_segment_done" gst_event_parse_segment_done :: 
+    Ptr Event ->                            -- _obj : TInterface "Gst" "Event"
+    Ptr CUInt ->                            -- format : TInterface "Gst" "Format"
+    Ptr Int64 ->                            -- position : TBasicType TInt64
+    IO ()
+
+
+eventParseSegmentDone ::
+    (MonadIO m) =>
+    Event                                   -- _obj
+    -> m (Format,Int64)                     -- result
+eventParseSegmentDone _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    format <- allocMem :: IO (Ptr CUInt)
+    position <- allocMem :: IO (Ptr Int64)
+    gst_event_parse_segment_done _obj' format position
+    format' <- peek format
+    let format'' = (toEnum . fromIntegral) format'
+    position' <- peek position
+    touchManagedPtr _obj
+    freeMem format
+    freeMem position
+    return (format'', position')
+
+data EventParseSegmentDoneMethodInfo
+instance (signature ~ (m (Format,Int64)), MonadIO m) => MethodInfo EventParseSegmentDoneMethodInfo Event signature where
+    overloadedMethod _ = eventParseSegmentDone
+
+-- method Event::parse_sink_message
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "msg", argType = TInterface "Gst" "Message", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_event_parse_sink_message" gst_event_parse_sink_message :: 
+    Ptr Event ->                            -- _obj : TInterface "Gst" "Event"
+    Ptr Message ->                          -- msg : TInterface "Gst" "Message"
+    IO ()
+
+
+eventParseSinkMessage ::
+    (MonadIO m) =>
+    Event                                   -- _obj
+    -> m (Message)                          -- result
+eventParseSinkMessage _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    msg <- callocBoxedBytes 120 :: IO (Ptr Message)
+    gst_event_parse_sink_message _obj' msg
+    msg' <- (wrapBoxed Message) msg
+    touchManagedPtr _obj
+    return msg'
+
+data EventParseSinkMessageMethodInfo
+instance (signature ~ (m (Message)), MonadIO m) => MethodInfo EventParseSinkMessageMethodInfo Event signature where
+    overloadedMethod _ = eventParseSinkMessage
+
+-- method Event::parse_step
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "amount", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "rate", argType = TBasicType TDouble, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "flush", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "intermediate", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_event_parse_step" gst_event_parse_step :: 
+    Ptr Event ->                            -- _obj : TInterface "Gst" "Event"
+    Ptr CUInt ->                            -- format : TInterface "Gst" "Format"
+    Ptr Word64 ->                           -- amount : TBasicType TUInt64
+    Ptr CDouble ->                          -- rate : TBasicType TDouble
+    Ptr CInt ->                             -- flush : TBasicType TBoolean
+    Ptr CInt ->                             -- intermediate : TBasicType TBoolean
+    IO ()
+
+
+eventParseStep ::
+    (MonadIO m) =>
+    Event                                   -- _obj
+    -> m (Format,Word64,Double,Bool,Bool)   -- result
+eventParseStep _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    format <- allocMem :: IO (Ptr CUInt)
+    amount <- allocMem :: IO (Ptr Word64)
+    rate <- allocMem :: IO (Ptr CDouble)
+    flush <- allocMem :: IO (Ptr CInt)
+    intermediate <- allocMem :: IO (Ptr CInt)
+    gst_event_parse_step _obj' format amount rate flush intermediate
+    format' <- peek format
+    let format'' = (toEnum . fromIntegral) format'
+    amount' <- peek amount
+    rate' <- peek rate
+    let rate'' = realToFrac rate'
+    flush' <- peek flush
+    let flush'' = (/= 0) flush'
+    intermediate' <- peek intermediate
+    let intermediate'' = (/= 0) intermediate'
+    touchManagedPtr _obj
+    freeMem format
+    freeMem amount
+    freeMem rate
+    freeMem flush
+    freeMem intermediate
+    return (format'', amount', rate'', flush'', intermediate'')
+
+data EventParseStepMethodInfo
+instance (signature ~ (m (Format,Word64,Double,Bool,Bool)), MonadIO m) => MethodInfo EventParseStepMethodInfo Event signature where
+    overloadedMethod _ = eventParseStep
+
+-- method Event::parse_stream_flags
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface "Gst" "StreamFlags", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_event_parse_stream_flags" gst_event_parse_stream_flags :: 
+    Ptr Event ->                            -- _obj : TInterface "Gst" "Event"
+    Ptr CUInt ->                            -- flags : TInterface "Gst" "StreamFlags"
+    IO ()
+
+
+eventParseStreamFlags ::
+    (MonadIO m) =>
+    Event                                   -- _obj
+    -> m ([StreamFlags])                    -- result
+eventParseStreamFlags _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    flags <- allocMem :: IO (Ptr CUInt)
+    gst_event_parse_stream_flags _obj' flags
+    flags' <- peek flags
+    let flags'' = wordToGFlags flags'
+    touchManagedPtr _obj
+    freeMem flags
+    return flags''
+
+data EventParseStreamFlagsMethodInfo
+instance (signature ~ (m ([StreamFlags])), MonadIO m) => MethodInfo EventParseStreamFlagsMethodInfo Event signature where
+    overloadedMethod _ = eventParseStreamFlags
+
+-- method Event::parse_stream_start
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stream_id", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_event_parse_stream_start" gst_event_parse_stream_start :: 
+    Ptr Event ->                            -- _obj : TInterface "Gst" "Event"
+    Ptr CString ->                          -- stream_id : TBasicType TUTF8
+    IO ()
+
+
+eventParseStreamStart ::
+    (MonadIO m) =>
+    Event                                   -- _obj
+    -> m (T.Text)                           -- result
+eventParseStreamStart _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    streamId <- allocMem :: IO (Ptr CString)
+    gst_event_parse_stream_start _obj' streamId
+    streamId' <- peek streamId
+    streamId'' <- cstringToText streamId'
+    touchManagedPtr _obj
+    freeMem streamId
+    return streamId''
+
+data EventParseStreamStartMethodInfo
+instance (signature ~ (m (T.Text)), MonadIO m) => MethodInfo EventParseStreamStartMethodInfo Event signature where
+    overloadedMethod _ = eventParseStreamStart
+
+-- method Event::parse_tag
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "taglist", argType = TInterface "Gst" "TagList", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_event_parse_tag" gst_event_parse_tag :: 
+    Ptr Event ->                            -- _obj : TInterface "Gst" "Event"
+    Ptr TagList ->                          -- taglist : TInterface "Gst" "TagList"
+    IO ()
+
+
+eventParseTag ::
+    (MonadIO m) =>
+    Event                                   -- _obj
+    -> m (TagList)                          -- result
+eventParseTag _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    taglist <- callocBoxedBytes 64 :: IO (Ptr TagList)
+    gst_event_parse_tag _obj' taglist
+    taglist' <- (wrapBoxed TagList) taglist
+    touchManagedPtr _obj
+    return taglist'
+
+data EventParseTagMethodInfo
+instance (signature ~ (m (TagList)), MonadIO m) => MethodInfo EventParseTagMethodInfo Event signature where
+    overloadedMethod _ = eventParseTag
+
+-- method Event::parse_toc
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "toc", argType = TInterface "Gst" "Toc", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "updated", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_event_parse_toc" gst_event_parse_toc :: 
+    Ptr Event ->                            -- _obj : TInterface "Gst" "Event"
+    Ptr (Ptr Toc) ->                        -- toc : TInterface "Gst" "Toc"
+    Ptr CInt ->                             -- updated : TBasicType TBoolean
+    IO ()
+
+
+eventParseToc ::
+    (MonadIO m) =>
+    Event                                   -- _obj
+    -> m (Toc,Bool)                         -- result
+eventParseToc _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    toc <- allocMem :: IO (Ptr (Ptr Toc))
+    updated <- allocMem :: IO (Ptr CInt)
+    gst_event_parse_toc _obj' toc updated
+    toc' <- peek toc
+    toc'' <- (wrapBoxed Toc) toc'
+    updated' <- peek updated
+    let updated'' = (/= 0) updated'
+    touchManagedPtr _obj
+    freeMem toc
+    freeMem updated
+    return (toc'', updated'')
+
+data EventParseTocMethodInfo
+instance (signature ~ (m (Toc,Bool)), MonadIO m) => MethodInfo EventParseTocMethodInfo Event signature where
+    overloadedMethod _ = eventParseToc
+
+-- method Event::parse_toc_select
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "uid", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_event_parse_toc_select" gst_event_parse_toc_select :: 
+    Ptr Event ->                            -- _obj : TInterface "Gst" "Event"
+    Ptr CString ->                          -- uid : TBasicType TUTF8
+    IO ()
+
+
+eventParseTocSelect ::
+    (MonadIO m) =>
+    Event                                   -- _obj
+    -> m (T.Text)                           -- result
+eventParseTocSelect _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    uid <- allocMem :: IO (Ptr CString)
+    gst_event_parse_toc_select _obj' uid
+    uid' <- peek uid
+    uid'' <- cstringToText uid'
+    freeMem uid'
+    touchManagedPtr _obj
+    freeMem uid
+    return uid''
+
+data EventParseTocSelectMethodInfo
+instance (signature ~ (m (T.Text)), MonadIO m) => MethodInfo EventParseTocSelectMethodInfo Event signature where
+    overloadedMethod _ = eventParseTocSelect
+
+-- method Event::set_group_id
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "group_id", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_event_set_group_id" gst_event_set_group_id :: 
+    Ptr Event ->                            -- _obj : TInterface "Gst" "Event"
+    Word32 ->                               -- group_id : TBasicType TUInt32
+    IO ()
+
+
+eventSetGroupId ::
+    (MonadIO m) =>
+    Event                                   -- _obj
+    -> Word32                               -- groupId
+    -> m ()                                 -- result
+eventSetGroupId _obj groupId = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    gst_event_set_group_id _obj' groupId
+    touchManagedPtr _obj
+    return ()
+
+data EventSetGroupIdMethodInfo
+instance (signature ~ (Word32 -> m ()), MonadIO m) => MethodInfo EventSetGroupIdMethodInfo Event signature where
+    overloadedMethod _ = eventSetGroupId
+
+-- method Event::set_running_time_offset
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_event_set_running_time_offset" gst_event_set_running_time_offset :: 
+    Ptr Event ->                            -- _obj : TInterface "Gst" "Event"
+    Int64 ->                                -- offset : TBasicType TInt64
+    IO ()
+
+
+eventSetRunningTimeOffset ::
+    (MonadIO m) =>
+    Event                                   -- _obj
+    -> Int64                                -- offset
+    -> m ()                                 -- result
+eventSetRunningTimeOffset _obj offset = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    gst_event_set_running_time_offset _obj' offset
+    touchManagedPtr _obj
+    return ()
+
+data EventSetRunningTimeOffsetMethodInfo
+instance (signature ~ (Int64 -> m ()), MonadIO m) => MethodInfo EventSetRunningTimeOffsetMethodInfo Event signature where
+    overloadedMethod _ = eventSetRunningTimeOffset
+
+-- method Event::set_seqnum
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "seqnum", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_event_set_seqnum" gst_event_set_seqnum :: 
+    Ptr Event ->                            -- _obj : TInterface "Gst" "Event"
+    Word32 ->                               -- seqnum : TBasicType TUInt32
+    IO ()
+
+
+eventSetSeqnum ::
+    (MonadIO m) =>
+    Event                                   -- _obj
+    -> Word32                               -- seqnum
+    -> m ()                                 -- result
+eventSetSeqnum _obj seqnum = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    gst_event_set_seqnum _obj' seqnum
+    touchManagedPtr _obj
+    return ()
+
+data EventSetSeqnumMethodInfo
+instance (signature ~ (Word32 -> m ()), MonadIO m) => MethodInfo EventSetSeqnumMethodInfo Event signature where
+    overloadedMethod _ = eventSetSeqnum
+
+-- method Event::set_stream_flags
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface "Gst" "StreamFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_event_set_stream_flags" gst_event_set_stream_flags :: 
+    Ptr Event ->                            -- _obj : TInterface "Gst" "Event"
+    CUInt ->                                -- flags : TInterface "Gst" "StreamFlags"
+    IO ()
+
+
+eventSetStreamFlags ::
+    (MonadIO m) =>
+    Event                                   -- _obj
+    -> [StreamFlags]                        -- flags
+    -> m ()                                 -- result
+eventSetStreamFlags _obj flags = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let flags' = gflagsToWord flags
+    gst_event_set_stream_flags _obj' flags'
+    touchManagedPtr _obj
+    return ()
+
+data EventSetStreamFlagsMethodInfo
+instance (signature ~ ([StreamFlags] -> m ()), MonadIO m) => MethodInfo EventSetStreamFlagsMethodInfo Event signature where
+    overloadedMethod _ = eventSetStreamFlags
+
+-- method Event::writable_structure
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Event", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Structure"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_event_writable_structure" gst_event_writable_structure :: 
+    Ptr Event ->                            -- _obj : TInterface "Gst" "Event"
+    IO (Ptr Structure)
+
+
+eventWritableStructure ::
+    (MonadIO m) =>
+    Event                                   -- _obj
+    -> m Structure                          -- result
+eventWritableStructure _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_event_writable_structure _obj'
+    checkUnexpectedReturnNULL "gst_event_writable_structure" result
+    result' <- (newBoxed Structure) result
+    touchManagedPtr _obj
+    return result'
+
+data EventWritableStructureMethodInfo
+instance (signature ~ (m Structure), MonadIO m) => MethodInfo EventWritableStructureMethodInfo Event signature where
+    overloadedMethod _ = eventWritableStructure
+
+type family ResolveEventMethod (t :: Symbol) (o :: *) :: * where
+    ResolveEventMethod "copySegment" o = EventCopySegmentMethodInfo
+    ResolveEventMethod "hasName" o = EventHasNameMethodInfo
+    ResolveEventMethod "parseBufferSize" o = EventParseBufferSizeMethodInfo
+    ResolveEventMethod "parseCaps" o = EventParseCapsMethodInfo
+    ResolveEventMethod "parseFlushStop" o = EventParseFlushStopMethodInfo
+    ResolveEventMethod "parseGap" o = EventParseGapMethodInfo
+    ResolveEventMethod "parseGroupId" o = EventParseGroupIdMethodInfo
+    ResolveEventMethod "parseLatency" o = EventParseLatencyMethodInfo
+    ResolveEventMethod "parseProtection" o = EventParseProtectionMethodInfo
+    ResolveEventMethod "parseQos" o = EventParseQosMethodInfo
+    ResolveEventMethod "parseSeek" o = EventParseSeekMethodInfo
+    ResolveEventMethod "parseSegment" o = EventParseSegmentMethodInfo
+    ResolveEventMethod "parseSegmentDone" o = EventParseSegmentDoneMethodInfo
+    ResolveEventMethod "parseSinkMessage" o = EventParseSinkMessageMethodInfo
+    ResolveEventMethod "parseStep" o = EventParseStepMethodInfo
+    ResolveEventMethod "parseStreamFlags" o = EventParseStreamFlagsMethodInfo
+    ResolveEventMethod "parseStreamStart" o = EventParseStreamStartMethodInfo
+    ResolveEventMethod "parseTag" o = EventParseTagMethodInfo
+    ResolveEventMethod "parseToc" o = EventParseTocMethodInfo
+    ResolveEventMethod "parseTocSelect" o = EventParseTocSelectMethodInfo
+    ResolveEventMethod "writableStructure" o = EventWritableStructureMethodInfo
+    ResolveEventMethod "getRunningTimeOffset" o = EventGetRunningTimeOffsetMethodInfo
+    ResolveEventMethod "getSeqnum" o = EventGetSeqnumMethodInfo
+    ResolveEventMethod "getStructure" o = EventGetStructureMethodInfo
+    ResolveEventMethod "setGroupId" o = EventSetGroupIdMethodInfo
+    ResolveEventMethod "setRunningTimeOffset" o = EventSetRunningTimeOffsetMethodInfo
+    ResolveEventMethod "setSeqnum" o = EventSetSeqnumMethodInfo
+    ResolveEventMethod "setStreamFlags" o = EventSetStreamFlagsMethodInfo
+    ResolveEventMethod l o = MethodResolutionFailed l o
+
+instance (info ~ ResolveEventMethod t Event, MethodInfo info Event p) => IsLabelProxy t (Event -> p) where
+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)
+
+#if MIN_VERSION_base(4,9,0)
+instance (info ~ ResolveEventMethod t Event, MethodInfo info Event p) => IsLabel t (Event -> p) where
+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)
+#endif
+
+
diff --git a/GI/Gst/Structs/Event.hs-boot b/GI/Gst/Structs/Event.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/Event.hs-boot
@@ -0,0 +1,39 @@
+module GI.Gst.Structs.Event where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+newtype Event = Event (ForeignPtr Event)
+instance BoxedObject Event where
+data EventCopySegmentMethodInfo
+data EventGetRunningTimeOffsetMethodInfo
+data EventGetSeqnumMethodInfo
+data EventGetStructureMethodInfo
+data EventHasNameMethodInfo
+data EventParseBufferSizeMethodInfo
+data EventParseCapsMethodInfo
+data EventParseFlushStopMethodInfo
+data EventParseGapMethodInfo
+data EventParseGroupIdMethodInfo
+data EventParseLatencyMethodInfo
+data EventParseProtectionMethodInfo
+data EventParseQosMethodInfo
+data EventParseSeekMethodInfo
+data EventParseSegmentMethodInfo
+data EventParseSegmentDoneMethodInfo
+data EventParseSinkMessageMethodInfo
+data EventParseStepMethodInfo
+data EventParseStreamFlagsMethodInfo
+data EventParseStreamStartMethodInfo
+data EventParseTagMethodInfo
+data EventParseTocMethodInfo
+data EventParseTocSelectMethodInfo
+data EventSetGroupIdMethodInfo
+data EventSetRunningTimeOffsetMethodInfo
+data EventSetSeqnumMethodInfo
+data EventSetStreamFlagsMethodInfo
+data EventWritableStructureMethodInfo
diff --git a/GI/Gst/Structs/FormatDefinition.hs b/GI/Gst/Structs/FormatDefinition.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/FormatDefinition.hs
@@ -0,0 +1,93 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+
+A format definition
+-}
+
+module GI.Gst.Structs.FormatDefinition
+    ( 
+
+-- * Exported types
+    FormatDefinition(..)                    ,
+    newZeroFormatDefinition                 ,
+    noFormatDefinition                      ,
+
+
+ -- * Properties
+-- ** Description
+    formatDefinitionReadDescription         ,
+
+
+-- ** Nick
+    formatDefinitionReadNick                ,
+
+
+-- ** Quark
+    formatDefinitionReadQuark               ,
+
+
+-- ** Value
+    formatDefinitionReadValue               ,
+
+
+
+
+    ) where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+import GI.Gst.Callbacks
+
+newtype FormatDefinition = FormatDefinition (ForeignPtr FormatDefinition)
+-- | Construct a `FormatDefinition` struct initialized to zero.
+newZeroFormatDefinition :: MonadIO m => m FormatDefinition
+newZeroFormatDefinition = liftIO $ callocBytes 32 >>= wrapPtr FormatDefinition
+
+noFormatDefinition :: Maybe FormatDefinition
+noFormatDefinition = Nothing
+
+formatDefinitionReadValue :: FormatDefinition -> IO Format
+formatDefinitionReadValue s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 0) :: IO CUInt
+    let val' = (toEnum . fromIntegral) val
+    return val'
+
+formatDefinitionReadNick :: FormatDefinition -> IO T.Text
+formatDefinitionReadNick s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 8) :: IO CString
+    val' <- cstringToText val
+    return val'
+
+formatDefinitionReadDescription :: FormatDefinition -> IO T.Text
+formatDefinitionReadDescription s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 16) :: IO CString
+    val' <- cstringToText val
+    return val'
+
+formatDefinitionReadQuark :: FormatDefinition -> IO Word32
+formatDefinitionReadQuark s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 24) :: IO Word32
+    return val
+
+type family ResolveFormatDefinitionMethod (t :: Symbol) (o :: *) :: * where
+    ResolveFormatDefinitionMethod l o = MethodResolutionFailed l o
+
+instance (info ~ ResolveFormatDefinitionMethod t FormatDefinition, MethodInfo info FormatDefinition p) => IsLabelProxy t (FormatDefinition -> p) where
+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)
+
+#if MIN_VERSION_base(4,9,0)
+instance (info ~ ResolveFormatDefinitionMethod t FormatDefinition, MethodInfo info FormatDefinition p) => IsLabel t (FormatDefinition -> p) where
+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)
+#endif
+
+
diff --git a/GI/Gst/Structs/FormatDefinition.hs-boot b/GI/Gst/Structs/FormatDefinition.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/FormatDefinition.hs-boot
@@ -0,0 +1,10 @@
+module GI.Gst.Structs.FormatDefinition where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+newtype FormatDefinition = FormatDefinition (ForeignPtr FormatDefinition)
diff --git a/GI/Gst/Structs/Iterator.hs b/GI/Gst/Structs/Iterator.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/Iterator.hs
@@ -0,0 +1,545 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+
+A GstIterator is used to retrieve multiple objects from another object in
+a threadsafe way.
+
+Various GStreamer objects provide access to their internal structures using
+an iterator.
+
+Note that if calling a GstIterator function results in your code receiving
+a refcounted object (with, say, g_value_get_object()), the refcount for that
+object will not be increased. Your code is responsible for taking a reference
+if it wants to continue using it later.
+
+The basic use pattern of an iterator is as follows:
+|[
+  GstIterator *it = _get_iterator(object);
+  GValue item = G_VALUE_INIT;
+  done = FALSE;
+  while (!done) {
+    switch (gst_iterator_next (it, &amp;item)) {
+      case GST_ITERATOR_OK:
+        ...get/use/change item here...
+        g_value_reset (&amp;item);
+        break;
+      case GST_ITERATOR_RESYNC:
+        ...rollback changes to items...
+        gst_iterator_resync (it);
+        break;
+      case GST_ITERATOR_ERROR:
+        ...wrong parameters were given...
+        done = TRUE;
+        break;
+      case GST_ITERATOR_DONE:
+        done = TRUE;
+        break;
+    }
+  }
+  g_value_unset (&amp;item);
+  gst_iterator_free (it);
+]|
+-}
+
+module GI.Gst.Structs.Iterator
+    ( 
+
+-- * Exported types
+    Iterator(..)                            ,
+    newZeroIterator                         ,
+    noIterator                              ,
+
+
+ -- * Methods
+-- ** iteratorCopy
+    IteratorCopyMethodInfo                  ,
+    iteratorCopy                            ,
+
+
+-- ** iteratorFilter
+    IteratorFilterMethodInfo                ,
+    iteratorFilter                          ,
+
+
+-- ** iteratorFindCustom
+    IteratorFindCustomMethodInfo            ,
+    iteratorFindCustom                      ,
+
+
+-- ** iteratorFold
+    IteratorFoldMethodInfo                  ,
+    iteratorFold                            ,
+
+
+-- ** iteratorForeach
+    IteratorForeachMethodInfo               ,
+    iteratorForeach                         ,
+
+
+-- ** iteratorFree
+    IteratorFreeMethodInfo                  ,
+    iteratorFree                            ,
+
+
+-- ** iteratorNewSingle
+    iteratorNewSingle                       ,
+
+
+-- ** iteratorNext
+    IteratorNextMethodInfo                  ,
+    iteratorNext                            ,
+
+
+-- ** iteratorPush
+    IteratorPushMethodInfo                  ,
+    iteratorPush                            ,
+
+
+-- ** iteratorResync
+    IteratorResyncMethodInfo                ,
+    iteratorResync                          ,
+
+
+
+
+ -- * Properties
+-- ** Cookie
+    iteratorReadCookie                      ,
+
+
+-- ** Lock
+    iteratorReadLock                        ,
+
+
+-- ** MasterCookie
+    iteratorReadMasterCookie                ,
+
+
+-- ** Pushed
+    iteratorReadPushed                      ,
+
+
+-- ** Size
+    iteratorReadSize                        ,
+
+
+-- ** Type
+    iteratorReadType                        ,
+
+
+
+
+    ) where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+import GI.Gst.Callbacks
+import qualified GI.GLib as GLib
+
+newtype Iterator = Iterator (ForeignPtr Iterator)
+foreign import ccall "gst_iterator_get_type" c_gst_iterator_get_type :: 
+    IO GType
+
+instance BoxedObject Iterator where
+    boxedType _ = c_gst_iterator_get_type
+
+-- | Construct a `Iterator` struct initialized to zero.
+newZeroIterator :: MonadIO m => m Iterator
+newZeroIterator = liftIO $ callocBoxedBytes 120 >>= wrapBoxed Iterator
+
+noIterator :: Maybe Iterator
+noIterator = Nothing
+
+-- XXX Skipped getter for "Iterator:copy" :: Not implemented: "Wrapping foreign callbacks is not supported yet"
+
+-- XXX Skipped getter for "Iterator:next" :: Not implemented: "Wrapping foreign callbacks is not supported yet"
+
+-- XXX Skipped getter for "Iterator:item" :: Not implemented: "Wrapping foreign callbacks is not supported yet"
+
+-- XXX Skipped getter for "Iterator:resync" :: Not implemented: "Wrapping foreign callbacks is not supported yet"
+
+-- XXX Skipped getter for "Iterator:free" :: Not implemented: "Wrapping foreign callbacks is not supported yet"
+
+iteratorReadPushed :: Iterator -> IO Iterator
+iteratorReadPushed s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 40) :: IO (Ptr Iterator)
+    val' <- (newBoxed Iterator) val
+    return val'
+
+iteratorReadType :: Iterator -> IO GType
+iteratorReadType s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 48) :: IO CGType
+    let val' = GType val
+    return val'
+
+iteratorReadLock :: Iterator -> IO GLib.Mutex
+iteratorReadLock s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 56) :: IO (Ptr GLib.Mutex)
+    val' <- (newPtr 8 GLib.Mutex) val
+    return val'
+
+iteratorReadCookie :: Iterator -> IO Word32
+iteratorReadCookie s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 64) :: IO Word32
+    return val
+
+iteratorReadMasterCookie :: Iterator -> IO Word32
+iteratorReadMasterCookie s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 72) :: IO Word32
+    return val
+
+iteratorReadSize :: Iterator -> IO Word32
+iteratorReadSize s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 80) :: IO Word32
+    return val
+
+-- method Iterator::new_single
+-- method type : Constructor
+-- Args : [Arg {argCName = "type", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "object", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Iterator"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_iterator_new_single" gst_iterator_new_single :: 
+    CGType ->                               -- type : TBasicType TGType
+    Ptr GValue ->                           -- object : TInterface "GObject" "Value"
+    IO (Ptr Iterator)
+
+
+iteratorNewSingle ::
+    (MonadIO m) =>
+    GType                                   -- type_
+    -> GValue                               -- object
+    -> m Iterator                           -- result
+iteratorNewSingle type_ object = liftIO $ do
+    let type_' = gtypeToCGType type_
+    let object' = unsafeManagedPtrGetPtr object
+    result <- gst_iterator_new_single type_' object'
+    checkUnexpectedReturnNULL "gst_iterator_new_single" result
+    result' <- (wrapBoxed Iterator) result
+    touchManagedPtr object
+    return result'
+
+-- method Iterator::copy
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Iterator", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Iterator"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_iterator_copy" gst_iterator_copy :: 
+    Ptr Iterator ->                         -- _obj : TInterface "Gst" "Iterator"
+    IO (Ptr Iterator)
+
+
+iteratorCopy ::
+    (MonadIO m) =>
+    Iterator                                -- _obj
+    -> m Iterator                           -- result
+iteratorCopy _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_iterator_copy _obj'
+    checkUnexpectedReturnNULL "gst_iterator_copy" result
+    result' <- (wrapBoxed Iterator) result
+    touchManagedPtr _obj
+    return result'
+
+data IteratorCopyMethodInfo
+instance (signature ~ (m Iterator), MonadIO m) => MethodInfo IteratorCopyMethodInfo Iterator signature where
+    overloadedMethod _ = iteratorCopy
+
+-- method Iterator::filter
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Iterator", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "func", argType = TInterface "GLib" "CompareFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Iterator"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_iterator_filter" gst_iterator_filter :: 
+    Ptr Iterator ->                         -- _obj : TInterface "Gst" "Iterator"
+    FunPtr GLib.CompareFuncC ->             -- func : TInterface "GLib" "CompareFunc"
+    Ptr GValue ->                           -- user_data : TInterface "GObject" "Value"
+    IO (Ptr Iterator)
+
+
+iteratorFilter ::
+    (MonadIO m) =>
+    Iterator                                -- _obj
+    -> GLib.CompareFunc                     -- func
+    -> GValue                               -- userData
+    -> m Iterator                           -- result
+iteratorFilter _obj func userData = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    func' <- GLib.mkCompareFunc (GLib.compareFuncWrapper Nothing func)
+    let userData' = unsafeManagedPtrGetPtr userData
+    result <- gst_iterator_filter _obj' func' userData'
+    checkUnexpectedReturnNULL "gst_iterator_filter" result
+    result' <- (wrapBoxed Iterator) result
+    safeFreeFunPtr $ castFunPtrToPtr func'
+    touchManagedPtr _obj
+    touchManagedPtr userData
+    return result'
+
+data IteratorFilterMethodInfo
+instance (signature ~ (GLib.CompareFunc -> GValue -> m Iterator), MonadIO m) => MethodInfo IteratorFilterMethodInfo Iterator signature where
+    overloadedMethod _ = iteratorFilter
+
+-- method Iterator::find_custom
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Iterator", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "func", argType = TInterface "GLib" "CompareFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, argClosure = 3, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "elem", argType = TInterface "GObject" "Value", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_iterator_find_custom" gst_iterator_find_custom :: 
+    Ptr Iterator ->                         -- _obj : TInterface "Gst" "Iterator"
+    FunPtr GLib.CompareFuncC ->             -- func : TInterface "GLib" "CompareFunc"
+    Ptr GValue ->                           -- elem : TInterface "GObject" "Value"
+    Ptr () ->                               -- user_data : TBasicType TVoid
+    IO CInt
+
+
+iteratorFindCustom ::
+    (MonadIO m) =>
+    Iterator                                -- _obj
+    -> GLib.CompareFunc                     -- func
+    -> m (Bool,GValue)                      -- result
+iteratorFindCustom _obj func = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    func' <- GLib.mkCompareFunc (GLib.compareFuncWrapper Nothing func)
+    elem <- callocBoxedBytes 24 :: IO (Ptr GValue)
+    let userData = nullPtr
+    result <- gst_iterator_find_custom _obj' func' elem userData
+    let result' = (/= 0) result
+    elem' <- (wrapBoxed GValue) elem
+    safeFreeFunPtr $ castFunPtrToPtr func'
+    touchManagedPtr _obj
+    return (result', elem')
+
+data IteratorFindCustomMethodInfo
+instance (signature ~ (GLib.CompareFunc -> m (Bool,GValue)), MonadIO m) => MethodInfo IteratorFindCustomMethodInfo Iterator signature where
+    overloadedMethod _ = iteratorFindCustom
+
+-- method Iterator::fold
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Iterator", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "func", argType = TInterface "Gst" "IteratorFoldFunction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, argClosure = 3, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "ret", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "IteratorResult"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_iterator_fold" gst_iterator_fold :: 
+    Ptr Iterator ->                         -- _obj : TInterface "Gst" "Iterator"
+    FunPtr IteratorFoldFunctionC ->         -- func : TInterface "Gst" "IteratorFoldFunction"
+    Ptr GValue ->                           -- ret : TInterface "GObject" "Value"
+    Ptr () ->                               -- user_data : TBasicType TVoid
+    IO CUInt
+
+
+iteratorFold ::
+    (MonadIO m) =>
+    Iterator                                -- _obj
+    -> IteratorFoldFunction                 -- func
+    -> GValue                               -- ret
+    -> m IteratorResult                     -- result
+iteratorFold _obj func ret = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    func' <- mkIteratorFoldFunction (iteratorFoldFunctionWrapper Nothing func)
+    let ret' = unsafeManagedPtrGetPtr ret
+    let userData = nullPtr
+    result <- gst_iterator_fold _obj' func' ret' userData
+    let result' = (toEnum . fromIntegral) result
+    safeFreeFunPtr $ castFunPtrToPtr func'
+    touchManagedPtr _obj
+    touchManagedPtr ret
+    return result'
+
+data IteratorFoldMethodInfo
+instance (signature ~ (IteratorFoldFunction -> GValue -> m IteratorResult), MonadIO m) => MethodInfo IteratorFoldMethodInfo Iterator signature where
+    overloadedMethod _ = iteratorFold
+
+-- method Iterator::foreach
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Iterator", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "func", argType = TInterface "Gst" "IteratorForeachFunction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "IteratorResult"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_iterator_foreach" gst_iterator_foreach :: 
+    Ptr Iterator ->                         -- _obj : TInterface "Gst" "Iterator"
+    FunPtr IteratorForeachFunctionC ->      -- func : TInterface "Gst" "IteratorForeachFunction"
+    Ptr () ->                               -- user_data : TBasicType TVoid
+    IO CUInt
+
+
+iteratorForeach ::
+    (MonadIO m) =>
+    Iterator                                -- _obj
+    -> IteratorForeachFunction              -- func
+    -> m IteratorResult                     -- result
+iteratorForeach _obj func = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    func' <- mkIteratorForeachFunction (iteratorForeachFunctionWrapper Nothing func)
+    let userData = nullPtr
+    result <- gst_iterator_foreach _obj' func' userData
+    let result' = (toEnum . fromIntegral) result
+    safeFreeFunPtr $ castFunPtrToPtr func'
+    touchManagedPtr _obj
+    return result'
+
+data IteratorForeachMethodInfo
+instance (signature ~ (IteratorForeachFunction -> m IteratorResult), MonadIO m) => MethodInfo IteratorForeachMethodInfo Iterator signature where
+    overloadedMethod _ = iteratorForeach
+
+-- method Iterator::free
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Iterator", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_iterator_free" gst_iterator_free :: 
+    Ptr Iterator ->                         -- _obj : TInterface "Gst" "Iterator"
+    IO ()
+
+
+iteratorFree ::
+    (MonadIO m) =>
+    Iterator                                -- _obj
+    -> m ()                                 -- result
+iteratorFree _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    gst_iterator_free _obj'
+    touchManagedPtr _obj
+    return ()
+
+data IteratorFreeMethodInfo
+instance (signature ~ (m ()), MonadIO m) => MethodInfo IteratorFreeMethodInfo Iterator signature where
+    overloadedMethod _ = iteratorFree
+
+-- method Iterator::next
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Iterator", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "elem", argType = TInterface "GObject" "Value", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "IteratorResult"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_iterator_next" gst_iterator_next :: 
+    Ptr Iterator ->                         -- _obj : TInterface "Gst" "Iterator"
+    Ptr GValue ->                           -- elem : TInterface "GObject" "Value"
+    IO CUInt
+
+
+iteratorNext ::
+    (MonadIO m) =>
+    Iterator                                -- _obj
+    -> m (IteratorResult,GValue)            -- result
+iteratorNext _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    elem <- callocBoxedBytes 24 :: IO (Ptr GValue)
+    result <- gst_iterator_next _obj' elem
+    let result' = (toEnum . fromIntegral) result
+    elem' <- (wrapBoxed GValue) elem
+    touchManagedPtr _obj
+    return (result', elem')
+
+data IteratorNextMethodInfo
+instance (signature ~ (m (IteratorResult,GValue)), MonadIO m) => MethodInfo IteratorNextMethodInfo Iterator signature where
+    overloadedMethod _ = iteratorNext
+
+-- method Iterator::push
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Iterator", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "other", argType = TInterface "Gst" "Iterator", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_iterator_push" gst_iterator_push :: 
+    Ptr Iterator ->                         -- _obj : TInterface "Gst" "Iterator"
+    Ptr Iterator ->                         -- other : TInterface "Gst" "Iterator"
+    IO ()
+
+
+iteratorPush ::
+    (MonadIO m) =>
+    Iterator                                -- _obj
+    -> Iterator                             -- other
+    -> m ()                                 -- result
+iteratorPush _obj other = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let other' = unsafeManagedPtrGetPtr other
+    gst_iterator_push _obj' other'
+    touchManagedPtr _obj
+    touchManagedPtr other
+    return ()
+
+data IteratorPushMethodInfo
+instance (signature ~ (Iterator -> m ()), MonadIO m) => MethodInfo IteratorPushMethodInfo Iterator signature where
+    overloadedMethod _ = iteratorPush
+
+-- method Iterator::resync
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Iterator", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_iterator_resync" gst_iterator_resync :: 
+    Ptr Iterator ->                         -- _obj : TInterface "Gst" "Iterator"
+    IO ()
+
+
+iteratorResync ::
+    (MonadIO m) =>
+    Iterator                                -- _obj
+    -> m ()                                 -- result
+iteratorResync _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    gst_iterator_resync _obj'
+    touchManagedPtr _obj
+    return ()
+
+data IteratorResyncMethodInfo
+instance (signature ~ (m ()), MonadIO m) => MethodInfo IteratorResyncMethodInfo Iterator signature where
+    overloadedMethod _ = iteratorResync
+
+type family ResolveIteratorMethod (t :: Symbol) (o :: *) :: * where
+    ResolveIteratorMethod "copy" o = IteratorCopyMethodInfo
+    ResolveIteratorMethod "filter" o = IteratorFilterMethodInfo
+    ResolveIteratorMethod "findCustom" o = IteratorFindCustomMethodInfo
+    ResolveIteratorMethod "fold" o = IteratorFoldMethodInfo
+    ResolveIteratorMethod "foreach" o = IteratorForeachMethodInfo
+    ResolveIteratorMethod "free" o = IteratorFreeMethodInfo
+    ResolveIteratorMethod "next" o = IteratorNextMethodInfo
+    ResolveIteratorMethod "push" o = IteratorPushMethodInfo
+    ResolveIteratorMethod "resync" o = IteratorResyncMethodInfo
+    ResolveIteratorMethod l o = MethodResolutionFailed l o
+
+instance (info ~ ResolveIteratorMethod t Iterator, MethodInfo info Iterator p) => IsLabelProxy t (Iterator -> p) where
+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)
+
+#if MIN_VERSION_base(4,9,0)
+instance (info ~ ResolveIteratorMethod t Iterator, MethodInfo info Iterator p) => IsLabel t (Iterator -> p) where
+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)
+#endif
+
+
diff --git a/GI/Gst/Structs/Iterator.hs-boot b/GI/Gst/Structs/Iterator.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/Iterator.hs-boot
@@ -0,0 +1,20 @@
+module GI.Gst.Structs.Iterator where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+newtype Iterator = Iterator (ForeignPtr Iterator)
+instance BoxedObject Iterator where
+data IteratorCopyMethodInfo
+data IteratorFilterMethodInfo
+data IteratorFindCustomMethodInfo
+data IteratorFoldMethodInfo
+data IteratorForeachMethodInfo
+data IteratorFreeMethodInfo
+data IteratorNextMethodInfo
+data IteratorPushMethodInfo
+data IteratorResyncMethodInfo
diff --git a/GI/Gst/Structs/MapInfo.hs b/GI/Gst/Structs/MapInfo.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/MapInfo.hs
@@ -0,0 +1,97 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+
+A structure containing the result of a map operation such as
+gst_memory_map(). It contains the data and size.
+-}
+
+module GI.Gst.Structs.MapInfo
+    ( 
+
+-- * Exported types
+    MapInfo(..)                             ,
+    newZeroMapInfo                          ,
+    noMapInfo                               ,
+
+
+ -- * Properties
+-- ** Flags
+    mapInfoReadFlags                        ,
+
+
+-- ** Maxsize
+    mapInfoReadMaxsize                      ,
+
+
+-- ** Memory
+    mapInfoReadMemory                       ,
+
+
+-- ** Size
+    mapInfoReadSize                         ,
+
+
+
+
+    ) where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+import GI.Gst.Callbacks
+
+newtype MapInfo = MapInfo (ForeignPtr MapInfo)
+-- | Construct a `MapInfo` struct initialized to zero.
+newZeroMapInfo :: MonadIO m => m MapInfo
+newZeroMapInfo = liftIO $ callocBytes 104 >>= wrapPtr MapInfo
+
+noMapInfo :: Maybe MapInfo
+noMapInfo = Nothing
+
+mapInfoReadMemory :: MapInfo -> IO Memory
+mapInfoReadMemory s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 0) :: IO (Ptr Memory)
+    val' <- (newBoxed Memory) val
+    return val'
+
+mapInfoReadFlags :: MapInfo -> IO [MapFlags]
+mapInfoReadFlags s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 8) :: IO CUInt
+    let val' = wordToGFlags val
+    return val'
+
+-- XXX Skipped getter for "MapInfo:data" :: Not implemented: "Don't know how to unpack C array of type TCArray False (-1) 3 (TBasicType TUInt8)"
+
+mapInfoReadSize :: MapInfo -> IO Word64
+mapInfoReadSize s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 24) :: IO Word64
+    return val
+
+mapInfoReadMaxsize :: MapInfo -> IO Word64
+mapInfoReadMaxsize s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 32) :: IO Word64
+    return val
+
+-- XXX Skipped getter for "MapInfo:user_data" :: Not implemented: "Don't know how to unpack C array of type TCArray False 4 (-1) (TBasicType TVoid)"
+
+type family ResolveMapInfoMethod (t :: Symbol) (o :: *) :: * where
+    ResolveMapInfoMethod l o = MethodResolutionFailed l o
+
+instance (info ~ ResolveMapInfoMethod t MapInfo, MethodInfo info MapInfo p) => IsLabelProxy t (MapInfo -> p) where
+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)
+
+#if MIN_VERSION_base(4,9,0)
+instance (info ~ ResolveMapInfoMethod t MapInfo, MethodInfo info MapInfo p) => IsLabel t (MapInfo -> p) where
+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)
+#endif
+
+
diff --git a/GI/Gst/Structs/MapInfo.hs-boot b/GI/Gst/Structs/MapInfo.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/MapInfo.hs-boot
@@ -0,0 +1,10 @@
+module GI.Gst.Structs.MapInfo where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+newtype MapInfo = MapInfo (ForeignPtr MapInfo)
diff --git a/GI/Gst/Structs/Memory.hs b/GI/Gst/Structs/Memory.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/Memory.hs
@@ -0,0 +1,562 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+
+GstMemory is a lightweight refcounted object that wraps a region of memory.
+They are typically used to manage the data of a #GstBuffer.
+
+A GstMemory object has an allocated region of memory of maxsize. The maximum
+size does not change during the lifetime of the memory object. The memory
+also has an offset and size property that specifies the valid range of memory
+in the allocated region.
+
+Memory is usually created by allocators with a gst_allocator_alloc()
+method call. When %NULL is used as the allocator, the default allocator will
+be used.
+
+New allocators can be registered with gst_allocator_register().
+Allocators are identified by name and can be retrieved with
+gst_allocator_find(). gst_allocator_set_default() can be used to change the
+default allocator.
+
+New memory can be created with gst_memory_new_wrapped() that wraps the memory
+allocated elsewhere.
+
+Refcounting of the memory block is performed with gst_memory_ref() and
+gst_memory_unref().
+
+The size of the memory can be retrieved and changed with
+gst_memory_get_sizes() and gst_memory_resize() respectively.
+
+Getting access to the data of the memory is performed with gst_memory_map().
+The call will return a pointer to offset bytes into the region of memory.
+After the memory access is completed, gst_memory_unmap() should be called.
+
+Memory can be copied with gst_memory_copy(), which will return a writable
+copy. gst_memory_share() will create a new memory block that shares the
+memory with an existing memory block at a custom offset and with a custom
+size.
+
+Memory can be efficiently merged when gst_memory_is_span() returns %TRUE.
+-}
+
+module GI.Gst.Structs.Memory
+    ( 
+
+-- * Exported types
+    Memory(..)                              ,
+    newZeroMemory                           ,
+    noMemory                                ,
+
+
+ -- * Methods
+-- ** memoryCopy
+    MemoryCopyMethodInfo                    ,
+    memoryCopy                              ,
+
+
+-- ** memoryGetSizes
+    MemoryGetSizesMethodInfo                ,
+    memoryGetSizes                          ,
+
+
+-- ** memoryIsSpan
+    MemoryIsSpanMethodInfo                  ,
+    memoryIsSpan                            ,
+
+
+-- ** memoryIsType
+    MemoryIsTypeMethodInfo                  ,
+    memoryIsType                            ,
+
+
+-- ** memoryMakeMapped
+    MemoryMakeMappedMethodInfo              ,
+    memoryMakeMapped                        ,
+
+
+-- ** memoryMap
+    MemoryMapMethodInfo                     ,
+    memoryMap                               ,
+
+
+-- ** memoryNewWrapped
+    memoryNewWrapped                        ,
+
+
+-- ** memoryResize
+    MemoryResizeMethodInfo                  ,
+    memoryResize                            ,
+
+
+-- ** memoryShare
+    MemoryShareMethodInfo                   ,
+    memoryShare                             ,
+
+
+-- ** memoryUnmap
+    MemoryUnmapMethodInfo                   ,
+    memoryUnmap                             ,
+
+
+
+
+ -- * Properties
+-- ** Align
+    memoryReadAlign                         ,
+
+
+-- ** Allocator
+    memoryReadAllocator                     ,
+
+
+-- ** Maxsize
+    memoryReadMaxsize                       ,
+
+
+-- ** MiniObject
+    memoryReadMiniObject                    ,
+
+
+-- ** Offset
+    memoryReadOffset                        ,
+
+
+-- ** Parent
+    memoryReadParent                        ,
+
+
+-- ** Size
+    memoryReadSize                          ,
+
+
+
+
+    ) where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+import GI.Gst.Callbacks
+import qualified GI.GLib as GLib
+
+newtype Memory = Memory (ForeignPtr Memory)
+foreign import ccall "gst_memory_get_type" c_gst_memory_get_type :: 
+    IO GType
+
+instance BoxedObject Memory where
+    boxedType _ = c_gst_memory_get_type
+
+-- | Construct a `Memory` struct initialized to zero.
+newZeroMemory :: MonadIO m => m Memory
+newZeroMemory = liftIO $ callocBoxedBytes 112 >>= wrapBoxed Memory
+
+noMemory :: Maybe Memory
+noMemory = Nothing
+
+memoryReadMiniObject :: Memory -> IO MiniObject
+memoryReadMiniObject s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 0) :: IO (Ptr MiniObject)
+    val' <- (newPtr 64 MiniObject) val
+    return val'
+
+memoryReadAllocator :: Memory -> IO Allocator
+memoryReadAllocator s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 64) :: IO (Ptr Allocator)
+    val' <- (newObject Allocator) val
+    return val'
+
+memoryReadParent :: Memory -> IO Memory
+memoryReadParent s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 72) :: IO (Ptr Memory)
+    val' <- (newBoxed Memory) val
+    return val'
+
+memoryReadMaxsize :: Memory -> IO Word64
+memoryReadMaxsize s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 80) :: IO Word64
+    return val
+
+memoryReadAlign :: Memory -> IO Word64
+memoryReadAlign s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 88) :: IO Word64
+    return val
+
+memoryReadOffset :: Memory -> IO Word64
+memoryReadOffset s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 96) :: IO Word64
+    return val
+
+memoryReadSize :: Memory -> IO Word64
+memoryReadSize s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 104) :: IO Word64
+    return val
+
+-- method Memory::new_wrapped
+-- method type : Constructor
+-- Args : [Arg {argCName = "flags", argType = TInterface "Gst" "MemoryFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TCArray False (-1) 4 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "maxsize", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "notify", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : [Arg {argCName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- returnType : TInterface "Gst" "Memory"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_memory_new_wrapped" gst_memory_new_wrapped :: 
+    CUInt ->                                -- flags : TInterface "Gst" "MemoryFlags"
+    Ptr Word8 ->                            -- data : TCArray False (-1) 4 (TBasicType TUInt8)
+    Word64 ->                               -- maxsize : TBasicType TUInt64
+    Word64 ->                               -- offset : TBasicType TUInt64
+    Word64 ->                               -- size : TBasicType TUInt64
+    Ptr () ->                               -- user_data : TBasicType TVoid
+    FunPtr GLib.DestroyNotifyC ->           -- notify : TInterface "GLib" "DestroyNotify"
+    IO (Ptr Memory)
+
+
+memoryNewWrapped ::
+    (MonadIO m) =>
+    [MemoryFlags]                           -- flags
+    -> ByteString                           -- data_
+    -> Word64                               -- maxsize
+    -> Word64                               -- offset
+    -> Maybe (GLib.DestroyNotify)           -- notify
+    -> m Memory                             -- result
+memoryNewWrapped flags data_ maxsize offset notify = liftIO $ do
+    let size = fromIntegral $ B.length data_
+    let flags' = gflagsToWord flags
+    data_' <- packByteString data_
+    ptrnotify <- callocMem :: IO (Ptr (FunPtr GLib.DestroyNotifyC))
+    maybeNotify <- case notify of
+        Nothing -> return (castPtrToFunPtr nullPtr)
+        Just jNotify -> do
+            jNotify' <- GLib.mkDestroyNotify (GLib.destroyNotifyWrapper (Just ptrnotify) jNotify)
+            poke ptrnotify jNotify'
+            return jNotify'
+    let userData = nullPtr
+    result <- gst_memory_new_wrapped flags' data_' maxsize offset size userData maybeNotify
+    checkUnexpectedReturnNULL "gst_memory_new_wrapped" result
+    result' <- (wrapBoxed Memory) result
+    freeMem data_'
+    return result'
+
+-- method Memory::copy
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Memory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Memory"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_memory_copy" gst_memory_copy :: 
+    Ptr Memory ->                           -- _obj : TInterface "Gst" "Memory"
+    Int64 ->                                -- offset : TBasicType TInt64
+    Int64 ->                                -- size : TBasicType TInt64
+    IO (Ptr Memory)
+
+
+memoryCopy ::
+    (MonadIO m) =>
+    Memory                                  -- _obj
+    -> Int64                                -- offset
+    -> Int64                                -- size
+    -> m Memory                             -- result
+memoryCopy _obj offset size = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_memory_copy _obj' offset size
+    checkUnexpectedReturnNULL "gst_memory_copy" result
+    result' <- (wrapBoxed Memory) result
+    touchManagedPtr _obj
+    return result'
+
+data MemoryCopyMethodInfo
+instance (signature ~ (Int64 -> Int64 -> m Memory), MonadIO m) => MethodInfo MemoryCopyMethodInfo Memory signature where
+    overloadedMethod _ = memoryCopy
+
+-- method Memory::get_sizes
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Memory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "maxsize", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUInt64
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_memory_get_sizes" gst_memory_get_sizes :: 
+    Ptr Memory ->                           -- _obj : TInterface "Gst" "Memory"
+    Word64 ->                               -- offset : TBasicType TUInt64
+    Word64 ->                               -- maxsize : TBasicType TUInt64
+    IO Word64
+
+
+memoryGetSizes ::
+    (MonadIO m) =>
+    Memory                                  -- _obj
+    -> Word64                               -- offset
+    -> Word64                               -- maxsize
+    -> m Word64                             -- result
+memoryGetSizes _obj offset maxsize = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_memory_get_sizes _obj' offset maxsize
+    touchManagedPtr _obj
+    return result
+
+data MemoryGetSizesMethodInfo
+instance (signature ~ (Word64 -> Word64 -> m Word64), MonadIO m) => MethodInfo MemoryGetSizesMethodInfo Memory signature where
+    overloadedMethod _ = memoryGetSizes
+
+-- method Memory::is_span
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Memory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mem2", argType = TInterface "Gst" "Memory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_memory_is_span" gst_memory_is_span :: 
+    Ptr Memory ->                           -- _obj : TInterface "Gst" "Memory"
+    Ptr Memory ->                           -- mem2 : TInterface "Gst" "Memory"
+    Word64 ->                               -- offset : TBasicType TUInt64
+    IO CInt
+
+
+memoryIsSpan ::
+    (MonadIO m) =>
+    Memory                                  -- _obj
+    -> Memory                               -- mem2
+    -> Word64                               -- offset
+    -> m Bool                               -- result
+memoryIsSpan _obj mem2 offset = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let mem2' = unsafeManagedPtrGetPtr mem2
+    result <- gst_memory_is_span _obj' mem2' offset
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    touchManagedPtr mem2
+    return result'
+
+data MemoryIsSpanMethodInfo
+instance (signature ~ (Memory -> Word64 -> m Bool), MonadIO m) => MethodInfo MemoryIsSpanMethodInfo Memory signature where
+    overloadedMethod _ = memoryIsSpan
+
+-- method Memory::is_type
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Memory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mem_type", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_memory_is_type" gst_memory_is_type :: 
+    Ptr Memory ->                           -- _obj : TInterface "Gst" "Memory"
+    CString ->                              -- mem_type : TBasicType TUTF8
+    IO CInt
+
+
+memoryIsType ::
+    (MonadIO m) =>
+    Memory                                  -- _obj
+    -> T.Text                               -- memType
+    -> m Bool                               -- result
+memoryIsType _obj memType = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    memType' <- textToCString memType
+    result <- gst_memory_is_type _obj' memType'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    freeMem memType'
+    return result'
+
+data MemoryIsTypeMethodInfo
+instance (signature ~ (T.Text -> m Bool), MonadIO m) => MethodInfo MemoryIsTypeMethodInfo Memory signature where
+    overloadedMethod _ = memoryIsType
+
+-- method Memory::make_mapped
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Memory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "info", argType = TInterface "Gst" "MapInfo", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface "Gst" "MapFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Memory"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_memory_make_mapped" gst_memory_make_mapped :: 
+    Ptr Memory ->                           -- _obj : TInterface "Gst" "Memory"
+    Ptr MapInfo ->                          -- info : TInterface "Gst" "MapInfo"
+    CUInt ->                                -- flags : TInterface "Gst" "MapFlags"
+    IO (Ptr Memory)
+
+
+memoryMakeMapped ::
+    (MonadIO m) =>
+    Memory                                  -- _obj
+    -> [MapFlags]                           -- flags
+    -> m (Memory,MapInfo)                   -- result
+memoryMakeMapped _obj flags = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    info <- callocBytes 104 :: IO (Ptr MapInfo)
+    let flags' = gflagsToWord flags
+    result <- gst_memory_make_mapped _obj' info flags'
+    checkUnexpectedReturnNULL "gst_memory_make_mapped" result
+    result' <- (wrapBoxed Memory) result
+    info' <- (wrapPtr MapInfo) info
+    touchManagedPtr _obj
+    return (result', info')
+
+data MemoryMakeMappedMethodInfo
+instance (signature ~ ([MapFlags] -> m (Memory,MapInfo)), MonadIO m) => MethodInfo MemoryMakeMappedMethodInfo Memory signature where
+    overloadedMethod _ = memoryMakeMapped
+
+-- method Memory::map
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Memory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "info", argType = TInterface "Gst" "MapInfo", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface "Gst" "MapFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_memory_map" gst_memory_map :: 
+    Ptr Memory ->                           -- _obj : TInterface "Gst" "Memory"
+    Ptr MapInfo ->                          -- info : TInterface "Gst" "MapInfo"
+    CUInt ->                                -- flags : TInterface "Gst" "MapFlags"
+    IO CInt
+
+
+memoryMap ::
+    (MonadIO m) =>
+    Memory                                  -- _obj
+    -> [MapFlags]                           -- flags
+    -> m (Bool,MapInfo)                     -- result
+memoryMap _obj flags = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    info <- callocBytes 104 :: IO (Ptr MapInfo)
+    let flags' = gflagsToWord flags
+    result <- gst_memory_map _obj' info flags'
+    let result' = (/= 0) result
+    info' <- (wrapPtr MapInfo) info
+    touchManagedPtr _obj
+    return (result', info')
+
+data MemoryMapMethodInfo
+instance (signature ~ ([MapFlags] -> m (Bool,MapInfo)), MonadIO m) => MethodInfo MemoryMapMethodInfo Memory signature where
+    overloadedMethod _ = memoryMap
+
+-- method Memory::resize
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Memory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_memory_resize" gst_memory_resize :: 
+    Ptr Memory ->                           -- _obj : TInterface "Gst" "Memory"
+    Int64 ->                                -- offset : TBasicType TInt64
+    Word64 ->                               -- size : TBasicType TUInt64
+    IO ()
+
+
+memoryResize ::
+    (MonadIO m) =>
+    Memory                                  -- _obj
+    -> Int64                                -- offset
+    -> Word64                               -- size
+    -> m ()                                 -- result
+memoryResize _obj offset size = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    gst_memory_resize _obj' offset size
+    touchManagedPtr _obj
+    return ()
+
+data MemoryResizeMethodInfo
+instance (signature ~ (Int64 -> Word64 -> m ()), MonadIO m) => MethodInfo MemoryResizeMethodInfo Memory signature where
+    overloadedMethod _ = memoryResize
+
+-- method Memory::share
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Memory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Memory"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_memory_share" gst_memory_share :: 
+    Ptr Memory ->                           -- _obj : TInterface "Gst" "Memory"
+    Int64 ->                                -- offset : TBasicType TInt64
+    Int64 ->                                -- size : TBasicType TInt64
+    IO (Ptr Memory)
+
+
+memoryShare ::
+    (MonadIO m) =>
+    Memory                                  -- _obj
+    -> Int64                                -- offset
+    -> Int64                                -- size
+    -> m Memory                             -- result
+memoryShare _obj offset size = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_memory_share _obj' offset size
+    checkUnexpectedReturnNULL "gst_memory_share" result
+    result' <- (wrapBoxed Memory) result
+    touchManagedPtr _obj
+    return result'
+
+data MemoryShareMethodInfo
+instance (signature ~ (Int64 -> Int64 -> m Memory), MonadIO m) => MethodInfo MemoryShareMethodInfo Memory signature where
+    overloadedMethod _ = memoryShare
+
+-- method Memory::unmap
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Memory", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "info", argType = TInterface "Gst" "MapInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_memory_unmap" gst_memory_unmap :: 
+    Ptr Memory ->                           -- _obj : TInterface "Gst" "Memory"
+    Ptr MapInfo ->                          -- info : TInterface "Gst" "MapInfo"
+    IO ()
+
+
+memoryUnmap ::
+    (MonadIO m) =>
+    Memory                                  -- _obj
+    -> MapInfo                              -- info
+    -> m ()                                 -- result
+memoryUnmap _obj info = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let info' = unsafeManagedPtrGetPtr info
+    gst_memory_unmap _obj' info'
+    touchManagedPtr _obj
+    touchManagedPtr info
+    return ()
+
+data MemoryUnmapMethodInfo
+instance (signature ~ (MapInfo -> m ()), MonadIO m) => MethodInfo MemoryUnmapMethodInfo Memory signature where
+    overloadedMethod _ = memoryUnmap
+
+type family ResolveMemoryMethod (t :: Symbol) (o :: *) :: * where
+    ResolveMemoryMethod "copy" o = MemoryCopyMethodInfo
+    ResolveMemoryMethod "isSpan" o = MemoryIsSpanMethodInfo
+    ResolveMemoryMethod "isType" o = MemoryIsTypeMethodInfo
+    ResolveMemoryMethod "makeMapped" o = MemoryMakeMappedMethodInfo
+    ResolveMemoryMethod "map" o = MemoryMapMethodInfo
+    ResolveMemoryMethod "resize" o = MemoryResizeMethodInfo
+    ResolveMemoryMethod "share" o = MemoryShareMethodInfo
+    ResolveMemoryMethod "unmap" o = MemoryUnmapMethodInfo
+    ResolveMemoryMethod "getSizes" o = MemoryGetSizesMethodInfo
+    ResolveMemoryMethod l o = MethodResolutionFailed l o
+
+instance (info ~ ResolveMemoryMethod t Memory, MethodInfo info Memory p) => IsLabelProxy t (Memory -> p) where
+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)
+
+#if MIN_VERSION_base(4,9,0)
+instance (info ~ ResolveMemoryMethod t Memory, MethodInfo info Memory p) => IsLabel t (Memory -> p) where
+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)
+#endif
+
+
diff --git a/GI/Gst/Structs/Memory.hs-boot b/GI/Gst/Structs/Memory.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/Memory.hs-boot
@@ -0,0 +1,20 @@
+module GI.Gst.Structs.Memory where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+newtype Memory = Memory (ForeignPtr Memory)
+instance BoxedObject Memory where
+data MemoryCopyMethodInfo
+data MemoryGetSizesMethodInfo
+data MemoryIsSpanMethodInfo
+data MemoryIsTypeMethodInfo
+data MemoryMakeMappedMethodInfo
+data MemoryMapMethodInfo
+data MemoryResizeMethodInfo
+data MemoryShareMethodInfo
+data MemoryUnmapMethodInfo
diff --git a/GI/Gst/Structs/Message.hs b/GI/Gst/Structs/Message.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/Message.hs
@@ -0,0 +1,3035 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+
+Messages are implemented as a subclass of #GstMiniObject with a generic
+#GstStructure as the content. This allows for writing custom messages without
+requiring an API change while allowing a wide range of different types
+of messages.
+
+Messages are posted by objects in the pipeline and are passed to the
+application using the #GstBus.
+
+The basic use pattern of posting a message on a #GstBus is as follows:
+|[
+  gst_bus_post (bus, gst_message_new_eos());
+]|
+
+A #GstElement usually posts messages on the bus provided by the parent
+container using gst_element_post_message().
+-}
+
+module GI.Gst.Structs.Message
+    ( 
+
+-- * Exported types
+    Message(..)                             ,
+    newZeroMessage                          ,
+    noMessage                               ,
+
+
+ -- * Methods
+-- ** messageGetSeqnum
+    MessageGetSeqnumMethodInfo              ,
+    messageGetSeqnum                        ,
+
+
+-- ** messageGetStreamStatusObject
+    MessageGetStreamStatusObjectMethodInfo  ,
+    messageGetStreamStatusObject            ,
+
+
+-- ** messageGetStructure
+    MessageGetStructureMethodInfo           ,
+    messageGetStructure                     ,
+
+
+-- ** messageHasName
+    MessageHasNameMethodInfo                ,
+    messageHasName                          ,
+
+
+-- ** messageNewApplication
+    messageNewApplication                   ,
+
+
+-- ** messageNewAsyncDone
+    messageNewAsyncDone                     ,
+
+
+-- ** messageNewAsyncStart
+    messageNewAsyncStart                    ,
+
+
+-- ** messageNewBuffering
+    messageNewBuffering                     ,
+
+
+-- ** messageNewClockLost
+    messageNewClockLost                     ,
+
+
+-- ** messageNewClockProvide
+    messageNewClockProvide                  ,
+
+
+-- ** messageNewCustom
+    messageNewCustom                        ,
+
+
+-- ** messageNewDeviceAdded
+    messageNewDeviceAdded                   ,
+
+
+-- ** messageNewDeviceRemoved
+    messageNewDeviceRemoved                 ,
+
+
+-- ** messageNewDurationChanged
+    messageNewDurationChanged               ,
+
+
+-- ** messageNewElement
+    messageNewElement                       ,
+
+
+-- ** messageNewEos
+    messageNewEos                           ,
+
+
+-- ** messageNewError
+    messageNewError                         ,
+
+
+-- ** messageNewHaveContext
+    messageNewHaveContext                   ,
+
+
+-- ** messageNewInfo
+    messageNewInfo                          ,
+
+
+-- ** messageNewLatency
+    messageNewLatency                       ,
+
+
+-- ** messageNewNeedContext
+    messageNewNeedContext                   ,
+
+
+-- ** messageNewNewClock
+    messageNewNewClock                      ,
+
+
+-- ** messageNewProgress
+    messageNewProgress                      ,
+
+
+-- ** messageNewQos
+    messageNewQos                           ,
+
+
+-- ** messageNewRequestState
+    messageNewRequestState                  ,
+
+
+-- ** messageNewResetTime
+    messageNewResetTime                     ,
+
+
+-- ** messageNewSegmentDone
+    messageNewSegmentDone                   ,
+
+
+-- ** messageNewSegmentStart
+    messageNewSegmentStart                  ,
+
+
+-- ** messageNewStateChanged
+    messageNewStateChanged                  ,
+
+
+-- ** messageNewStateDirty
+    messageNewStateDirty                    ,
+
+
+-- ** messageNewStepDone
+    messageNewStepDone                      ,
+
+
+-- ** messageNewStepStart
+    messageNewStepStart                     ,
+
+
+-- ** messageNewStreamStart
+    messageNewStreamStart                   ,
+
+
+-- ** messageNewStreamStatus
+    messageNewStreamStatus                  ,
+
+
+-- ** messageNewStructureChange
+    messageNewStructureChange               ,
+
+
+-- ** messageNewTag
+    messageNewTag                           ,
+
+
+-- ** messageNewToc
+    messageNewToc                           ,
+
+
+-- ** messageNewWarning
+    messageNewWarning                       ,
+
+
+-- ** messageParseAsyncDone
+    MessageParseAsyncDoneMethodInfo         ,
+    messageParseAsyncDone                   ,
+
+
+-- ** messageParseBuffering
+    MessageParseBufferingMethodInfo         ,
+    messageParseBuffering                   ,
+
+
+-- ** messageParseBufferingStats
+    MessageParseBufferingStatsMethodInfo    ,
+    messageParseBufferingStats              ,
+
+
+-- ** messageParseClockLost
+    MessageParseClockLostMethodInfo         ,
+    messageParseClockLost                   ,
+
+
+-- ** messageParseClockProvide
+    MessageParseClockProvideMethodInfo      ,
+    messageParseClockProvide                ,
+
+
+-- ** messageParseContextType
+    MessageParseContextTypeMethodInfo       ,
+    messageParseContextType                 ,
+
+
+-- ** messageParseDeviceAdded
+    MessageParseDeviceAddedMethodInfo       ,
+    messageParseDeviceAdded                 ,
+
+
+-- ** messageParseDeviceRemoved
+    MessageParseDeviceRemovedMethodInfo     ,
+    messageParseDeviceRemoved               ,
+
+
+-- ** messageParseError
+    MessageParseErrorMethodInfo             ,
+    messageParseError                       ,
+
+
+-- ** messageParseGroupId
+    MessageParseGroupIdMethodInfo           ,
+    messageParseGroupId                     ,
+
+
+-- ** messageParseHaveContext
+    MessageParseHaveContextMethodInfo       ,
+    messageParseHaveContext                 ,
+
+
+-- ** messageParseInfo
+    MessageParseInfoMethodInfo              ,
+    messageParseInfo                        ,
+
+
+-- ** messageParseNewClock
+    MessageParseNewClockMethodInfo          ,
+    messageParseNewClock                    ,
+
+
+-- ** messageParseProgress
+    MessageParseProgressMethodInfo          ,
+    messageParseProgress                    ,
+
+
+-- ** messageParseQos
+    MessageParseQosMethodInfo               ,
+    messageParseQos                         ,
+
+
+-- ** messageParseQosStats
+    MessageParseQosStatsMethodInfo          ,
+    messageParseQosStats                    ,
+
+
+-- ** messageParseQosValues
+    MessageParseQosValuesMethodInfo         ,
+    messageParseQosValues                   ,
+
+
+-- ** messageParseRequestState
+    MessageParseRequestStateMethodInfo      ,
+    messageParseRequestState                ,
+
+
+-- ** messageParseResetTime
+    MessageParseResetTimeMethodInfo         ,
+    messageParseResetTime                   ,
+
+
+-- ** messageParseSegmentDone
+    MessageParseSegmentDoneMethodInfo       ,
+    messageParseSegmentDone                 ,
+
+
+-- ** messageParseSegmentStart
+    MessageParseSegmentStartMethodInfo      ,
+    messageParseSegmentStart                ,
+
+
+-- ** messageParseStateChanged
+    MessageParseStateChangedMethodInfo      ,
+    messageParseStateChanged                ,
+
+
+-- ** messageParseStepDone
+    MessageParseStepDoneMethodInfo          ,
+    messageParseStepDone                    ,
+
+
+-- ** messageParseStepStart
+    MessageParseStepStartMethodInfo         ,
+    messageParseStepStart                   ,
+
+
+-- ** messageParseStreamStatus
+    MessageParseStreamStatusMethodInfo      ,
+    messageParseStreamStatus                ,
+
+
+-- ** messageParseStructureChange
+    MessageParseStructureChangeMethodInfo   ,
+    messageParseStructureChange             ,
+
+
+-- ** messageParseTag
+    MessageParseTagMethodInfo               ,
+    messageParseTag                         ,
+
+
+-- ** messageParseToc
+    MessageParseTocMethodInfo               ,
+    messageParseToc                         ,
+
+
+-- ** messageParseWarning
+    MessageParseWarningMethodInfo           ,
+    messageParseWarning                     ,
+
+
+-- ** messageSetBufferingStats
+    MessageSetBufferingStatsMethodInfo      ,
+    messageSetBufferingStats                ,
+
+
+-- ** messageSetGroupId
+    MessageSetGroupIdMethodInfo             ,
+    messageSetGroupId                       ,
+
+
+-- ** messageSetQosStats
+    MessageSetQosStatsMethodInfo            ,
+    messageSetQosStats                      ,
+
+
+-- ** messageSetQosValues
+    MessageSetQosValuesMethodInfo           ,
+    messageSetQosValues                     ,
+
+
+-- ** messageSetSeqnum
+    MessageSetSeqnumMethodInfo              ,
+    messageSetSeqnum                        ,
+
+
+-- ** messageSetStreamStatusObject
+    MessageSetStreamStatusObjectMethodInfo  ,
+    messageSetStreamStatusObject            ,
+
+
+
+
+ -- * Properties
+-- ** MiniObject
+    messageReadMiniObject                   ,
+
+
+-- ** Seqnum
+    messageReadSeqnum                       ,
+
+
+-- ** Src
+    messageReadSrc                          ,
+
+
+-- ** Timestamp
+    messageReadTimestamp                    ,
+
+
+-- ** Type
+    messageReadType                         ,
+
+
+
+
+    ) where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+import GI.Gst.Callbacks
+
+newtype Message = Message (ForeignPtr Message)
+foreign import ccall "gst_message_get_type" c_gst_message_get_type :: 
+    IO GType
+
+instance BoxedObject Message where
+    boxedType _ = c_gst_message_get_type
+
+-- | Construct a `Message` struct initialized to zero.
+newZeroMessage :: MonadIO m => m Message
+newZeroMessage = liftIO $ callocBoxedBytes 120 >>= wrapBoxed Message
+
+noMessage :: Maybe Message
+noMessage = Nothing
+
+messageReadMiniObject :: Message -> IO MiniObject
+messageReadMiniObject s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 0) :: IO (Ptr MiniObject)
+    val' <- (newPtr 64 MiniObject) val
+    return val'
+
+messageReadType :: Message -> IO [MessageType]
+messageReadType s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 64) :: IO CUInt
+    let val' = wordToGFlags val
+    return val'
+
+messageReadTimestamp :: Message -> IO Word64
+messageReadTimestamp s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 72) :: IO Word64
+    return val
+
+messageReadSrc :: Message -> IO Object
+messageReadSrc s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 80) :: IO (Ptr Object)
+    val' <- (newObject Object) val
+    return val'
+
+messageReadSeqnum :: Message -> IO Word32
+messageReadSeqnum s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 88) :: IO Word32
+    return val
+
+-- method Message::new_application
+-- method type : Constructor
+-- Args : [Arg {argCName = "src", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "structure", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Message"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_message_new_application" gst_message_new_application :: 
+    Ptr Object ->                           -- src : TInterface "Gst" "Object"
+    Ptr Structure ->                        -- structure : TInterface "Gst" "Structure"
+    IO (Ptr Message)
+
+
+messageNewApplication ::
+    (MonadIO m, ObjectK a) =>
+    Maybe (a)                               -- src
+    -> Structure                            -- structure
+    -> m Message                            -- result
+messageNewApplication src structure = liftIO $ do
+    maybeSrc <- case src of
+        Nothing -> return nullPtr
+        Just jSrc -> do
+            let jSrc' = unsafeManagedPtrCastPtr jSrc
+            return jSrc'
+    structure' <- copyBoxed structure
+    result <- gst_message_new_application maybeSrc structure'
+    checkUnexpectedReturnNULL "gst_message_new_application" result
+    result' <- (wrapBoxed Message) result
+    whenJust src touchManagedPtr
+    touchManagedPtr structure
+    return result'
+
+-- method Message::new_async_done
+-- method type : Constructor
+-- Args : [Arg {argCName = "src", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "running_time", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Message"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_message_new_async_done" gst_message_new_async_done :: 
+    Ptr Object ->                           -- src : TInterface "Gst" "Object"
+    Word64 ->                               -- running_time : TBasicType TUInt64
+    IO (Ptr Message)
+
+
+messageNewAsyncDone ::
+    (MonadIO m, ObjectK a) =>
+    Maybe (a)                               -- src
+    -> Word64                               -- runningTime
+    -> m Message                            -- result
+messageNewAsyncDone src runningTime = liftIO $ do
+    maybeSrc <- case src of
+        Nothing -> return nullPtr
+        Just jSrc -> do
+            let jSrc' = unsafeManagedPtrCastPtr jSrc
+            return jSrc'
+    result <- gst_message_new_async_done maybeSrc runningTime
+    checkUnexpectedReturnNULL "gst_message_new_async_done" result
+    result' <- (wrapBoxed Message) result
+    whenJust src touchManagedPtr
+    return result'
+
+-- method Message::new_async_start
+-- method type : Constructor
+-- Args : [Arg {argCName = "src", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Message"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_message_new_async_start" gst_message_new_async_start :: 
+    Ptr Object ->                           -- src : TInterface "Gst" "Object"
+    IO (Ptr Message)
+
+
+messageNewAsyncStart ::
+    (MonadIO m, ObjectK a) =>
+    Maybe (a)                               -- src
+    -> m Message                            -- result
+messageNewAsyncStart src = liftIO $ do
+    maybeSrc <- case src of
+        Nothing -> return nullPtr
+        Just jSrc -> do
+            let jSrc' = unsafeManagedPtrCastPtr jSrc
+            return jSrc'
+    result <- gst_message_new_async_start maybeSrc
+    checkUnexpectedReturnNULL "gst_message_new_async_start" result
+    result' <- (wrapBoxed Message) result
+    whenJust src touchManagedPtr
+    return result'
+
+-- method Message::new_buffering
+-- method type : Constructor
+-- Args : [Arg {argCName = "src", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "percent", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Message"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_message_new_buffering" gst_message_new_buffering :: 
+    Ptr Object ->                           -- src : TInterface "Gst" "Object"
+    Int32 ->                                -- percent : TBasicType TInt32
+    IO (Ptr Message)
+
+
+messageNewBuffering ::
+    (MonadIO m, ObjectK a) =>
+    Maybe (a)                               -- src
+    -> Int32                                -- percent
+    -> m Message                            -- result
+messageNewBuffering src percent = liftIO $ do
+    maybeSrc <- case src of
+        Nothing -> return nullPtr
+        Just jSrc -> do
+            let jSrc' = unsafeManagedPtrCastPtr jSrc
+            return jSrc'
+    result <- gst_message_new_buffering maybeSrc percent
+    checkUnexpectedReturnNULL "gst_message_new_buffering" result
+    result' <- (wrapBoxed Message) result
+    whenJust src touchManagedPtr
+    return result'
+
+-- method Message::new_clock_lost
+-- method type : Constructor
+-- Args : [Arg {argCName = "src", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "clock", argType = TInterface "Gst" "Clock", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Message"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_message_new_clock_lost" gst_message_new_clock_lost :: 
+    Ptr Object ->                           -- src : TInterface "Gst" "Object"
+    Ptr Clock ->                            -- clock : TInterface "Gst" "Clock"
+    IO (Ptr Message)
+
+
+messageNewClockLost ::
+    (MonadIO m, ObjectK a, ClockK b) =>
+    Maybe (a)                               -- src
+    -> b                                    -- clock
+    -> m Message                            -- result
+messageNewClockLost src clock = liftIO $ do
+    maybeSrc <- case src of
+        Nothing -> return nullPtr
+        Just jSrc -> do
+            let jSrc' = unsafeManagedPtrCastPtr jSrc
+            return jSrc'
+    let clock' = unsafeManagedPtrCastPtr clock
+    result <- gst_message_new_clock_lost maybeSrc clock'
+    checkUnexpectedReturnNULL "gst_message_new_clock_lost" result
+    result' <- (wrapBoxed Message) result
+    whenJust src touchManagedPtr
+    touchManagedPtr clock
+    return result'
+
+-- method Message::new_clock_provide
+-- method type : Constructor
+-- Args : [Arg {argCName = "src", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "clock", argType = TInterface "Gst" "Clock", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "ready", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Message"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_message_new_clock_provide" gst_message_new_clock_provide :: 
+    Ptr Object ->                           -- src : TInterface "Gst" "Object"
+    Ptr Clock ->                            -- clock : TInterface "Gst" "Clock"
+    CInt ->                                 -- ready : TBasicType TBoolean
+    IO (Ptr Message)
+
+
+messageNewClockProvide ::
+    (MonadIO m, ObjectK a, ClockK b) =>
+    Maybe (a)                               -- src
+    -> b                                    -- clock
+    -> Bool                                 -- ready
+    -> m Message                            -- result
+messageNewClockProvide src clock ready = liftIO $ do
+    maybeSrc <- case src of
+        Nothing -> return nullPtr
+        Just jSrc -> do
+            let jSrc' = unsafeManagedPtrCastPtr jSrc
+            return jSrc'
+    let clock' = unsafeManagedPtrCastPtr clock
+    let ready' = (fromIntegral . fromEnum) ready
+    result <- gst_message_new_clock_provide maybeSrc clock' ready'
+    checkUnexpectedReturnNULL "gst_message_new_clock_provide" result
+    result' <- (wrapBoxed Message) result
+    whenJust src touchManagedPtr
+    touchManagedPtr clock
+    return result'
+
+-- method Message::new_custom
+-- method type : Constructor
+-- Args : [Arg {argCName = "type", argType = TInterface "Gst" "MessageType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "src", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "structure", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Message"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_message_new_custom" gst_message_new_custom :: 
+    CUInt ->                                -- type : TInterface "Gst" "MessageType"
+    Ptr Object ->                           -- src : TInterface "Gst" "Object"
+    Ptr Structure ->                        -- structure : TInterface "Gst" "Structure"
+    IO (Ptr Message)
+
+
+messageNewCustom ::
+    (MonadIO m, ObjectK a) =>
+    [MessageType]                           -- type_
+    -> Maybe (a)                            -- src
+    -> Maybe (Structure)                    -- structure
+    -> m Message                            -- result
+messageNewCustom type_ src structure = liftIO $ do
+    let type_' = gflagsToWord type_
+    maybeSrc <- case src of
+        Nothing -> return nullPtr
+        Just jSrc -> do
+            let jSrc' = unsafeManagedPtrCastPtr jSrc
+            return jSrc'
+    maybeStructure <- case structure of
+        Nothing -> return nullPtr
+        Just jStructure -> do
+            jStructure' <- copyBoxed jStructure
+            return jStructure'
+    result <- gst_message_new_custom type_' maybeSrc maybeStructure
+    checkUnexpectedReturnNULL "gst_message_new_custom" result
+    result' <- (wrapBoxed Message) result
+    whenJust src touchManagedPtr
+    whenJust structure touchManagedPtr
+    return result'
+
+-- method Message::new_device_added
+-- method type : Constructor
+-- Args : [Arg {argCName = "src", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "device", argType = TInterface "Gst" "Device", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Message"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_message_new_device_added" gst_message_new_device_added :: 
+    Ptr Object ->                           -- src : TInterface "Gst" "Object"
+    Ptr Device ->                           -- device : TInterface "Gst" "Device"
+    IO (Ptr Message)
+
+
+messageNewDeviceAdded ::
+    (MonadIO m, ObjectK a, DeviceK b) =>
+    a                                       -- src
+    -> b                                    -- device
+    -> m Message                            -- result
+messageNewDeviceAdded src device = liftIO $ do
+    let src' = unsafeManagedPtrCastPtr src
+    let device' = unsafeManagedPtrCastPtr device
+    result <- gst_message_new_device_added src' device'
+    checkUnexpectedReturnNULL "gst_message_new_device_added" result
+    result' <- (wrapBoxed Message) result
+    touchManagedPtr src
+    touchManagedPtr device
+    return result'
+
+-- method Message::new_device_removed
+-- method type : Constructor
+-- Args : [Arg {argCName = "src", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "device", argType = TInterface "Gst" "Device", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Message"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_message_new_device_removed" gst_message_new_device_removed :: 
+    Ptr Object ->                           -- src : TInterface "Gst" "Object"
+    Ptr Device ->                           -- device : TInterface "Gst" "Device"
+    IO (Ptr Message)
+
+
+messageNewDeviceRemoved ::
+    (MonadIO m, ObjectK a, DeviceK b) =>
+    a                                       -- src
+    -> b                                    -- device
+    -> m Message                            -- result
+messageNewDeviceRemoved src device = liftIO $ do
+    let src' = unsafeManagedPtrCastPtr src
+    let device' = unsafeManagedPtrCastPtr device
+    result <- gst_message_new_device_removed src' device'
+    checkUnexpectedReturnNULL "gst_message_new_device_removed" result
+    result' <- (wrapBoxed Message) result
+    touchManagedPtr src
+    touchManagedPtr device
+    return result'
+
+-- method Message::new_duration_changed
+-- method type : Constructor
+-- Args : [Arg {argCName = "src", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Message"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_message_new_duration_changed" gst_message_new_duration_changed :: 
+    Ptr Object ->                           -- src : TInterface "Gst" "Object"
+    IO (Ptr Message)
+
+
+messageNewDurationChanged ::
+    (MonadIO m, ObjectK a) =>
+    Maybe (a)                               -- src
+    -> m Message                            -- result
+messageNewDurationChanged src = liftIO $ do
+    maybeSrc <- case src of
+        Nothing -> return nullPtr
+        Just jSrc -> do
+            let jSrc' = unsafeManagedPtrCastPtr jSrc
+            return jSrc'
+    result <- gst_message_new_duration_changed maybeSrc
+    checkUnexpectedReturnNULL "gst_message_new_duration_changed" result
+    result' <- (wrapBoxed Message) result
+    whenJust src touchManagedPtr
+    return result'
+
+-- method Message::new_element
+-- method type : Constructor
+-- Args : [Arg {argCName = "src", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "structure", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Message"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_message_new_element" gst_message_new_element :: 
+    Ptr Object ->                           -- src : TInterface "Gst" "Object"
+    Ptr Structure ->                        -- structure : TInterface "Gst" "Structure"
+    IO (Ptr Message)
+
+
+messageNewElement ::
+    (MonadIO m, ObjectK a) =>
+    Maybe (a)                               -- src
+    -> Structure                            -- structure
+    -> m Message                            -- result
+messageNewElement src structure = liftIO $ do
+    maybeSrc <- case src of
+        Nothing -> return nullPtr
+        Just jSrc -> do
+            let jSrc' = unsafeManagedPtrCastPtr jSrc
+            return jSrc'
+    structure' <- copyBoxed structure
+    result <- gst_message_new_element maybeSrc structure'
+    checkUnexpectedReturnNULL "gst_message_new_element" result
+    result' <- (wrapBoxed Message) result
+    whenJust src touchManagedPtr
+    touchManagedPtr structure
+    return result'
+
+-- method Message::new_eos
+-- method type : Constructor
+-- Args : [Arg {argCName = "src", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Message"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_message_new_eos" gst_message_new_eos :: 
+    Ptr Object ->                           -- src : TInterface "Gst" "Object"
+    IO (Ptr Message)
+
+
+messageNewEos ::
+    (MonadIO m, ObjectK a) =>
+    Maybe (a)                               -- src
+    -> m Message                            -- result
+messageNewEos src = liftIO $ do
+    maybeSrc <- case src of
+        Nothing -> return nullPtr
+        Just jSrc -> do
+            let jSrc' = unsafeManagedPtrCastPtr jSrc
+            return jSrc'
+    result <- gst_message_new_eos maybeSrc
+    checkUnexpectedReturnNULL "gst_message_new_eos" result
+    result' <- (wrapBoxed Message) result
+    whenJust src touchManagedPtr
+    return result'
+
+-- method Message::new_error
+-- method type : Constructor
+-- Args : [Arg {argCName = "src", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "error", argType = TError, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "debug", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Message"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_message_new_error" gst_message_new_error :: 
+    Ptr Object ->                           -- src : TInterface "Gst" "Object"
+    Ptr GError ->                           -- error : TError
+    CString ->                              -- debug : TBasicType TUTF8
+    IO (Ptr Message)
+
+
+messageNewError ::
+    (MonadIO m, ObjectK a) =>
+    Maybe (a)                               -- src
+    -> GError                               -- error_
+    -> T.Text                               -- debug
+    -> m Message                            -- result
+messageNewError src error_ debug = liftIO $ do
+    maybeSrc <- case src of
+        Nothing -> return nullPtr
+        Just jSrc -> do
+            let jSrc' = unsafeManagedPtrCastPtr jSrc
+            return jSrc'
+    let error_' = unsafeManagedPtrGetPtr error_
+    debug' <- textToCString debug
+    result <- gst_message_new_error maybeSrc error_' debug'
+    checkUnexpectedReturnNULL "gst_message_new_error" result
+    result' <- (wrapBoxed Message) result
+    whenJust src touchManagedPtr
+    touchManagedPtr error_
+    freeMem debug'
+    return result'
+
+-- method Message::new_have_context
+-- method type : Constructor
+-- Args : [Arg {argCName = "src", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "context", argType = TInterface "Gst" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Message"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_message_new_have_context" gst_message_new_have_context :: 
+    Ptr Object ->                           -- src : TInterface "Gst" "Object"
+    Ptr Context ->                          -- context : TInterface "Gst" "Context"
+    IO (Ptr Message)
+
+
+messageNewHaveContext ::
+    (MonadIO m, ObjectK a) =>
+    Maybe (a)                               -- src
+    -> Context                              -- context
+    -> m Message                            -- result
+messageNewHaveContext src context = liftIO $ do
+    maybeSrc <- case src of
+        Nothing -> return nullPtr
+        Just jSrc -> do
+            let jSrc' = unsafeManagedPtrCastPtr jSrc
+            return jSrc'
+    context' <- copyBoxed context
+    result <- gst_message_new_have_context maybeSrc context'
+    checkUnexpectedReturnNULL "gst_message_new_have_context" result
+    result' <- (wrapBoxed Message) result
+    whenJust src touchManagedPtr
+    touchManagedPtr context
+    return result'
+
+-- method Message::new_info
+-- method type : Constructor
+-- Args : [Arg {argCName = "src", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "error", argType = TError, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "debug", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Message"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_message_new_info" gst_message_new_info :: 
+    Ptr Object ->                           -- src : TInterface "Gst" "Object"
+    Ptr GError ->                           -- error : TError
+    CString ->                              -- debug : TBasicType TUTF8
+    IO (Ptr Message)
+
+
+messageNewInfo ::
+    (MonadIO m, ObjectK a) =>
+    Maybe (a)                               -- src
+    -> GError                               -- error_
+    -> T.Text                               -- debug
+    -> m Message                            -- result
+messageNewInfo src error_ debug = liftIO $ do
+    maybeSrc <- case src of
+        Nothing -> return nullPtr
+        Just jSrc -> do
+            let jSrc' = unsafeManagedPtrCastPtr jSrc
+            return jSrc'
+    let error_' = unsafeManagedPtrGetPtr error_
+    debug' <- textToCString debug
+    result <- gst_message_new_info maybeSrc error_' debug'
+    checkUnexpectedReturnNULL "gst_message_new_info" result
+    result' <- (wrapBoxed Message) result
+    whenJust src touchManagedPtr
+    touchManagedPtr error_
+    freeMem debug'
+    return result'
+
+-- method Message::new_latency
+-- method type : Constructor
+-- Args : [Arg {argCName = "src", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Message"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_message_new_latency" gst_message_new_latency :: 
+    Ptr Object ->                           -- src : TInterface "Gst" "Object"
+    IO (Ptr Message)
+
+
+messageNewLatency ::
+    (MonadIO m, ObjectK a) =>
+    Maybe (a)                               -- src
+    -> m Message                            -- result
+messageNewLatency src = liftIO $ do
+    maybeSrc <- case src of
+        Nothing -> return nullPtr
+        Just jSrc -> do
+            let jSrc' = unsafeManagedPtrCastPtr jSrc
+            return jSrc'
+    result <- gst_message_new_latency maybeSrc
+    checkUnexpectedReturnNULL "gst_message_new_latency" result
+    result' <- (wrapBoxed Message) result
+    whenJust src touchManagedPtr
+    return result'
+
+-- method Message::new_need_context
+-- method type : Constructor
+-- Args : [Arg {argCName = "src", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "context_type", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Message"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_message_new_need_context" gst_message_new_need_context :: 
+    Ptr Object ->                           -- src : TInterface "Gst" "Object"
+    CString ->                              -- context_type : TBasicType TUTF8
+    IO (Ptr Message)
+
+
+messageNewNeedContext ::
+    (MonadIO m, ObjectK a) =>
+    Maybe (a)                               -- src
+    -> T.Text                               -- contextType
+    -> m Message                            -- result
+messageNewNeedContext src contextType = liftIO $ do
+    maybeSrc <- case src of
+        Nothing -> return nullPtr
+        Just jSrc -> do
+            let jSrc' = unsafeManagedPtrCastPtr jSrc
+            return jSrc'
+    contextType' <- textToCString contextType
+    result <- gst_message_new_need_context maybeSrc contextType'
+    checkUnexpectedReturnNULL "gst_message_new_need_context" result
+    result' <- (wrapBoxed Message) result
+    whenJust src touchManagedPtr
+    freeMem contextType'
+    return result'
+
+-- method Message::new_new_clock
+-- method type : Constructor
+-- Args : [Arg {argCName = "src", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "clock", argType = TInterface "Gst" "Clock", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Message"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_message_new_new_clock" gst_message_new_new_clock :: 
+    Ptr Object ->                           -- src : TInterface "Gst" "Object"
+    Ptr Clock ->                            -- clock : TInterface "Gst" "Clock"
+    IO (Ptr Message)
+
+
+messageNewNewClock ::
+    (MonadIO m, ObjectK a, ClockK b) =>
+    Maybe (a)                               -- src
+    -> b                                    -- clock
+    -> m Message                            -- result
+messageNewNewClock src clock = liftIO $ do
+    maybeSrc <- case src of
+        Nothing -> return nullPtr
+        Just jSrc -> do
+            let jSrc' = unsafeManagedPtrCastPtr jSrc
+            return jSrc'
+    let clock' = unsafeManagedPtrCastPtr clock
+    result <- gst_message_new_new_clock maybeSrc clock'
+    checkUnexpectedReturnNULL "gst_message_new_new_clock" result
+    result' <- (wrapBoxed Message) result
+    whenJust src touchManagedPtr
+    touchManagedPtr clock
+    return result'
+
+-- method Message::new_progress
+-- method type : Constructor
+-- Args : [Arg {argCName = "src", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "type", argType = TInterface "Gst" "ProgressType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "code", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Message"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_message_new_progress" gst_message_new_progress :: 
+    Ptr Object ->                           -- src : TInterface "Gst" "Object"
+    CUInt ->                                -- type : TInterface "Gst" "ProgressType"
+    CString ->                              -- code : TBasicType TUTF8
+    CString ->                              -- text : TBasicType TUTF8
+    IO (Ptr Message)
+
+
+messageNewProgress ::
+    (MonadIO m, ObjectK a) =>
+    a                                       -- src
+    -> ProgressType                         -- type_
+    -> T.Text                               -- code
+    -> T.Text                               -- text
+    -> m Message                            -- result
+messageNewProgress src type_ code text = liftIO $ do
+    let src' = unsafeManagedPtrCastPtr src
+    let type_' = (fromIntegral . fromEnum) type_
+    code' <- textToCString code
+    text' <- textToCString text
+    result <- gst_message_new_progress src' type_' code' text'
+    checkUnexpectedReturnNULL "gst_message_new_progress" result
+    result' <- (wrapBoxed Message) result
+    touchManagedPtr src
+    freeMem code'
+    freeMem text'
+    return result'
+
+-- method Message::new_qos
+-- method type : Constructor
+-- Args : [Arg {argCName = "src", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "live", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "running_time", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stream_time", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "timestamp", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "duration", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Message"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_message_new_qos" gst_message_new_qos :: 
+    Ptr Object ->                           -- src : TInterface "Gst" "Object"
+    CInt ->                                 -- live : TBasicType TBoolean
+    Word64 ->                               -- running_time : TBasicType TUInt64
+    Word64 ->                               -- stream_time : TBasicType TUInt64
+    Word64 ->                               -- timestamp : TBasicType TUInt64
+    Word64 ->                               -- duration : TBasicType TUInt64
+    IO (Ptr Message)
+
+
+messageNewQos ::
+    (MonadIO m, ObjectK a) =>
+    a                                       -- src
+    -> Bool                                 -- live
+    -> Word64                               -- runningTime
+    -> Word64                               -- streamTime
+    -> Word64                               -- timestamp
+    -> Word64                               -- duration
+    -> m Message                            -- result
+messageNewQos src live runningTime streamTime timestamp duration = liftIO $ do
+    let src' = unsafeManagedPtrCastPtr src
+    let live' = (fromIntegral . fromEnum) live
+    result <- gst_message_new_qos src' live' runningTime streamTime timestamp duration
+    checkUnexpectedReturnNULL "gst_message_new_qos" result
+    result' <- (wrapBoxed Message) result
+    touchManagedPtr src
+    return result'
+
+-- method Message::new_request_state
+-- method type : Constructor
+-- Args : [Arg {argCName = "src", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "state", argType = TInterface "Gst" "State", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Message"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_message_new_request_state" gst_message_new_request_state :: 
+    Ptr Object ->                           -- src : TInterface "Gst" "Object"
+    CUInt ->                                -- state : TInterface "Gst" "State"
+    IO (Ptr Message)
+
+
+messageNewRequestState ::
+    (MonadIO m, ObjectK a) =>
+    Maybe (a)                               -- src
+    -> State                                -- state
+    -> m Message                            -- result
+messageNewRequestState src state = liftIO $ do
+    maybeSrc <- case src of
+        Nothing -> return nullPtr
+        Just jSrc -> do
+            let jSrc' = unsafeManagedPtrCastPtr jSrc
+            return jSrc'
+    let state' = (fromIntegral . fromEnum) state
+    result <- gst_message_new_request_state maybeSrc state'
+    checkUnexpectedReturnNULL "gst_message_new_request_state" result
+    result' <- (wrapBoxed Message) result
+    whenJust src touchManagedPtr
+    return result'
+
+-- method Message::new_reset_time
+-- method type : Constructor
+-- Args : [Arg {argCName = "src", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "running_time", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Message"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_message_new_reset_time" gst_message_new_reset_time :: 
+    Ptr Object ->                           -- src : TInterface "Gst" "Object"
+    Word64 ->                               -- running_time : TBasicType TUInt64
+    IO (Ptr Message)
+
+
+messageNewResetTime ::
+    (MonadIO m, ObjectK a) =>
+    Maybe (a)                               -- src
+    -> Word64                               -- runningTime
+    -> m Message                            -- result
+messageNewResetTime src runningTime = liftIO $ do
+    maybeSrc <- case src of
+        Nothing -> return nullPtr
+        Just jSrc -> do
+            let jSrc' = unsafeManagedPtrCastPtr jSrc
+            return jSrc'
+    result <- gst_message_new_reset_time maybeSrc runningTime
+    checkUnexpectedReturnNULL "gst_message_new_reset_time" result
+    result' <- (wrapBoxed Message) result
+    whenJust src touchManagedPtr
+    return result'
+
+-- method Message::new_segment_done
+-- method type : Constructor
+-- Args : [Arg {argCName = "src", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "position", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Message"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_message_new_segment_done" gst_message_new_segment_done :: 
+    Ptr Object ->                           -- src : TInterface "Gst" "Object"
+    CUInt ->                                -- format : TInterface "Gst" "Format"
+    Int64 ->                                -- position : TBasicType TInt64
+    IO (Ptr Message)
+
+
+messageNewSegmentDone ::
+    (MonadIO m, ObjectK a) =>
+    Maybe (a)                               -- src
+    -> Format                               -- format
+    -> Int64                                -- position
+    -> m Message                            -- result
+messageNewSegmentDone src format position = liftIO $ do
+    maybeSrc <- case src of
+        Nothing -> return nullPtr
+        Just jSrc -> do
+            let jSrc' = unsafeManagedPtrCastPtr jSrc
+            return jSrc'
+    let format' = (fromIntegral . fromEnum) format
+    result <- gst_message_new_segment_done maybeSrc format' position
+    checkUnexpectedReturnNULL "gst_message_new_segment_done" result
+    result' <- (wrapBoxed Message) result
+    whenJust src touchManagedPtr
+    return result'
+
+-- method Message::new_segment_start
+-- method type : Constructor
+-- Args : [Arg {argCName = "src", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "position", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Message"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_message_new_segment_start" gst_message_new_segment_start :: 
+    Ptr Object ->                           -- src : TInterface "Gst" "Object"
+    CUInt ->                                -- format : TInterface "Gst" "Format"
+    Int64 ->                                -- position : TBasicType TInt64
+    IO (Ptr Message)
+
+
+messageNewSegmentStart ::
+    (MonadIO m, ObjectK a) =>
+    Maybe (a)                               -- src
+    -> Format                               -- format
+    -> Int64                                -- position
+    -> m Message                            -- result
+messageNewSegmentStart src format position = liftIO $ do
+    maybeSrc <- case src of
+        Nothing -> return nullPtr
+        Just jSrc -> do
+            let jSrc' = unsafeManagedPtrCastPtr jSrc
+            return jSrc'
+    let format' = (fromIntegral . fromEnum) format
+    result <- gst_message_new_segment_start maybeSrc format' position
+    checkUnexpectedReturnNULL "gst_message_new_segment_start" result
+    result' <- (wrapBoxed Message) result
+    whenJust src touchManagedPtr
+    return result'
+
+-- method Message::new_state_changed
+-- method type : Constructor
+-- Args : [Arg {argCName = "src", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "oldstate", argType = TInterface "Gst" "State", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "newstate", argType = TInterface "Gst" "State", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pending", argType = TInterface "Gst" "State", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Message"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_message_new_state_changed" gst_message_new_state_changed :: 
+    Ptr Object ->                           -- src : TInterface "Gst" "Object"
+    CUInt ->                                -- oldstate : TInterface "Gst" "State"
+    CUInt ->                                -- newstate : TInterface "Gst" "State"
+    CUInt ->                                -- pending : TInterface "Gst" "State"
+    IO (Ptr Message)
+
+
+messageNewStateChanged ::
+    (MonadIO m, ObjectK a) =>
+    Maybe (a)                               -- src
+    -> State                                -- oldstate
+    -> State                                -- newstate
+    -> State                                -- pending
+    -> m Message                            -- result
+messageNewStateChanged src oldstate newstate pending = liftIO $ do
+    maybeSrc <- case src of
+        Nothing -> return nullPtr
+        Just jSrc -> do
+            let jSrc' = unsafeManagedPtrCastPtr jSrc
+            return jSrc'
+    let oldstate' = (fromIntegral . fromEnum) oldstate
+    let newstate' = (fromIntegral . fromEnum) newstate
+    let pending' = (fromIntegral . fromEnum) pending
+    result <- gst_message_new_state_changed maybeSrc oldstate' newstate' pending'
+    checkUnexpectedReturnNULL "gst_message_new_state_changed" result
+    result' <- (wrapBoxed Message) result
+    whenJust src touchManagedPtr
+    return result'
+
+-- method Message::new_state_dirty
+-- method type : Constructor
+-- Args : [Arg {argCName = "src", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Message"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_message_new_state_dirty" gst_message_new_state_dirty :: 
+    Ptr Object ->                           -- src : TInterface "Gst" "Object"
+    IO (Ptr Message)
+
+
+messageNewStateDirty ::
+    (MonadIO m, ObjectK a) =>
+    Maybe (a)                               -- src
+    -> m Message                            -- result
+messageNewStateDirty src = liftIO $ do
+    maybeSrc <- case src of
+        Nothing -> return nullPtr
+        Just jSrc -> do
+            let jSrc' = unsafeManagedPtrCastPtr jSrc
+            return jSrc'
+    result <- gst_message_new_state_dirty maybeSrc
+    checkUnexpectedReturnNULL "gst_message_new_state_dirty" result
+    result' <- (wrapBoxed Message) result
+    whenJust src touchManagedPtr
+    return result'
+
+-- method Message::new_step_done
+-- method type : Constructor
+-- Args : [Arg {argCName = "src", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "amount", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "rate", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flush", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "intermediate", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "duration", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "eos", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Message"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_message_new_step_done" gst_message_new_step_done :: 
+    Ptr Object ->                           -- src : TInterface "Gst" "Object"
+    CUInt ->                                -- format : TInterface "Gst" "Format"
+    Word64 ->                               -- amount : TBasicType TUInt64
+    CDouble ->                              -- rate : TBasicType TDouble
+    CInt ->                                 -- flush : TBasicType TBoolean
+    CInt ->                                 -- intermediate : TBasicType TBoolean
+    Word64 ->                               -- duration : TBasicType TUInt64
+    CInt ->                                 -- eos : TBasicType TBoolean
+    IO (Ptr Message)
+
+
+messageNewStepDone ::
+    (MonadIO m, ObjectK a) =>
+    a                                       -- src
+    -> Format                               -- format
+    -> Word64                               -- amount
+    -> Double                               -- rate
+    -> Bool                                 -- flush
+    -> Bool                                 -- intermediate
+    -> Word64                               -- duration
+    -> Bool                                 -- eos
+    -> m Message                            -- result
+messageNewStepDone src format amount rate flush intermediate duration eos = liftIO $ do
+    let src' = unsafeManagedPtrCastPtr src
+    let format' = (fromIntegral . fromEnum) format
+    let rate' = realToFrac rate
+    let flush' = (fromIntegral . fromEnum) flush
+    let intermediate' = (fromIntegral . fromEnum) intermediate
+    let eos' = (fromIntegral . fromEnum) eos
+    result <- gst_message_new_step_done src' format' amount rate' flush' intermediate' duration eos'
+    checkUnexpectedReturnNULL "gst_message_new_step_done" result
+    result' <- (wrapBoxed Message) result
+    touchManagedPtr src
+    return result'
+
+-- method Message::new_step_start
+-- method type : Constructor
+-- Args : [Arg {argCName = "src", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "active", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "amount", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "rate", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flush", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "intermediate", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Message"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_message_new_step_start" gst_message_new_step_start :: 
+    Ptr Object ->                           -- src : TInterface "Gst" "Object"
+    CInt ->                                 -- active : TBasicType TBoolean
+    CUInt ->                                -- format : TInterface "Gst" "Format"
+    Word64 ->                               -- amount : TBasicType TUInt64
+    CDouble ->                              -- rate : TBasicType TDouble
+    CInt ->                                 -- flush : TBasicType TBoolean
+    CInt ->                                 -- intermediate : TBasicType TBoolean
+    IO (Ptr Message)
+
+
+messageNewStepStart ::
+    (MonadIO m, ObjectK a) =>
+    a                                       -- src
+    -> Bool                                 -- active
+    -> Format                               -- format
+    -> Word64                               -- amount
+    -> Double                               -- rate
+    -> Bool                                 -- flush
+    -> Bool                                 -- intermediate
+    -> m Message                            -- result
+messageNewStepStart src active format amount rate flush intermediate = liftIO $ do
+    let src' = unsafeManagedPtrCastPtr src
+    let active' = (fromIntegral . fromEnum) active
+    let format' = (fromIntegral . fromEnum) format
+    let rate' = realToFrac rate
+    let flush' = (fromIntegral . fromEnum) flush
+    let intermediate' = (fromIntegral . fromEnum) intermediate
+    result <- gst_message_new_step_start src' active' format' amount rate' flush' intermediate'
+    checkUnexpectedReturnNULL "gst_message_new_step_start" result
+    result' <- (wrapBoxed Message) result
+    touchManagedPtr src
+    return result'
+
+-- method Message::new_stream_start
+-- method type : Constructor
+-- Args : [Arg {argCName = "src", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Message"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_message_new_stream_start" gst_message_new_stream_start :: 
+    Ptr Object ->                           -- src : TInterface "Gst" "Object"
+    IO (Ptr Message)
+
+
+messageNewStreamStart ::
+    (MonadIO m, ObjectK a) =>
+    Maybe (a)                               -- src
+    -> m Message                            -- result
+messageNewStreamStart src = liftIO $ do
+    maybeSrc <- case src of
+        Nothing -> return nullPtr
+        Just jSrc -> do
+            let jSrc' = unsafeManagedPtrCastPtr jSrc
+            return jSrc'
+    result <- gst_message_new_stream_start maybeSrc
+    checkUnexpectedReturnNULL "gst_message_new_stream_start" result
+    result' <- (wrapBoxed Message) result
+    whenJust src touchManagedPtr
+    return result'
+
+-- method Message::new_stream_status
+-- method type : Constructor
+-- Args : [Arg {argCName = "src", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "type", argType = TInterface "Gst" "StreamStatusType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "owner", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Message"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_message_new_stream_status" gst_message_new_stream_status :: 
+    Ptr Object ->                           -- src : TInterface "Gst" "Object"
+    CUInt ->                                -- type : TInterface "Gst" "StreamStatusType"
+    Ptr Element ->                          -- owner : TInterface "Gst" "Element"
+    IO (Ptr Message)
+
+
+messageNewStreamStatus ::
+    (MonadIO m, ObjectK a, ElementK b) =>
+    a                                       -- src
+    -> StreamStatusType                     -- type_
+    -> b                                    -- owner
+    -> m Message                            -- result
+messageNewStreamStatus src type_ owner = liftIO $ do
+    let src' = unsafeManagedPtrCastPtr src
+    let type_' = (fromIntegral . fromEnum) type_
+    let owner' = unsafeManagedPtrCastPtr owner
+    result <- gst_message_new_stream_status src' type_' owner'
+    checkUnexpectedReturnNULL "gst_message_new_stream_status" result
+    result' <- (wrapBoxed Message) result
+    touchManagedPtr src
+    touchManagedPtr owner
+    return result'
+
+-- method Message::new_structure_change
+-- method type : Constructor
+-- Args : [Arg {argCName = "src", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "type", argType = TInterface "Gst" "StructureChangeType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "owner", argType = TInterface "Gst" "Element", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "busy", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Message"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_message_new_structure_change" gst_message_new_structure_change :: 
+    Ptr Object ->                           -- src : TInterface "Gst" "Object"
+    CUInt ->                                -- type : TInterface "Gst" "StructureChangeType"
+    Ptr Element ->                          -- owner : TInterface "Gst" "Element"
+    CInt ->                                 -- busy : TBasicType TBoolean
+    IO (Ptr Message)
+
+
+messageNewStructureChange ::
+    (MonadIO m, ObjectK a, ElementK b) =>
+    Maybe (a)                               -- src
+    -> StructureChangeType                  -- type_
+    -> b                                    -- owner
+    -> Bool                                 -- busy
+    -> m Message                            -- result
+messageNewStructureChange src type_ owner busy = liftIO $ do
+    maybeSrc <- case src of
+        Nothing -> return nullPtr
+        Just jSrc -> do
+            let jSrc' = unsafeManagedPtrCastPtr jSrc
+            return jSrc'
+    let type_' = (fromIntegral . fromEnum) type_
+    let owner' = unsafeManagedPtrCastPtr owner
+    let busy' = (fromIntegral . fromEnum) busy
+    result <- gst_message_new_structure_change maybeSrc type_' owner' busy'
+    checkUnexpectedReturnNULL "gst_message_new_structure_change" result
+    result' <- (wrapBoxed Message) result
+    whenJust src touchManagedPtr
+    touchManagedPtr owner
+    return result'
+
+-- method Message::new_tag
+-- method type : Constructor
+-- Args : [Arg {argCName = "src", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag_list", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Message"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_message_new_tag" gst_message_new_tag :: 
+    Ptr Object ->                           -- src : TInterface "Gst" "Object"
+    Ptr TagList ->                          -- tag_list : TInterface "Gst" "TagList"
+    IO (Ptr Message)
+
+
+messageNewTag ::
+    (MonadIO m, ObjectK a) =>
+    Maybe (a)                               -- src
+    -> TagList                              -- tagList
+    -> m Message                            -- result
+messageNewTag src tagList = liftIO $ do
+    maybeSrc <- case src of
+        Nothing -> return nullPtr
+        Just jSrc -> do
+            let jSrc' = unsafeManagedPtrCastPtr jSrc
+            return jSrc'
+    tagList' <- copyBoxed tagList
+    result <- gst_message_new_tag maybeSrc tagList'
+    checkUnexpectedReturnNULL "gst_message_new_tag" result
+    result' <- (wrapBoxed Message) result
+    whenJust src touchManagedPtr
+    touchManagedPtr tagList
+    return result'
+
+-- method Message::new_toc
+-- method type : Constructor
+-- Args : [Arg {argCName = "src", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "toc", argType = TInterface "Gst" "Toc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "updated", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Message"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_message_new_toc" gst_message_new_toc :: 
+    Ptr Object ->                           -- src : TInterface "Gst" "Object"
+    Ptr Toc ->                              -- toc : TInterface "Gst" "Toc"
+    CInt ->                                 -- updated : TBasicType TBoolean
+    IO (Ptr Message)
+
+
+messageNewToc ::
+    (MonadIO m, ObjectK a) =>
+    a                                       -- src
+    -> Toc                                  -- toc
+    -> Bool                                 -- updated
+    -> m Message                            -- result
+messageNewToc src toc updated = liftIO $ do
+    let src' = unsafeManagedPtrCastPtr src
+    let toc' = unsafeManagedPtrGetPtr toc
+    let updated' = (fromIntegral . fromEnum) updated
+    result <- gst_message_new_toc src' toc' updated'
+    checkUnexpectedReturnNULL "gst_message_new_toc" result
+    result' <- (wrapBoxed Message) result
+    touchManagedPtr src
+    touchManagedPtr toc
+    return result'
+
+-- method Message::new_warning
+-- method type : Constructor
+-- Args : [Arg {argCName = "src", argType = TInterface "Gst" "Object", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "error", argType = TError, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "debug", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Message"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_message_new_warning" gst_message_new_warning :: 
+    Ptr Object ->                           -- src : TInterface "Gst" "Object"
+    Ptr GError ->                           -- error : TError
+    CString ->                              -- debug : TBasicType TUTF8
+    IO (Ptr Message)
+
+
+messageNewWarning ::
+    (MonadIO m, ObjectK a) =>
+    Maybe (a)                               -- src
+    -> GError                               -- error_
+    -> T.Text                               -- debug
+    -> m Message                            -- result
+messageNewWarning src error_ debug = liftIO $ do
+    maybeSrc <- case src of
+        Nothing -> return nullPtr
+        Just jSrc -> do
+            let jSrc' = unsafeManagedPtrCastPtr jSrc
+            return jSrc'
+    let error_' = unsafeManagedPtrGetPtr error_
+    debug' <- textToCString debug
+    result <- gst_message_new_warning maybeSrc error_' debug'
+    checkUnexpectedReturnNULL "gst_message_new_warning" result
+    result' <- (wrapBoxed Message) result
+    whenJust src touchManagedPtr
+    touchManagedPtr error_
+    freeMem debug'
+    return result'
+
+-- method Message::get_seqnum
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUInt32
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_message_get_seqnum" gst_message_get_seqnum :: 
+    Ptr Message ->                          -- _obj : TInterface "Gst" "Message"
+    IO Word32
+
+
+messageGetSeqnum ::
+    (MonadIO m) =>
+    Message                                 -- _obj
+    -> m Word32                             -- result
+messageGetSeqnum _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_message_get_seqnum _obj'
+    touchManagedPtr _obj
+    return result
+
+data MessageGetSeqnumMethodInfo
+instance (signature ~ (m Word32), MonadIO m) => MethodInfo MessageGetSeqnumMethodInfo Message signature where
+    overloadedMethod _ = messageGetSeqnum
+
+-- method Message::get_stream_status_object
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "GObject" "Value"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_message_get_stream_status_object" gst_message_get_stream_status_object :: 
+    Ptr Message ->                          -- _obj : TInterface "Gst" "Message"
+    IO (Ptr GValue)
+
+
+messageGetStreamStatusObject ::
+    (MonadIO m) =>
+    Message                                 -- _obj
+    -> m GValue                             -- result
+messageGetStreamStatusObject _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_message_get_stream_status_object _obj'
+    checkUnexpectedReturnNULL "gst_message_get_stream_status_object" result
+    result' <- (newBoxed GValue) result
+    touchManagedPtr _obj
+    return result'
+
+data MessageGetStreamStatusObjectMethodInfo
+instance (signature ~ (m GValue), MonadIO m) => MethodInfo MessageGetStreamStatusObjectMethodInfo Message signature where
+    overloadedMethod _ = messageGetStreamStatusObject
+
+-- method Message::get_structure
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Structure"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_message_get_structure" gst_message_get_structure :: 
+    Ptr Message ->                          -- _obj : TInterface "Gst" "Message"
+    IO (Ptr Structure)
+
+
+messageGetStructure ::
+    (MonadIO m) =>
+    Message                                 -- _obj
+    -> m Structure                          -- result
+messageGetStructure _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_message_get_structure _obj'
+    checkUnexpectedReturnNULL "gst_message_get_structure" result
+    result' <- (newBoxed Structure) result
+    touchManagedPtr _obj
+    return result'
+
+data MessageGetStructureMethodInfo
+instance (signature ~ (m Structure), MonadIO m) => MethodInfo MessageGetStructureMethodInfo Message signature where
+    overloadedMethod _ = messageGetStructure
+
+-- method Message::has_name
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_message_has_name" gst_message_has_name :: 
+    Ptr Message ->                          -- _obj : TInterface "Gst" "Message"
+    CString ->                              -- name : TBasicType TUTF8
+    IO CInt
+
+
+messageHasName ::
+    (MonadIO m) =>
+    Message                                 -- _obj
+    -> T.Text                               -- name
+    -> m Bool                               -- result
+messageHasName _obj name = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    name' <- textToCString name
+    result <- gst_message_has_name _obj' name'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    freeMem name'
+    return result'
+
+data MessageHasNameMethodInfo
+instance (signature ~ (T.Text -> m Bool), MonadIO m) => MethodInfo MessageHasNameMethodInfo Message signature where
+    overloadedMethod _ = messageHasName
+
+-- method Message::parse_async_done
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "running_time", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_message_parse_async_done" gst_message_parse_async_done :: 
+    Ptr Message ->                          -- _obj : TInterface "Gst" "Message"
+    Ptr Word64 ->                           -- running_time : TBasicType TUInt64
+    IO ()
+
+
+messageParseAsyncDone ::
+    (MonadIO m) =>
+    Message                                 -- _obj
+    -> m (Word64)                           -- result
+messageParseAsyncDone _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    runningTime <- allocMem :: IO (Ptr Word64)
+    gst_message_parse_async_done _obj' runningTime
+    runningTime' <- peek runningTime
+    touchManagedPtr _obj
+    freeMem runningTime
+    return runningTime'
+
+data MessageParseAsyncDoneMethodInfo
+instance (signature ~ (m (Word64)), MonadIO m) => MethodInfo MessageParseAsyncDoneMethodInfo Message signature where
+    overloadedMethod _ = messageParseAsyncDone
+
+-- method Message::parse_buffering
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "percent", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_message_parse_buffering" gst_message_parse_buffering :: 
+    Ptr Message ->                          -- _obj : TInterface "Gst" "Message"
+    Ptr Int32 ->                            -- percent : TBasicType TInt32
+    IO ()
+
+
+messageParseBuffering ::
+    (MonadIO m) =>
+    Message                                 -- _obj
+    -> m (Int32)                            -- result
+messageParseBuffering _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    percent <- allocMem :: IO (Ptr Int32)
+    gst_message_parse_buffering _obj' percent
+    percent' <- peek percent
+    touchManagedPtr _obj
+    freeMem percent
+    return percent'
+
+data MessageParseBufferingMethodInfo
+instance (signature ~ (m (Int32)), MonadIO m) => MethodInfo MessageParseBufferingMethodInfo Message signature where
+    overloadedMethod _ = messageParseBuffering
+
+-- method Message::parse_buffering_stats
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mode", argType = TInterface "Gst" "BufferingMode", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "avg_in", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "avg_out", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "buffering_left", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_message_parse_buffering_stats" gst_message_parse_buffering_stats :: 
+    Ptr Message ->                          -- _obj : TInterface "Gst" "Message"
+    Ptr CUInt ->                            -- mode : TInterface "Gst" "BufferingMode"
+    Ptr Int32 ->                            -- avg_in : TBasicType TInt32
+    Ptr Int32 ->                            -- avg_out : TBasicType TInt32
+    Ptr Int64 ->                            -- buffering_left : TBasicType TInt64
+    IO ()
+
+
+messageParseBufferingStats ::
+    (MonadIO m) =>
+    Message                                 -- _obj
+    -> m (BufferingMode,Int32,Int32,Int64)  -- result
+messageParseBufferingStats _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    mode <- allocMem :: IO (Ptr CUInt)
+    avgIn <- allocMem :: IO (Ptr Int32)
+    avgOut <- allocMem :: IO (Ptr Int32)
+    bufferingLeft <- allocMem :: IO (Ptr Int64)
+    gst_message_parse_buffering_stats _obj' mode avgIn avgOut bufferingLeft
+    mode' <- peek mode
+    let mode'' = (toEnum . fromIntegral) mode'
+    avgIn' <- peek avgIn
+    avgOut' <- peek avgOut
+    bufferingLeft' <- peek bufferingLeft
+    touchManagedPtr _obj
+    freeMem mode
+    freeMem avgIn
+    freeMem avgOut
+    freeMem bufferingLeft
+    return (mode'', avgIn', avgOut', bufferingLeft')
+
+data MessageParseBufferingStatsMethodInfo
+instance (signature ~ (m (BufferingMode,Int32,Int32,Int64)), MonadIO m) => MethodInfo MessageParseBufferingStatsMethodInfo Message signature where
+    overloadedMethod _ = messageParseBufferingStats
+
+-- method Message::parse_clock_lost
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "clock", argType = TInterface "Gst" "Clock", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_message_parse_clock_lost" gst_message_parse_clock_lost :: 
+    Ptr Message ->                          -- _obj : TInterface "Gst" "Message"
+    Ptr (Ptr Clock) ->                      -- clock : TInterface "Gst" "Clock"
+    IO ()
+
+
+messageParseClockLost ::
+    (MonadIO m) =>
+    Message                                 -- _obj
+    -> m (Clock)                            -- result
+messageParseClockLost _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    clock <- allocMem :: IO (Ptr (Ptr Clock))
+    gst_message_parse_clock_lost _obj' clock
+    clock' <- peek clock
+    clock'' <- (newObject Clock) clock'
+    touchManagedPtr _obj
+    freeMem clock
+    return clock''
+
+data MessageParseClockLostMethodInfo
+instance (signature ~ (m (Clock)), MonadIO m) => MethodInfo MessageParseClockLostMethodInfo Message signature where
+    overloadedMethod _ = messageParseClockLost
+
+-- method Message::parse_clock_provide
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "clock", argType = TInterface "Gst" "Clock", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "ready", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_message_parse_clock_provide" gst_message_parse_clock_provide :: 
+    Ptr Message ->                          -- _obj : TInterface "Gst" "Message"
+    Ptr (Ptr Clock) ->                      -- clock : TInterface "Gst" "Clock"
+    Ptr CInt ->                             -- ready : TBasicType TBoolean
+    IO ()
+
+
+messageParseClockProvide ::
+    (MonadIO m) =>
+    Message                                 -- _obj
+    -> m (Clock,Bool)                       -- result
+messageParseClockProvide _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    clock <- allocMem :: IO (Ptr (Ptr Clock))
+    ready <- allocMem :: IO (Ptr CInt)
+    gst_message_parse_clock_provide _obj' clock ready
+    clock' <- peek clock
+    clock'' <- (newObject Clock) clock'
+    ready' <- peek ready
+    let ready'' = (/= 0) ready'
+    touchManagedPtr _obj
+    freeMem clock
+    freeMem ready
+    return (clock'', ready'')
+
+data MessageParseClockProvideMethodInfo
+instance (signature ~ (m (Clock,Bool)), MonadIO m) => MethodInfo MessageParseClockProvideMethodInfo Message signature where
+    overloadedMethod _ = messageParseClockProvide
+
+-- method Message::parse_context_type
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "context_type", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_message_parse_context_type" gst_message_parse_context_type :: 
+    Ptr Message ->                          -- _obj : TInterface "Gst" "Message"
+    Ptr CString ->                          -- context_type : TBasicType TUTF8
+    IO CInt
+
+
+messageParseContextType ::
+    (MonadIO m) =>
+    Message                                 -- _obj
+    -> m (Bool,T.Text)                      -- result
+messageParseContextType _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    contextType <- allocMem :: IO (Ptr CString)
+    result <- gst_message_parse_context_type _obj' contextType
+    let result' = (/= 0) result
+    contextType' <- peek contextType
+    contextType'' <- cstringToText contextType'
+    freeMem contextType'
+    touchManagedPtr _obj
+    freeMem contextType
+    return (result', contextType'')
+
+data MessageParseContextTypeMethodInfo
+instance (signature ~ (m (Bool,T.Text)), MonadIO m) => MethodInfo MessageParseContextTypeMethodInfo Message signature where
+    overloadedMethod _ = messageParseContextType
+
+-- method Message::parse_device_added
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "device", argType = TInterface "Gst" "Device", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_message_parse_device_added" gst_message_parse_device_added :: 
+    Ptr Message ->                          -- _obj : TInterface "Gst" "Message"
+    Ptr (Ptr Device) ->                     -- device : TInterface "Gst" "Device"
+    IO ()
+
+
+messageParseDeviceAdded ::
+    (MonadIO m) =>
+    Message                                 -- _obj
+    -> m (Device)                           -- result
+messageParseDeviceAdded _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    device <- allocMem :: IO (Ptr (Ptr Device))
+    gst_message_parse_device_added _obj' device
+    device' <- peek device
+    device'' <- (newObject Device) device'
+    touchManagedPtr _obj
+    freeMem device
+    return device''
+
+data MessageParseDeviceAddedMethodInfo
+instance (signature ~ (m (Device)), MonadIO m) => MethodInfo MessageParseDeviceAddedMethodInfo Message signature where
+    overloadedMethod _ = messageParseDeviceAdded
+
+-- method Message::parse_device_removed
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "device", argType = TInterface "Gst" "Device", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_message_parse_device_removed" gst_message_parse_device_removed :: 
+    Ptr Message ->                          -- _obj : TInterface "Gst" "Message"
+    Ptr (Ptr Device) ->                     -- device : TInterface "Gst" "Device"
+    IO ()
+
+
+messageParseDeviceRemoved ::
+    (MonadIO m) =>
+    Message                                 -- _obj
+    -> m (Device)                           -- result
+messageParseDeviceRemoved _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    device <- allocMem :: IO (Ptr (Ptr Device))
+    gst_message_parse_device_removed _obj' device
+    device' <- peek device
+    device'' <- (newObject Device) device'
+    touchManagedPtr _obj
+    freeMem device
+    return device''
+
+data MessageParseDeviceRemovedMethodInfo
+instance (signature ~ (m (Device)), MonadIO m) => MethodInfo MessageParseDeviceRemovedMethodInfo Message signature where
+    overloadedMethod _ = messageParseDeviceRemoved
+
+-- method Message::parse_error
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "gerror", argType = TError, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "debug", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_message_parse_error" gst_message_parse_error :: 
+    Ptr Message ->                          -- _obj : TInterface "Gst" "Message"
+    Ptr GError ->                           -- gerror : TError
+    Ptr CString ->                          -- debug : TBasicType TUTF8
+    IO ()
+
+
+messageParseError ::
+    (MonadIO m) =>
+    Message                                 -- _obj
+    -> m (GError,T.Text)                    -- result
+messageParseError _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    gerror <- callocBoxedBytes 16 :: IO (Ptr GError)
+    debug <- allocMem :: IO (Ptr CString)
+    gst_message_parse_error _obj' gerror debug
+    gerror' <- (wrapBoxed GError) gerror
+    debug' <- peek debug
+    debug'' <- cstringToText debug'
+    freeMem debug'
+    touchManagedPtr _obj
+    freeMem debug
+    return (gerror', debug'')
+
+data MessageParseErrorMethodInfo
+instance (signature ~ (m (GError,T.Text)), MonadIO m) => MethodInfo MessageParseErrorMethodInfo Message signature where
+    overloadedMethod _ = messageParseError
+
+-- method Message::parse_group_id
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "group_id", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_message_parse_group_id" gst_message_parse_group_id :: 
+    Ptr Message ->                          -- _obj : TInterface "Gst" "Message"
+    Ptr Word32 ->                           -- group_id : TBasicType TUInt32
+    IO CInt
+
+
+messageParseGroupId ::
+    (MonadIO m) =>
+    Message                                 -- _obj
+    -> m (Bool,Word32)                      -- result
+messageParseGroupId _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    groupId <- allocMem :: IO (Ptr Word32)
+    result <- gst_message_parse_group_id _obj' groupId
+    let result' = (/= 0) result
+    groupId' <- peek groupId
+    touchManagedPtr _obj
+    freeMem groupId
+    return (result', groupId')
+
+data MessageParseGroupIdMethodInfo
+instance (signature ~ (m (Bool,Word32)), MonadIO m) => MethodInfo MessageParseGroupIdMethodInfo Message signature where
+    overloadedMethod _ = messageParseGroupId
+
+-- method Message::parse_have_context
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "context", argType = TInterface "Gst" "Context", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_message_parse_have_context" gst_message_parse_have_context :: 
+    Ptr Message ->                          -- _obj : TInterface "Gst" "Message"
+    Ptr (Ptr Context) ->                    -- context : TInterface "Gst" "Context"
+    IO ()
+
+
+messageParseHaveContext ::
+    (MonadIO m) =>
+    Message                                 -- _obj
+    -> m (Context)                          -- result
+messageParseHaveContext _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    context <- allocMem :: IO (Ptr (Ptr Context))
+    gst_message_parse_have_context _obj' context
+    context' <- peek context
+    context'' <- (wrapBoxed Context) context'
+    touchManagedPtr _obj
+    freeMem context
+    return context''
+
+data MessageParseHaveContextMethodInfo
+instance (signature ~ (m (Context)), MonadIO m) => MethodInfo MessageParseHaveContextMethodInfo Message signature where
+    overloadedMethod _ = messageParseHaveContext
+
+-- method Message::parse_info
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "gerror", argType = TError, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "debug", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_message_parse_info" gst_message_parse_info :: 
+    Ptr Message ->                          -- _obj : TInterface "Gst" "Message"
+    Ptr GError ->                           -- gerror : TError
+    Ptr CString ->                          -- debug : TBasicType TUTF8
+    IO ()
+
+
+messageParseInfo ::
+    (MonadIO m) =>
+    Message                                 -- _obj
+    -> m (GError,T.Text)                    -- result
+messageParseInfo _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    gerror <- callocBoxedBytes 16 :: IO (Ptr GError)
+    debug <- allocMem :: IO (Ptr CString)
+    gst_message_parse_info _obj' gerror debug
+    gerror' <- (wrapBoxed GError) gerror
+    debug' <- peek debug
+    debug'' <- cstringToText debug'
+    freeMem debug'
+    touchManagedPtr _obj
+    freeMem debug
+    return (gerror', debug'')
+
+data MessageParseInfoMethodInfo
+instance (signature ~ (m (GError,T.Text)), MonadIO m) => MethodInfo MessageParseInfoMethodInfo Message signature where
+    overloadedMethod _ = messageParseInfo
+
+-- method Message::parse_new_clock
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "clock", argType = TInterface "Gst" "Clock", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_message_parse_new_clock" gst_message_parse_new_clock :: 
+    Ptr Message ->                          -- _obj : TInterface "Gst" "Message"
+    Ptr (Ptr Clock) ->                      -- clock : TInterface "Gst" "Clock"
+    IO ()
+
+
+messageParseNewClock ::
+    (MonadIO m) =>
+    Message                                 -- _obj
+    -> m (Clock)                            -- result
+messageParseNewClock _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    clock <- allocMem :: IO (Ptr (Ptr Clock))
+    gst_message_parse_new_clock _obj' clock
+    clock' <- peek clock
+    clock'' <- (newObject Clock) clock'
+    touchManagedPtr _obj
+    freeMem clock
+    return clock''
+
+data MessageParseNewClockMethodInfo
+instance (signature ~ (m (Clock)), MonadIO m) => MethodInfo MessageParseNewClockMethodInfo Message signature where
+    overloadedMethod _ = messageParseNewClock
+
+-- method Message::parse_progress
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "type", argType = TInterface "Gst" "ProgressType", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "code", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "text", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_message_parse_progress" gst_message_parse_progress :: 
+    Ptr Message ->                          -- _obj : TInterface "Gst" "Message"
+    Ptr CUInt ->                            -- type : TInterface "Gst" "ProgressType"
+    Ptr CString ->                          -- code : TBasicType TUTF8
+    Ptr CString ->                          -- text : TBasicType TUTF8
+    IO ()
+
+
+messageParseProgress ::
+    (MonadIO m) =>
+    Message                                 -- _obj
+    -> m (ProgressType,T.Text,T.Text)       -- result
+messageParseProgress _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    type_ <- allocMem :: IO (Ptr CUInt)
+    code <- allocMem :: IO (Ptr CString)
+    text <- allocMem :: IO (Ptr CString)
+    gst_message_parse_progress _obj' type_ code text
+    type_' <- peek type_
+    let type_'' = (toEnum . fromIntegral) type_'
+    code' <- peek code
+    code'' <- cstringToText code'
+    freeMem code'
+    text' <- peek text
+    text'' <- cstringToText text'
+    freeMem text'
+    touchManagedPtr _obj
+    freeMem type_
+    freeMem code
+    freeMem text
+    return (type_'', code'', text'')
+
+data MessageParseProgressMethodInfo
+instance (signature ~ (m (ProgressType,T.Text,T.Text)), MonadIO m) => MethodInfo MessageParseProgressMethodInfo Message signature where
+    overloadedMethod _ = messageParseProgress
+
+-- method Message::parse_qos
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "live", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "running_time", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "stream_time", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "timestamp", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "duration", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_message_parse_qos" gst_message_parse_qos :: 
+    Ptr Message ->                          -- _obj : TInterface "Gst" "Message"
+    Ptr CInt ->                             -- live : TBasicType TBoolean
+    Ptr Word64 ->                           -- running_time : TBasicType TUInt64
+    Ptr Word64 ->                           -- stream_time : TBasicType TUInt64
+    Ptr Word64 ->                           -- timestamp : TBasicType TUInt64
+    Ptr Word64 ->                           -- duration : TBasicType TUInt64
+    IO ()
+
+
+messageParseQos ::
+    (MonadIO m) =>
+    Message                                 -- _obj
+    -> m (Bool,Word64,Word64,Word64,Word64) -- result
+messageParseQos _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    live <- allocMem :: IO (Ptr CInt)
+    runningTime <- allocMem :: IO (Ptr Word64)
+    streamTime <- allocMem :: IO (Ptr Word64)
+    timestamp <- allocMem :: IO (Ptr Word64)
+    duration <- allocMem :: IO (Ptr Word64)
+    gst_message_parse_qos _obj' live runningTime streamTime timestamp duration
+    live' <- peek live
+    let live'' = (/= 0) live'
+    runningTime' <- peek runningTime
+    streamTime' <- peek streamTime
+    timestamp' <- peek timestamp
+    duration' <- peek duration
+    touchManagedPtr _obj
+    freeMem live
+    freeMem runningTime
+    freeMem streamTime
+    freeMem timestamp
+    freeMem duration
+    return (live'', runningTime', streamTime', timestamp', duration')
+
+data MessageParseQosMethodInfo
+instance (signature ~ (m (Bool,Word64,Word64,Word64,Word64)), MonadIO m) => MethodInfo MessageParseQosMethodInfo Message signature where
+    overloadedMethod _ = messageParseQos
+
+-- method Message::parse_qos_stats
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "processed", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "dropped", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_message_parse_qos_stats" gst_message_parse_qos_stats :: 
+    Ptr Message ->                          -- _obj : TInterface "Gst" "Message"
+    Ptr CUInt ->                            -- format : TInterface "Gst" "Format"
+    Ptr Word64 ->                           -- processed : TBasicType TUInt64
+    Ptr Word64 ->                           -- dropped : TBasicType TUInt64
+    IO ()
+
+
+messageParseQosStats ::
+    (MonadIO m) =>
+    Message                                 -- _obj
+    -> m (Format,Word64,Word64)             -- result
+messageParseQosStats _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    format <- allocMem :: IO (Ptr CUInt)
+    processed <- allocMem :: IO (Ptr Word64)
+    dropped <- allocMem :: IO (Ptr Word64)
+    gst_message_parse_qos_stats _obj' format processed dropped
+    format' <- peek format
+    let format'' = (toEnum . fromIntegral) format'
+    processed' <- peek processed
+    dropped' <- peek dropped
+    touchManagedPtr _obj
+    freeMem format
+    freeMem processed
+    freeMem dropped
+    return (format'', processed', dropped')
+
+data MessageParseQosStatsMethodInfo
+instance (signature ~ (m (Format,Word64,Word64)), MonadIO m) => MethodInfo MessageParseQosStatsMethodInfo Message signature where
+    overloadedMethod _ = messageParseQosStats
+
+-- method Message::parse_qos_values
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "jitter", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "proportion", argType = TBasicType TDouble, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "quality", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_message_parse_qos_values" gst_message_parse_qos_values :: 
+    Ptr Message ->                          -- _obj : TInterface "Gst" "Message"
+    Ptr Int64 ->                            -- jitter : TBasicType TInt64
+    Ptr CDouble ->                          -- proportion : TBasicType TDouble
+    Ptr Int32 ->                            -- quality : TBasicType TInt32
+    IO ()
+
+
+messageParseQosValues ::
+    (MonadIO m) =>
+    Message                                 -- _obj
+    -> m (Int64,Double,Int32)               -- result
+messageParseQosValues _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    jitter <- allocMem :: IO (Ptr Int64)
+    proportion <- allocMem :: IO (Ptr CDouble)
+    quality <- allocMem :: IO (Ptr Int32)
+    gst_message_parse_qos_values _obj' jitter proportion quality
+    jitter' <- peek jitter
+    proportion' <- peek proportion
+    let proportion'' = realToFrac proportion'
+    quality' <- peek quality
+    touchManagedPtr _obj
+    freeMem jitter
+    freeMem proportion
+    freeMem quality
+    return (jitter', proportion'', quality')
+
+data MessageParseQosValuesMethodInfo
+instance (signature ~ (m (Int64,Double,Int32)), MonadIO m) => MethodInfo MessageParseQosValuesMethodInfo Message signature where
+    overloadedMethod _ = messageParseQosValues
+
+-- method Message::parse_request_state
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "state", argType = TInterface "Gst" "State", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_message_parse_request_state" gst_message_parse_request_state :: 
+    Ptr Message ->                          -- _obj : TInterface "Gst" "Message"
+    Ptr CUInt ->                            -- state : TInterface "Gst" "State"
+    IO ()
+
+
+messageParseRequestState ::
+    (MonadIO m) =>
+    Message                                 -- _obj
+    -> m (State)                            -- result
+messageParseRequestState _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    state <- allocMem :: IO (Ptr CUInt)
+    gst_message_parse_request_state _obj' state
+    state' <- peek state
+    let state'' = (toEnum . fromIntegral) state'
+    touchManagedPtr _obj
+    freeMem state
+    return state''
+
+data MessageParseRequestStateMethodInfo
+instance (signature ~ (m (State)), MonadIO m) => MethodInfo MessageParseRequestStateMethodInfo Message signature where
+    overloadedMethod _ = messageParseRequestState
+
+-- method Message::parse_reset_time
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "running_time", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_message_parse_reset_time" gst_message_parse_reset_time :: 
+    Ptr Message ->                          -- _obj : TInterface "Gst" "Message"
+    Ptr Word64 ->                           -- running_time : TBasicType TUInt64
+    IO ()
+
+
+messageParseResetTime ::
+    (MonadIO m) =>
+    Message                                 -- _obj
+    -> m (Word64)                           -- result
+messageParseResetTime _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    runningTime <- allocMem :: IO (Ptr Word64)
+    gst_message_parse_reset_time _obj' runningTime
+    runningTime' <- peek runningTime
+    touchManagedPtr _obj
+    freeMem runningTime
+    return runningTime'
+
+data MessageParseResetTimeMethodInfo
+instance (signature ~ (m (Word64)), MonadIO m) => MethodInfo MessageParseResetTimeMethodInfo Message signature where
+    overloadedMethod _ = messageParseResetTime
+
+-- method Message::parse_segment_done
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "position", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_message_parse_segment_done" gst_message_parse_segment_done :: 
+    Ptr Message ->                          -- _obj : TInterface "Gst" "Message"
+    Ptr CUInt ->                            -- format : TInterface "Gst" "Format"
+    Ptr Int64 ->                            -- position : TBasicType TInt64
+    IO ()
+
+
+messageParseSegmentDone ::
+    (MonadIO m) =>
+    Message                                 -- _obj
+    -> m (Format,Int64)                     -- result
+messageParseSegmentDone _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    format <- allocMem :: IO (Ptr CUInt)
+    position <- allocMem :: IO (Ptr Int64)
+    gst_message_parse_segment_done _obj' format position
+    format' <- peek format
+    let format'' = (toEnum . fromIntegral) format'
+    position' <- peek position
+    touchManagedPtr _obj
+    freeMem format
+    freeMem position
+    return (format'', position')
+
+data MessageParseSegmentDoneMethodInfo
+instance (signature ~ (m (Format,Int64)), MonadIO m) => MethodInfo MessageParseSegmentDoneMethodInfo Message signature where
+    overloadedMethod _ = messageParseSegmentDone
+
+-- method Message::parse_segment_start
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "position", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_message_parse_segment_start" gst_message_parse_segment_start :: 
+    Ptr Message ->                          -- _obj : TInterface "Gst" "Message"
+    Ptr CUInt ->                            -- format : TInterface "Gst" "Format"
+    Ptr Int64 ->                            -- position : TBasicType TInt64
+    IO ()
+
+
+messageParseSegmentStart ::
+    (MonadIO m) =>
+    Message                                 -- _obj
+    -> m (Format,Int64)                     -- result
+messageParseSegmentStart _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    format <- allocMem :: IO (Ptr CUInt)
+    position <- allocMem :: IO (Ptr Int64)
+    gst_message_parse_segment_start _obj' format position
+    format' <- peek format
+    let format'' = (toEnum . fromIntegral) format'
+    position' <- peek position
+    touchManagedPtr _obj
+    freeMem format
+    freeMem position
+    return (format'', position')
+
+data MessageParseSegmentStartMethodInfo
+instance (signature ~ (m (Format,Int64)), MonadIO m) => MethodInfo MessageParseSegmentStartMethodInfo Message signature where
+    overloadedMethod _ = messageParseSegmentStart
+
+-- method Message::parse_state_changed
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "oldstate", argType = TInterface "Gst" "State", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "newstate", argType = TInterface "Gst" "State", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "pending", argType = TInterface "Gst" "State", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_message_parse_state_changed" gst_message_parse_state_changed :: 
+    Ptr Message ->                          -- _obj : TInterface "Gst" "Message"
+    Ptr CUInt ->                            -- oldstate : TInterface "Gst" "State"
+    Ptr CUInt ->                            -- newstate : TInterface "Gst" "State"
+    Ptr CUInt ->                            -- pending : TInterface "Gst" "State"
+    IO ()
+
+
+messageParseStateChanged ::
+    (MonadIO m) =>
+    Message                                 -- _obj
+    -> m (State,State,State)                -- result
+messageParseStateChanged _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    oldstate <- allocMem :: IO (Ptr CUInt)
+    newstate <- allocMem :: IO (Ptr CUInt)
+    pending <- allocMem :: IO (Ptr CUInt)
+    gst_message_parse_state_changed _obj' oldstate newstate pending
+    oldstate' <- peek oldstate
+    let oldstate'' = (toEnum . fromIntegral) oldstate'
+    newstate' <- peek newstate
+    let newstate'' = (toEnum . fromIntegral) newstate'
+    pending' <- peek pending
+    let pending'' = (toEnum . fromIntegral) pending'
+    touchManagedPtr _obj
+    freeMem oldstate
+    freeMem newstate
+    freeMem pending
+    return (oldstate'', newstate'', pending'')
+
+data MessageParseStateChangedMethodInfo
+instance (signature ~ (m (State,State,State)), MonadIO m) => MethodInfo MessageParseStateChangedMethodInfo Message signature where
+    overloadedMethod _ = messageParseStateChanged
+
+-- method Message::parse_step_done
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "amount", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "rate", argType = TBasicType TDouble, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "flush", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "intermediate", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "duration", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "eos", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_message_parse_step_done" gst_message_parse_step_done :: 
+    Ptr Message ->                          -- _obj : TInterface "Gst" "Message"
+    Ptr CUInt ->                            -- format : TInterface "Gst" "Format"
+    Ptr Word64 ->                           -- amount : TBasicType TUInt64
+    Ptr CDouble ->                          -- rate : TBasicType TDouble
+    Ptr CInt ->                             -- flush : TBasicType TBoolean
+    Ptr CInt ->                             -- intermediate : TBasicType TBoolean
+    Ptr Word64 ->                           -- duration : TBasicType TUInt64
+    Ptr CInt ->                             -- eos : TBasicType TBoolean
+    IO ()
+
+
+messageParseStepDone ::
+    (MonadIO m) =>
+    Message                                 -- _obj
+    -> m (Format,Word64,Double,Bool,Bool,Word64,Bool)-- result
+messageParseStepDone _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    format <- allocMem :: IO (Ptr CUInt)
+    amount <- allocMem :: IO (Ptr Word64)
+    rate <- allocMem :: IO (Ptr CDouble)
+    flush <- allocMem :: IO (Ptr CInt)
+    intermediate <- allocMem :: IO (Ptr CInt)
+    duration <- allocMem :: IO (Ptr Word64)
+    eos <- allocMem :: IO (Ptr CInt)
+    gst_message_parse_step_done _obj' format amount rate flush intermediate duration eos
+    format' <- peek format
+    let format'' = (toEnum . fromIntegral) format'
+    amount' <- peek amount
+    rate' <- peek rate
+    let rate'' = realToFrac rate'
+    flush' <- peek flush
+    let flush'' = (/= 0) flush'
+    intermediate' <- peek intermediate
+    let intermediate'' = (/= 0) intermediate'
+    duration' <- peek duration
+    eos' <- peek eos
+    let eos'' = (/= 0) eos'
+    touchManagedPtr _obj
+    freeMem format
+    freeMem amount
+    freeMem rate
+    freeMem flush
+    freeMem intermediate
+    freeMem duration
+    freeMem eos
+    return (format'', amount', rate'', flush'', intermediate'', duration', eos'')
+
+data MessageParseStepDoneMethodInfo
+instance (signature ~ (m (Format,Word64,Double,Bool,Bool,Word64,Bool)), MonadIO m) => MethodInfo MessageParseStepDoneMethodInfo Message signature where
+    overloadedMethod _ = messageParseStepDone
+
+-- method Message::parse_step_start
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "active", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "amount", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "rate", argType = TBasicType TDouble, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "flush", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "intermediate", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_message_parse_step_start" gst_message_parse_step_start :: 
+    Ptr Message ->                          -- _obj : TInterface "Gst" "Message"
+    Ptr CInt ->                             -- active : TBasicType TBoolean
+    Ptr CUInt ->                            -- format : TInterface "Gst" "Format"
+    Ptr Word64 ->                           -- amount : TBasicType TUInt64
+    Ptr CDouble ->                          -- rate : TBasicType TDouble
+    Ptr CInt ->                             -- flush : TBasicType TBoolean
+    Ptr CInt ->                             -- intermediate : TBasicType TBoolean
+    IO ()
+
+
+messageParseStepStart ::
+    (MonadIO m) =>
+    Message                                 -- _obj
+    -> m (Bool,Format,Word64,Double,Bool,Bool)-- result
+messageParseStepStart _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    active <- allocMem :: IO (Ptr CInt)
+    format <- allocMem :: IO (Ptr CUInt)
+    amount <- allocMem :: IO (Ptr Word64)
+    rate <- allocMem :: IO (Ptr CDouble)
+    flush <- allocMem :: IO (Ptr CInt)
+    intermediate <- allocMem :: IO (Ptr CInt)
+    gst_message_parse_step_start _obj' active format amount rate flush intermediate
+    active' <- peek active
+    let active'' = (/= 0) active'
+    format' <- peek format
+    let format'' = (toEnum . fromIntegral) format'
+    amount' <- peek amount
+    rate' <- peek rate
+    let rate'' = realToFrac rate'
+    flush' <- peek flush
+    let flush'' = (/= 0) flush'
+    intermediate' <- peek intermediate
+    let intermediate'' = (/= 0) intermediate'
+    touchManagedPtr _obj
+    freeMem active
+    freeMem format
+    freeMem amount
+    freeMem rate
+    freeMem flush
+    freeMem intermediate
+    return (active'', format'', amount', rate'', flush'', intermediate'')
+
+data MessageParseStepStartMethodInfo
+instance (signature ~ (m (Bool,Format,Word64,Double,Bool,Bool)), MonadIO m) => MethodInfo MessageParseStepStartMethodInfo Message signature where
+    overloadedMethod _ = messageParseStepStart
+
+-- method Message::parse_stream_status
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "type", argType = TInterface "Gst" "StreamStatusType", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "owner", argType = TInterface "Gst" "Element", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_message_parse_stream_status" gst_message_parse_stream_status :: 
+    Ptr Message ->                          -- _obj : TInterface "Gst" "Message"
+    Ptr CUInt ->                            -- type : TInterface "Gst" "StreamStatusType"
+    Ptr (Ptr Element) ->                    -- owner : TInterface "Gst" "Element"
+    IO ()
+
+
+messageParseStreamStatus ::
+    (MonadIO m) =>
+    Message                                 -- _obj
+    -> m (StreamStatusType,Element)         -- result
+messageParseStreamStatus _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    type_ <- allocMem :: IO (Ptr CUInt)
+    owner <- allocMem :: IO (Ptr (Ptr Element))
+    gst_message_parse_stream_status _obj' type_ owner
+    type_' <- peek type_
+    let type_'' = (toEnum . fromIntegral) type_'
+    owner' <- peek owner
+    owner'' <- (newObject Element) owner'
+    touchManagedPtr _obj
+    freeMem type_
+    freeMem owner
+    return (type_'', owner'')
+
+data MessageParseStreamStatusMethodInfo
+instance (signature ~ (m (StreamStatusType,Element)), MonadIO m) => MethodInfo MessageParseStreamStatusMethodInfo Message signature where
+    overloadedMethod _ = messageParseStreamStatus
+
+-- method Message::parse_structure_change
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "type", argType = TInterface "Gst" "StructureChangeType", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "owner", argType = TInterface "Gst" "Element", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "busy", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_message_parse_structure_change" gst_message_parse_structure_change :: 
+    Ptr Message ->                          -- _obj : TInterface "Gst" "Message"
+    Ptr CUInt ->                            -- type : TInterface "Gst" "StructureChangeType"
+    Ptr (Ptr Element) ->                    -- owner : TInterface "Gst" "Element"
+    Ptr CInt ->                             -- busy : TBasicType TBoolean
+    IO ()
+
+
+messageParseStructureChange ::
+    (MonadIO m) =>
+    Message                                 -- _obj
+    -> m (StructureChangeType,Element,Bool) -- result
+messageParseStructureChange _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    type_ <- allocMem :: IO (Ptr CUInt)
+    owner <- allocMem :: IO (Ptr (Ptr Element))
+    busy <- allocMem :: IO (Ptr CInt)
+    gst_message_parse_structure_change _obj' type_ owner busy
+    type_' <- peek type_
+    let type_'' = (toEnum . fromIntegral) type_'
+    owner' <- peek owner
+    owner'' <- (newObject Element) owner'
+    busy' <- peek busy
+    let busy'' = (/= 0) busy'
+    touchManagedPtr _obj
+    freeMem type_
+    freeMem owner
+    freeMem busy
+    return (type_'', owner'', busy'')
+
+data MessageParseStructureChangeMethodInfo
+instance (signature ~ (m (StructureChangeType,Element,Bool)), MonadIO m) => MethodInfo MessageParseStructureChangeMethodInfo Message signature where
+    overloadedMethod _ = messageParseStructureChange
+
+-- method Message::parse_tag
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag_list", argType = TInterface "Gst" "TagList", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_message_parse_tag" gst_message_parse_tag :: 
+    Ptr Message ->                          -- _obj : TInterface "Gst" "Message"
+    Ptr TagList ->                          -- tag_list : TInterface "Gst" "TagList"
+    IO ()
+
+
+messageParseTag ::
+    (MonadIO m) =>
+    Message                                 -- _obj
+    -> m (TagList)                          -- result
+messageParseTag _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    tagList <- callocBoxedBytes 64 :: IO (Ptr TagList)
+    gst_message_parse_tag _obj' tagList
+    tagList' <- (wrapBoxed TagList) tagList
+    touchManagedPtr _obj
+    return tagList'
+
+data MessageParseTagMethodInfo
+instance (signature ~ (m (TagList)), MonadIO m) => MethodInfo MessageParseTagMethodInfo Message signature where
+    overloadedMethod _ = messageParseTag
+
+-- method Message::parse_toc
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "toc", argType = TInterface "Gst" "Toc", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "updated", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_message_parse_toc" gst_message_parse_toc :: 
+    Ptr Message ->                          -- _obj : TInterface "Gst" "Message"
+    Ptr (Ptr Toc) ->                        -- toc : TInterface "Gst" "Toc"
+    Ptr CInt ->                             -- updated : TBasicType TBoolean
+    IO ()
+
+
+messageParseToc ::
+    (MonadIO m) =>
+    Message                                 -- _obj
+    -> m (Toc,Bool)                         -- result
+messageParseToc _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    toc <- allocMem :: IO (Ptr (Ptr Toc))
+    updated <- allocMem :: IO (Ptr CInt)
+    gst_message_parse_toc _obj' toc updated
+    toc' <- peek toc
+    toc'' <- (wrapBoxed Toc) toc'
+    updated' <- peek updated
+    let updated'' = (/= 0) updated'
+    touchManagedPtr _obj
+    freeMem toc
+    freeMem updated
+    return (toc'', updated'')
+
+data MessageParseTocMethodInfo
+instance (signature ~ (m (Toc,Bool)), MonadIO m) => MethodInfo MessageParseTocMethodInfo Message signature where
+    overloadedMethod _ = messageParseToc
+
+-- method Message::parse_warning
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "gerror", argType = TError, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "debug", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_message_parse_warning" gst_message_parse_warning :: 
+    Ptr Message ->                          -- _obj : TInterface "Gst" "Message"
+    Ptr GError ->                           -- gerror : TError
+    Ptr CString ->                          -- debug : TBasicType TUTF8
+    IO ()
+
+
+messageParseWarning ::
+    (MonadIO m) =>
+    Message                                 -- _obj
+    -> m (GError,T.Text)                    -- result
+messageParseWarning _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    gerror <- callocBoxedBytes 16 :: IO (Ptr GError)
+    debug <- allocMem :: IO (Ptr CString)
+    gst_message_parse_warning _obj' gerror debug
+    gerror' <- (wrapBoxed GError) gerror
+    debug' <- peek debug
+    debug'' <- cstringToText debug'
+    freeMem debug'
+    touchManagedPtr _obj
+    freeMem debug
+    return (gerror', debug'')
+
+data MessageParseWarningMethodInfo
+instance (signature ~ (m (GError,T.Text)), MonadIO m) => MethodInfo MessageParseWarningMethodInfo Message signature where
+    overloadedMethod _ = messageParseWarning
+
+-- method Message::set_buffering_stats
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mode", argType = TInterface "Gst" "BufferingMode", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "avg_in", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "avg_out", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "buffering_left", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_message_set_buffering_stats" gst_message_set_buffering_stats :: 
+    Ptr Message ->                          -- _obj : TInterface "Gst" "Message"
+    CUInt ->                                -- mode : TInterface "Gst" "BufferingMode"
+    Int32 ->                                -- avg_in : TBasicType TInt32
+    Int32 ->                                -- avg_out : TBasicType TInt32
+    Int64 ->                                -- buffering_left : TBasicType TInt64
+    IO ()
+
+
+messageSetBufferingStats ::
+    (MonadIO m) =>
+    Message                                 -- _obj
+    -> BufferingMode                        -- mode
+    -> Int32                                -- avgIn
+    -> Int32                                -- avgOut
+    -> Int64                                -- bufferingLeft
+    -> m ()                                 -- result
+messageSetBufferingStats _obj mode avgIn avgOut bufferingLeft = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let mode' = (fromIntegral . fromEnum) mode
+    gst_message_set_buffering_stats _obj' mode' avgIn avgOut bufferingLeft
+    touchManagedPtr _obj
+    return ()
+
+data MessageSetBufferingStatsMethodInfo
+instance (signature ~ (BufferingMode -> Int32 -> Int32 -> Int64 -> m ()), MonadIO m) => MethodInfo MessageSetBufferingStatsMethodInfo Message signature where
+    overloadedMethod _ = messageSetBufferingStats
+
+-- method Message::set_group_id
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "group_id", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_message_set_group_id" gst_message_set_group_id :: 
+    Ptr Message ->                          -- _obj : TInterface "Gst" "Message"
+    Word32 ->                               -- group_id : TBasicType TUInt32
+    IO ()
+
+
+messageSetGroupId ::
+    (MonadIO m) =>
+    Message                                 -- _obj
+    -> Word32                               -- groupId
+    -> m ()                                 -- result
+messageSetGroupId _obj groupId = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    gst_message_set_group_id _obj' groupId
+    touchManagedPtr _obj
+    return ()
+
+data MessageSetGroupIdMethodInfo
+instance (signature ~ (Word32 -> m ()), MonadIO m) => MethodInfo MessageSetGroupIdMethodInfo Message signature where
+    overloadedMethod _ = messageSetGroupId
+
+-- method Message::set_qos_stats
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "processed", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dropped", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_message_set_qos_stats" gst_message_set_qos_stats :: 
+    Ptr Message ->                          -- _obj : TInterface "Gst" "Message"
+    CUInt ->                                -- format : TInterface "Gst" "Format"
+    Word64 ->                               -- processed : TBasicType TUInt64
+    Word64 ->                               -- dropped : TBasicType TUInt64
+    IO ()
+
+
+messageSetQosStats ::
+    (MonadIO m) =>
+    Message                                 -- _obj
+    -> Format                               -- format
+    -> Word64                               -- processed
+    -> Word64                               -- dropped
+    -> m ()                                 -- result
+messageSetQosStats _obj format processed dropped = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let format' = (fromIntegral . fromEnum) format
+    gst_message_set_qos_stats _obj' format' processed dropped
+    touchManagedPtr _obj
+    return ()
+
+data MessageSetQosStatsMethodInfo
+instance (signature ~ (Format -> Word64 -> Word64 -> m ()), MonadIO m) => MethodInfo MessageSetQosStatsMethodInfo Message signature where
+    overloadedMethod _ = messageSetQosStats
+
+-- method Message::set_qos_values
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "jitter", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "proportion", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "quality", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_message_set_qos_values" gst_message_set_qos_values :: 
+    Ptr Message ->                          -- _obj : TInterface "Gst" "Message"
+    Int64 ->                                -- jitter : TBasicType TInt64
+    CDouble ->                              -- proportion : TBasicType TDouble
+    Int32 ->                                -- quality : TBasicType TInt32
+    IO ()
+
+
+messageSetQosValues ::
+    (MonadIO m) =>
+    Message                                 -- _obj
+    -> Int64                                -- jitter
+    -> Double                               -- proportion
+    -> Int32                                -- quality
+    -> m ()                                 -- result
+messageSetQosValues _obj jitter proportion quality = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let proportion' = realToFrac proportion
+    gst_message_set_qos_values _obj' jitter proportion' quality
+    touchManagedPtr _obj
+    return ()
+
+data MessageSetQosValuesMethodInfo
+instance (signature ~ (Int64 -> Double -> Int32 -> m ()), MonadIO m) => MethodInfo MessageSetQosValuesMethodInfo Message signature where
+    overloadedMethod _ = messageSetQosValues
+
+-- method Message::set_seqnum
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "seqnum", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_message_set_seqnum" gst_message_set_seqnum :: 
+    Ptr Message ->                          -- _obj : TInterface "Gst" "Message"
+    Word32 ->                               -- seqnum : TBasicType TUInt32
+    IO ()
+
+
+messageSetSeqnum ::
+    (MonadIO m) =>
+    Message                                 -- _obj
+    -> Word32                               -- seqnum
+    -> m ()                                 -- result
+messageSetSeqnum _obj seqnum = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    gst_message_set_seqnum _obj' seqnum
+    touchManagedPtr _obj
+    return ()
+
+data MessageSetSeqnumMethodInfo
+instance (signature ~ (Word32 -> m ()), MonadIO m) => MethodInfo MessageSetSeqnumMethodInfo Message signature where
+    overloadedMethod _ = messageSetSeqnum
+
+-- method Message::set_stream_status_object
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Message", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "object", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_message_set_stream_status_object" gst_message_set_stream_status_object :: 
+    Ptr Message ->                          -- _obj : TInterface "Gst" "Message"
+    Ptr GValue ->                           -- object : TInterface "GObject" "Value"
+    IO ()
+
+
+messageSetStreamStatusObject ::
+    (MonadIO m) =>
+    Message                                 -- _obj
+    -> GValue                               -- object
+    -> m ()                                 -- result
+messageSetStreamStatusObject _obj object = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let object' = unsafeManagedPtrGetPtr object
+    gst_message_set_stream_status_object _obj' object'
+    touchManagedPtr _obj
+    touchManagedPtr object
+    return ()
+
+data MessageSetStreamStatusObjectMethodInfo
+instance (signature ~ (GValue -> m ()), MonadIO m) => MethodInfo MessageSetStreamStatusObjectMethodInfo Message signature where
+    overloadedMethod _ = messageSetStreamStatusObject
+
+type family ResolveMessageMethod (t :: Symbol) (o :: *) :: * where
+    ResolveMessageMethod "hasName" o = MessageHasNameMethodInfo
+    ResolveMessageMethod "parseAsyncDone" o = MessageParseAsyncDoneMethodInfo
+    ResolveMessageMethod "parseBuffering" o = MessageParseBufferingMethodInfo
+    ResolveMessageMethod "parseBufferingStats" o = MessageParseBufferingStatsMethodInfo
+    ResolveMessageMethod "parseClockLost" o = MessageParseClockLostMethodInfo
+    ResolveMessageMethod "parseClockProvide" o = MessageParseClockProvideMethodInfo
+    ResolveMessageMethod "parseContextType" o = MessageParseContextTypeMethodInfo
+    ResolveMessageMethod "parseDeviceAdded" o = MessageParseDeviceAddedMethodInfo
+    ResolveMessageMethod "parseDeviceRemoved" o = MessageParseDeviceRemovedMethodInfo
+    ResolveMessageMethod "parseError" o = MessageParseErrorMethodInfo
+    ResolveMessageMethod "parseGroupId" o = MessageParseGroupIdMethodInfo
+    ResolveMessageMethod "parseHaveContext" o = MessageParseHaveContextMethodInfo
+    ResolveMessageMethod "parseInfo" o = MessageParseInfoMethodInfo
+    ResolveMessageMethod "parseNewClock" o = MessageParseNewClockMethodInfo
+    ResolveMessageMethod "parseProgress" o = MessageParseProgressMethodInfo
+    ResolveMessageMethod "parseQos" o = MessageParseQosMethodInfo
+    ResolveMessageMethod "parseQosStats" o = MessageParseQosStatsMethodInfo
+    ResolveMessageMethod "parseQosValues" o = MessageParseQosValuesMethodInfo
+    ResolveMessageMethod "parseRequestState" o = MessageParseRequestStateMethodInfo
+    ResolveMessageMethod "parseResetTime" o = MessageParseResetTimeMethodInfo
+    ResolveMessageMethod "parseSegmentDone" o = MessageParseSegmentDoneMethodInfo
+    ResolveMessageMethod "parseSegmentStart" o = MessageParseSegmentStartMethodInfo
+    ResolveMessageMethod "parseStateChanged" o = MessageParseStateChangedMethodInfo
+    ResolveMessageMethod "parseStepDone" o = MessageParseStepDoneMethodInfo
+    ResolveMessageMethod "parseStepStart" o = MessageParseStepStartMethodInfo
+    ResolveMessageMethod "parseStreamStatus" o = MessageParseStreamStatusMethodInfo
+    ResolveMessageMethod "parseStructureChange" o = MessageParseStructureChangeMethodInfo
+    ResolveMessageMethod "parseTag" o = MessageParseTagMethodInfo
+    ResolveMessageMethod "parseToc" o = MessageParseTocMethodInfo
+    ResolveMessageMethod "parseWarning" o = MessageParseWarningMethodInfo
+    ResolveMessageMethod "getSeqnum" o = MessageGetSeqnumMethodInfo
+    ResolveMessageMethod "getStreamStatusObject" o = MessageGetStreamStatusObjectMethodInfo
+    ResolveMessageMethod "getStructure" o = MessageGetStructureMethodInfo
+    ResolveMessageMethod "setBufferingStats" o = MessageSetBufferingStatsMethodInfo
+    ResolveMessageMethod "setGroupId" o = MessageSetGroupIdMethodInfo
+    ResolveMessageMethod "setQosStats" o = MessageSetQosStatsMethodInfo
+    ResolveMessageMethod "setQosValues" o = MessageSetQosValuesMethodInfo
+    ResolveMessageMethod "setSeqnum" o = MessageSetSeqnumMethodInfo
+    ResolveMessageMethod "setStreamStatusObject" o = MessageSetStreamStatusObjectMethodInfo
+    ResolveMessageMethod l o = MethodResolutionFailed l o
+
+instance (info ~ ResolveMessageMethod t Message, MethodInfo info Message p) => IsLabelProxy t (Message -> p) where
+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)
+
+#if MIN_VERSION_base(4,9,0)
+instance (info ~ ResolveMessageMethod t Message, MethodInfo info Message p) => IsLabel t (Message -> p) where
+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)
+#endif
+
+
diff --git a/GI/Gst/Structs/Message.hs-boot b/GI/Gst/Structs/Message.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/Message.hs-boot
@@ -0,0 +1,50 @@
+module GI.Gst.Structs.Message where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+newtype Message = Message (ForeignPtr Message)
+instance BoxedObject Message where
+data MessageGetSeqnumMethodInfo
+data MessageGetStreamStatusObjectMethodInfo
+data MessageGetStructureMethodInfo
+data MessageHasNameMethodInfo
+data MessageParseAsyncDoneMethodInfo
+data MessageParseBufferingMethodInfo
+data MessageParseBufferingStatsMethodInfo
+data MessageParseClockLostMethodInfo
+data MessageParseClockProvideMethodInfo
+data MessageParseContextTypeMethodInfo
+data MessageParseDeviceAddedMethodInfo
+data MessageParseDeviceRemovedMethodInfo
+data MessageParseErrorMethodInfo
+data MessageParseGroupIdMethodInfo
+data MessageParseHaveContextMethodInfo
+data MessageParseInfoMethodInfo
+data MessageParseNewClockMethodInfo
+data MessageParseProgressMethodInfo
+data MessageParseQosMethodInfo
+data MessageParseQosStatsMethodInfo
+data MessageParseQosValuesMethodInfo
+data MessageParseRequestStateMethodInfo
+data MessageParseResetTimeMethodInfo
+data MessageParseSegmentDoneMethodInfo
+data MessageParseSegmentStartMethodInfo
+data MessageParseStateChangedMethodInfo
+data MessageParseStepDoneMethodInfo
+data MessageParseStepStartMethodInfo
+data MessageParseStreamStatusMethodInfo
+data MessageParseStructureChangeMethodInfo
+data MessageParseTagMethodInfo
+data MessageParseTocMethodInfo
+data MessageParseWarningMethodInfo
+data MessageSetBufferingStatsMethodInfo
+data MessageSetGroupIdMethodInfo
+data MessageSetQosStatsMethodInfo
+data MessageSetQosValuesMethodInfo
+data MessageSetSeqnumMethodInfo
+data MessageSetStreamStatusObjectMethodInfo
diff --git a/GI/Gst/Structs/Meta.hs b/GI/Gst/Structs/Meta.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/Meta.hs
@@ -0,0 +1,262 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+
+The #GstMeta structure should be included as the first member of a #GstBuffer
+metadata structure. The structure defines the API of the metadata and should
+be accessible to all elements using the metadata.
+
+A metadata API is registered with gst_meta_api_type_register() which takes a
+name for the metadata API and some tags associated with the metadata.
+With gst_meta_api_type_has_tag() one can check if a certain metadata API
+contains a given tag.
+
+Multiple implementations of a metadata API can be registered.
+To implement a metadata API, gst_meta_register() should be used. This
+function takes all parameters needed to create, free and transform metadata
+along with the size of the metadata. The function returns a #GstMetaInfo
+structure that contains the information for the implementation of the API.
+
+A specific implementation can be retrieved by name with gst_meta_get_info().
+
+See #GstBuffer for how the metadata can be added, retrieved and removed from
+buffers.
+-}
+
+module GI.Gst.Structs.Meta
+    ( 
+
+-- * Exported types
+    Meta(..)                                ,
+    newZeroMeta                             ,
+    noMeta                                  ,
+
+
+ -- * Methods
+-- ** metaApiTypeGetTags
+    metaApiTypeGetTags                      ,
+
+
+-- ** metaApiTypeHasTag
+    metaApiTypeHasTag                       ,
+
+
+-- ** metaApiTypeRegister
+    metaApiTypeRegister                     ,
+
+
+-- ** metaGetInfo
+    metaGetInfo                             ,
+
+
+-- ** metaRegister
+    metaRegister                            ,
+
+
+
+
+ -- * Properties
+-- ** Flags
+    metaReadFlags                           ,
+
+
+-- ** Info
+    metaReadInfo                            ,
+
+
+
+
+    ) where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+import GI.Gst.Callbacks
+
+newtype Meta = Meta (ForeignPtr Meta)
+-- | Construct a `Meta` struct initialized to zero.
+newZeroMeta :: MonadIO m => m Meta
+newZeroMeta = liftIO $ callocBytes 16 >>= wrapPtr Meta
+
+noMeta :: Maybe Meta
+noMeta = Nothing
+
+metaReadFlags :: Meta -> IO [MetaFlags]
+metaReadFlags s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 0) :: IO CUInt
+    let val' = wordToGFlags val
+    return val'
+
+metaReadInfo :: Meta -> IO MetaInfo
+metaReadInfo s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 8) :: IO (Ptr MetaInfo)
+    val' <- (newPtr 80 MetaInfo) val
+    return val'
+
+-- method Meta::api_type_get_tags
+-- method type : MemberFunction
+-- Args : [Arg {argCName = "api", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TCArray True (-1) (-1) (TBasicType TUTF8)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_meta_api_type_get_tags" gst_meta_api_type_get_tags :: 
+    CGType ->                               -- api : TBasicType TGType
+    IO (Ptr CString)
+
+
+metaApiTypeGetTags ::
+    (MonadIO m) =>
+    GType                                   -- api
+    -> m [T.Text]                           -- result
+metaApiTypeGetTags api = liftIO $ do
+    let api' = gtypeToCGType api
+    result <- gst_meta_api_type_get_tags api'
+    checkUnexpectedReturnNULL "gst_meta_api_type_get_tags" result
+    result' <- unpackZeroTerminatedUTF8CArray result
+    return result'
+
+-- method Meta::api_type_has_tag
+-- method type : MemberFunction
+-- Args : [Arg {argCName = "api", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_meta_api_type_has_tag" gst_meta_api_type_has_tag :: 
+    CGType ->                               -- api : TBasicType TGType
+    Word32 ->                               -- tag : TBasicType TUInt32
+    IO CInt
+
+
+metaApiTypeHasTag ::
+    (MonadIO m) =>
+    GType                                   -- api
+    -> Word32                               -- tag
+    -> m Bool                               -- result
+metaApiTypeHasTag api tag = liftIO $ do
+    let api' = gtypeToCGType api
+    result <- gst_meta_api_type_has_tag api' tag
+    let result' = (/= 0) result
+    return result'
+
+-- method Meta::api_type_register
+-- method type : MemberFunction
+-- Args : [Arg {argCName = "api", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tags", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TGType
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_meta_api_type_register" gst_meta_api_type_register :: 
+    CString ->                              -- api : TBasicType TUTF8
+    CString ->                              -- tags : TBasicType TUTF8
+    IO CGType
+
+
+metaApiTypeRegister ::
+    (MonadIO m) =>
+    T.Text                                  -- api
+    -> T.Text                               -- tags
+    -> m GType                              -- result
+metaApiTypeRegister api tags = liftIO $ do
+    api' <- textToCString api
+    tags' <- textToCString tags
+    result <- gst_meta_api_type_register api' tags'
+    let result' = GType result
+    freeMem api'
+    freeMem tags'
+    return result'
+
+-- method Meta::get_info
+-- method type : MemberFunction
+-- Args : [Arg {argCName = "impl", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "MetaInfo"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_meta_get_info" gst_meta_get_info :: 
+    CString ->                              -- impl : TBasicType TUTF8
+    IO (Ptr MetaInfo)
+
+
+metaGetInfo ::
+    (MonadIO m) =>
+    T.Text                                  -- impl
+    -> m MetaInfo                           -- result
+metaGetInfo impl = liftIO $ do
+    impl' <- textToCString impl
+    result <- gst_meta_get_info impl'
+    checkUnexpectedReturnNULL "gst_meta_get_info" result
+    result' <- (newPtr 80 MetaInfo) result
+    freeMem impl'
+    return result'
+
+-- method Meta::register
+-- method type : MemberFunction
+-- Args : [Arg {argCName = "api", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "impl", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "init_func", argType = TInterface "Gst" "MetaInitFunction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "free_func", argType = TInterface "Gst" "MetaFreeFunction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "transform_func", argType = TInterface "Gst" "MetaTransformFunction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "MetaInfo"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_meta_register" gst_meta_register :: 
+    CGType ->                               -- api : TBasicType TGType
+    CString ->                              -- impl : TBasicType TUTF8
+    Word64 ->                               -- size : TBasicType TUInt64
+    FunPtr MetaInitFunctionC ->             -- init_func : TInterface "Gst" "MetaInitFunction"
+    FunPtr MetaFreeFunctionC ->             -- free_func : TInterface "Gst" "MetaFreeFunction"
+    FunPtr MetaTransformFunctionC ->        -- transform_func : TInterface "Gst" "MetaTransformFunction"
+    IO (Ptr MetaInfo)
+
+
+metaRegister ::
+    (MonadIO m) =>
+    GType                                   -- api
+    -> T.Text                               -- impl
+    -> Word64                               -- size
+    -> MetaInitFunction                     -- initFunc
+    -> MetaFreeFunction                     -- freeFunc
+    -> MetaTransformFunction                -- transformFunc
+    -> m MetaInfo                           -- result
+metaRegister api impl size initFunc freeFunc transformFunc = liftIO $ do
+    let api' = gtypeToCGType api
+    impl' <- textToCString impl
+    ptrinitFunc <- callocMem :: IO (Ptr (FunPtr MetaInitFunctionC))
+    initFunc' <- mkMetaInitFunction (metaInitFunctionWrapper (Just ptrinitFunc) initFunc)
+    poke ptrinitFunc initFunc'
+    ptrfreeFunc <- callocMem :: IO (Ptr (FunPtr MetaFreeFunctionC))
+    freeFunc' <- mkMetaFreeFunction (metaFreeFunctionWrapper (Just ptrfreeFunc) freeFunc)
+    poke ptrfreeFunc freeFunc'
+    ptrtransformFunc <- callocMem :: IO (Ptr (FunPtr MetaTransformFunctionC))
+    transformFunc' <- mkMetaTransformFunction (metaTransformFunctionWrapper (Just ptrtransformFunc) transformFunc)
+    poke ptrtransformFunc transformFunc'
+    result <- gst_meta_register api' impl' size initFunc' freeFunc' transformFunc'
+    checkUnexpectedReturnNULL "gst_meta_register" result
+    result' <- (newPtr 80 MetaInfo) result
+    freeMem impl'
+    return result'
+
+type family ResolveMetaMethod (t :: Symbol) (o :: *) :: * where
+    ResolveMetaMethod l o = MethodResolutionFailed l o
+
+instance (info ~ ResolveMetaMethod t Meta, MethodInfo info Meta p) => IsLabelProxy t (Meta -> p) where
+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)
+
+#if MIN_VERSION_base(4,9,0)
+instance (info ~ ResolveMetaMethod t Meta, MethodInfo info Meta p) => IsLabel t (Meta -> p) where
+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)
+#endif
+
+
diff --git a/GI/Gst/Structs/Meta.hs-boot b/GI/Gst/Structs/Meta.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/Meta.hs-boot
@@ -0,0 +1,10 @@
+module GI.Gst.Structs.Meta where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+newtype Meta = Meta (ForeignPtr Meta)
diff --git a/GI/Gst/Structs/MetaInfo.hs b/GI/Gst/Structs/MetaInfo.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/MetaInfo.hs
@@ -0,0 +1,90 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+
+The #GstMetaInfo provides information about a specific metadata
+structure.
+-}
+
+module GI.Gst.Structs.MetaInfo
+    ( 
+
+-- * Exported types
+    MetaInfo(..)                            ,
+    newZeroMetaInfo                         ,
+    noMetaInfo                              ,
+
+
+ -- * Properties
+-- ** Api
+    metaInfoReadApi                         ,
+
+
+-- ** Size
+    metaInfoReadSize                        ,
+
+
+-- ** Type
+    metaInfoReadType                        ,
+
+
+
+
+    ) where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+import GI.Gst.Callbacks
+
+newtype MetaInfo = MetaInfo (ForeignPtr MetaInfo)
+-- | Construct a `MetaInfo` struct initialized to zero.
+newZeroMetaInfo :: MonadIO m => m MetaInfo
+newZeroMetaInfo = liftIO $ callocBytes 80 >>= wrapPtr MetaInfo
+
+noMetaInfo :: Maybe MetaInfo
+noMetaInfo = Nothing
+
+metaInfoReadApi :: MetaInfo -> IO GType
+metaInfoReadApi s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 0) :: IO CGType
+    let val' = GType val
+    return val'
+
+metaInfoReadType :: MetaInfo -> IO GType
+metaInfoReadType s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 8) :: IO CGType
+    let val' = GType val
+    return val'
+
+metaInfoReadSize :: MetaInfo -> IO Word64
+metaInfoReadSize s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 16) :: IO Word64
+    return val
+
+-- XXX Skipped getter for "MetaInfo:init_func" :: Not implemented: "Wrapping foreign callbacks is not supported yet"
+
+-- XXX Skipped getter for "MetaInfo:free_func" :: Not implemented: "Wrapping foreign callbacks is not supported yet"
+
+-- XXX Skipped getter for "MetaInfo:transform_func" :: Not implemented: "Wrapping foreign callbacks is not supported yet"
+
+type family ResolveMetaInfoMethod (t :: Symbol) (o :: *) :: * where
+    ResolveMetaInfoMethod l o = MethodResolutionFailed l o
+
+instance (info ~ ResolveMetaInfoMethod t MetaInfo, MethodInfo info MetaInfo p) => IsLabelProxy t (MetaInfo -> p) where
+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)
+
+#if MIN_VERSION_base(4,9,0)
+instance (info ~ ResolveMetaInfoMethod t MetaInfo, MethodInfo info MetaInfo p) => IsLabel t (MetaInfo -> p) where
+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)
+#endif
+
+
diff --git a/GI/Gst/Structs/MetaInfo.hs-boot b/GI/Gst/Structs/MetaInfo.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/MetaInfo.hs-boot
@@ -0,0 +1,10 @@
+module GI.Gst.Structs.MetaInfo where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+newtype MetaInfo = MetaInfo (ForeignPtr MetaInfo)
diff --git a/GI/Gst/Structs/MetaTransformCopy.hs b/GI/Gst/Structs/MetaTransformCopy.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/MetaTransformCopy.hs
@@ -0,0 +1,82 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+
+Extra data passed to a "gst-copy" transform #GstMetaTransformFunction.
+-}
+
+module GI.Gst.Structs.MetaTransformCopy
+    ( 
+
+-- * Exported types
+    MetaTransformCopy(..)                   ,
+    newZeroMetaTransformCopy                ,
+    noMetaTransformCopy                     ,
+
+
+ -- * Properties
+-- ** Offset
+    metaTransformCopyReadOffset             ,
+
+
+-- ** Region
+    metaTransformCopyReadRegion             ,
+
+
+-- ** Size
+    metaTransformCopyReadSize               ,
+
+
+
+
+    ) where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+import GI.Gst.Callbacks
+
+newtype MetaTransformCopy = MetaTransformCopy (ForeignPtr MetaTransformCopy)
+-- | Construct a `MetaTransformCopy` struct initialized to zero.
+newZeroMetaTransformCopy :: MonadIO m => m MetaTransformCopy
+newZeroMetaTransformCopy = liftIO $ callocBytes 24 >>= wrapPtr MetaTransformCopy
+
+noMetaTransformCopy :: Maybe MetaTransformCopy
+noMetaTransformCopy = Nothing
+
+metaTransformCopyReadRegion :: MetaTransformCopy -> IO Bool
+metaTransformCopyReadRegion s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 0) :: IO CInt
+    let val' = (/= 0) val
+    return val'
+
+metaTransformCopyReadOffset :: MetaTransformCopy -> IO Word64
+metaTransformCopyReadOffset s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 8) :: IO Word64
+    return val
+
+metaTransformCopyReadSize :: MetaTransformCopy -> IO Word64
+metaTransformCopyReadSize s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 16) :: IO Word64
+    return val
+
+type family ResolveMetaTransformCopyMethod (t :: Symbol) (o :: *) :: * where
+    ResolveMetaTransformCopyMethod l o = MethodResolutionFailed l o
+
+instance (info ~ ResolveMetaTransformCopyMethod t MetaTransformCopy, MethodInfo info MetaTransformCopy p) => IsLabelProxy t (MetaTransformCopy -> p) where
+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)
+
+#if MIN_VERSION_base(4,9,0)
+instance (info ~ ResolveMetaTransformCopyMethod t MetaTransformCopy, MethodInfo info MetaTransformCopy p) => IsLabel t (MetaTransformCopy -> p) where
+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)
+#endif
+
+
diff --git a/GI/Gst/Structs/MetaTransformCopy.hs-boot b/GI/Gst/Structs/MetaTransformCopy.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/MetaTransformCopy.hs-boot
@@ -0,0 +1,10 @@
+module GI.Gst.Structs.MetaTransformCopy where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+newtype MetaTransformCopy = MetaTransformCopy (ForeignPtr MetaTransformCopy)
diff --git a/GI/Gst/Structs/MiniObject.hs b/GI/Gst/Structs/MiniObject.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/MiniObject.hs
@@ -0,0 +1,379 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+
+#GstMiniObject is a simple structure that can be used to implement refcounted
+types.
+
+Subclasses will include #GstMiniObject as the first member in their structure
+and then call gst_mini_object_init() to initialize the #GstMiniObject fields.
+
+gst_mini_object_ref() and gst_mini_object_unref() increment and decrement the
+refcount respectively. When the refcount of a mini-object reaches 0, the
+dispose function is called first and when this returns %TRUE, the free
+function of the miniobject is called.
+
+A copy can be made with gst_mini_object_copy().
+
+gst_mini_object_is_writable() will return %TRUE when the refcount of the
+object is exactly 1, meaning the current caller has the only reference to the
+object. gst_mini_object_make_writable() will return a writable version of the
+object, which might be a new copy when the refcount was not 1.
+
+Opaque data can be associated with a #GstMiniObject with
+gst_mini_object_set_qdata() and gst_mini_object_get_qdata(). The data is
+meant to be specific to the particular object and is not automatically copied
+with gst_mini_object_copy() or similar methods.
+
+A weak reference can be added and remove with gst_mini_object_weak_ref()
+and gst_mini_object_weak_unref() respectively.
+-}
+
+module GI.Gst.Structs.MiniObject
+    ( 
+
+-- * Exported types
+    MiniObject(..)                          ,
+    newZeroMiniObject                       ,
+    noMiniObject                            ,
+
+
+ -- * Methods
+-- ** miniObjectGetQdata
+    MiniObjectGetQdataMethodInfo            ,
+    miniObjectGetQdata                      ,
+
+
+-- ** miniObjectIsWritable
+    MiniObjectIsWritableMethodInfo          ,
+    miniObjectIsWritable                    ,
+
+
+-- ** miniObjectLock
+    MiniObjectLockMethodInfo                ,
+    miniObjectLock                          ,
+
+
+-- ** miniObjectSetQdata
+    MiniObjectSetQdataMethodInfo            ,
+    miniObjectSetQdata                      ,
+
+
+-- ** miniObjectStealQdata
+    MiniObjectStealQdataMethodInfo          ,
+    miniObjectStealQdata                    ,
+
+
+-- ** miniObjectTake
+    miniObjectTake                          ,
+
+
+-- ** miniObjectUnlock
+    MiniObjectUnlockMethodInfo              ,
+    miniObjectUnlock                        ,
+
+
+
+
+ -- * Properties
+-- ** Flags
+    miniObjectReadFlags                     ,
+
+
+-- ** Lockstate
+    miniObjectReadLockstate                 ,
+
+
+-- ** Refcount
+    miniObjectReadRefcount                  ,
+
+
+-- ** Type
+    miniObjectReadType                      ,
+
+
+
+
+    ) where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+import GI.Gst.Callbacks
+import qualified GI.GLib as GLib
+
+newtype MiniObject = MiniObject (ForeignPtr MiniObject)
+-- | Construct a `MiniObject` struct initialized to zero.
+newZeroMiniObject :: MonadIO m => m MiniObject
+newZeroMiniObject = liftIO $ callocBytes 64 >>= wrapPtr MiniObject
+
+noMiniObject :: Maybe MiniObject
+noMiniObject = Nothing
+
+miniObjectReadType :: MiniObject -> IO GType
+miniObjectReadType s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 0) :: IO CGType
+    let val' = GType val
+    return val'
+
+miniObjectReadRefcount :: MiniObject -> IO Int32
+miniObjectReadRefcount s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 8) :: IO Int32
+    return val
+
+miniObjectReadLockstate :: MiniObject -> IO Int32
+miniObjectReadLockstate s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 12) :: IO Int32
+    return val
+
+miniObjectReadFlags :: MiniObject -> IO Word32
+miniObjectReadFlags s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 16) :: IO Word32
+    return val
+
+-- XXX Skipped getter for "MiniObject:dispose" :: Not implemented: "Wrapping foreign callbacks is not supported yet"
+
+-- XXX Skipped getter for "MiniObject:free" :: Not implemented: "Wrapping foreign callbacks is not supported yet"
+
+-- method MiniObject::get_qdata
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "MiniObject", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "quark", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_mini_object_get_qdata" gst_mini_object_get_qdata :: 
+    Ptr MiniObject ->                       -- _obj : TInterface "Gst" "MiniObject"
+    Word32 ->                               -- quark : TBasicType TUInt32
+    IO ()
+
+
+miniObjectGetQdata ::
+    (MonadIO m) =>
+    MiniObject                              -- _obj
+    -> Word32                               -- quark
+    -> m ()                                 -- result
+miniObjectGetQdata _obj quark = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    gst_mini_object_get_qdata _obj' quark
+    touchManagedPtr _obj
+    return ()
+
+data MiniObjectGetQdataMethodInfo
+instance (signature ~ (Word32 -> m ()), MonadIO m) => MethodInfo MiniObjectGetQdataMethodInfo MiniObject signature where
+    overloadedMethod _ = miniObjectGetQdata
+
+-- method MiniObject::is_writable
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "MiniObject", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_mini_object_is_writable" gst_mini_object_is_writable :: 
+    Ptr MiniObject ->                       -- _obj : TInterface "Gst" "MiniObject"
+    IO CInt
+
+
+miniObjectIsWritable ::
+    (MonadIO m) =>
+    MiniObject                              -- _obj
+    -> m Bool                               -- result
+miniObjectIsWritable _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_mini_object_is_writable _obj'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data MiniObjectIsWritableMethodInfo
+instance (signature ~ (m Bool), MonadIO m) => MethodInfo MiniObjectIsWritableMethodInfo MiniObject signature where
+    overloadedMethod _ = miniObjectIsWritable
+
+-- method MiniObject::lock
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "MiniObject", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface "Gst" "LockFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_mini_object_lock" gst_mini_object_lock :: 
+    Ptr MiniObject ->                       -- _obj : TInterface "Gst" "MiniObject"
+    CUInt ->                                -- flags : TInterface "Gst" "LockFlags"
+    IO CInt
+
+
+miniObjectLock ::
+    (MonadIO m) =>
+    MiniObject                              -- _obj
+    -> [LockFlags]                          -- flags
+    -> m Bool                               -- result
+miniObjectLock _obj flags = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let flags' = gflagsToWord flags
+    result <- gst_mini_object_lock _obj' flags'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data MiniObjectLockMethodInfo
+instance (signature ~ ([LockFlags] -> m Bool), MonadIO m) => MethodInfo MiniObjectLockMethodInfo MiniObject signature where
+    overloadedMethod _ = miniObjectLock
+
+-- method MiniObject::set_qdata
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "MiniObject", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "quark", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "destroy", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_mini_object_set_qdata" gst_mini_object_set_qdata :: 
+    Ptr MiniObject ->                       -- _obj : TInterface "Gst" "MiniObject"
+    Word32 ->                               -- quark : TBasicType TUInt32
+    Ptr () ->                               -- data : TBasicType TVoid
+    FunPtr GLib.DestroyNotifyC ->           -- destroy : TInterface "GLib" "DestroyNotify"
+    IO ()
+
+
+miniObjectSetQdata ::
+    (MonadIO m) =>
+    MiniObject                              -- _obj
+    -> Word32                               -- quark
+    -> Ptr ()                               -- data_
+    -> GLib.DestroyNotify                   -- destroy
+    -> m ()                                 -- result
+miniObjectSetQdata _obj quark data_ destroy = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    ptrdestroy <- callocMem :: IO (Ptr (FunPtr GLib.DestroyNotifyC))
+    destroy' <- GLib.mkDestroyNotify (GLib.destroyNotifyWrapper (Just ptrdestroy) destroy)
+    poke ptrdestroy destroy'
+    gst_mini_object_set_qdata _obj' quark data_ destroy'
+    touchManagedPtr _obj
+    return ()
+
+data MiniObjectSetQdataMethodInfo
+instance (signature ~ (Word32 -> Ptr () -> GLib.DestroyNotify -> m ()), MonadIO m) => MethodInfo MiniObjectSetQdataMethodInfo MiniObject signature where
+    overloadedMethod _ = miniObjectSetQdata
+
+-- method MiniObject::steal_qdata
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "MiniObject", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "quark", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_mini_object_steal_qdata" gst_mini_object_steal_qdata :: 
+    Ptr MiniObject ->                       -- _obj : TInterface "Gst" "MiniObject"
+    Word32 ->                               -- quark : TBasicType TUInt32
+    IO ()
+
+
+miniObjectStealQdata ::
+    (MonadIO m) =>
+    MiniObject                              -- _obj
+    -> Word32                               -- quark
+    -> m ()                                 -- result
+miniObjectStealQdata _obj quark = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    gst_mini_object_steal_qdata _obj' quark
+    touchManagedPtr _obj
+    return ()
+
+data MiniObjectStealQdataMethodInfo
+instance (signature ~ (Word32 -> m ()), MonadIO m) => MethodInfo MiniObjectStealQdataMethodInfo MiniObject signature where
+    overloadedMethod _ = miniObjectStealQdata
+
+-- method MiniObject::unlock
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "MiniObject", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface "Gst" "LockFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_mini_object_unlock" gst_mini_object_unlock :: 
+    Ptr MiniObject ->                       -- _obj : TInterface "Gst" "MiniObject"
+    CUInt ->                                -- flags : TInterface "Gst" "LockFlags"
+    IO ()
+
+
+miniObjectUnlock ::
+    (MonadIO m) =>
+    MiniObject                              -- _obj
+    -> [LockFlags]                          -- flags
+    -> m ()                                 -- result
+miniObjectUnlock _obj flags = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let flags' = gflagsToWord flags
+    gst_mini_object_unlock _obj' flags'
+    touchManagedPtr _obj
+    return ()
+
+data MiniObjectUnlockMethodInfo
+instance (signature ~ ([LockFlags] -> m ()), MonadIO m) => MethodInfo MiniObjectUnlockMethodInfo MiniObject signature where
+    overloadedMethod _ = miniObjectUnlock
+
+-- XXX Could not generate method MiniObject::replace
+-- Error was : Not implemented: "Nullable inout structs not supported"
+-- method MiniObject::take
+-- method type : MemberFunction
+-- Args : [Arg {argCName = "olddata", argType = TInterface "Gst" "MiniObject", direction = DirectionInout, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "newdata", argType = TInterface "Gst" "MiniObject", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_mini_object_take" gst_mini_object_take :: 
+    Ptr MiniObject ->                       -- olddata : TInterface "Gst" "MiniObject"
+    Ptr MiniObject ->                       -- newdata : TInterface "Gst" "MiniObject"
+    IO CInt
+
+
+miniObjectTake ::
+    (MonadIO m) =>
+    MiniObject                              -- olddata
+    -> MiniObject                           -- newdata
+    -> m (Bool,MiniObject)                  -- result
+miniObjectTake olddata newdata = liftIO $ do
+    let olddata' = unsafeManagedPtrGetPtr olddata
+    olddata'' <- callocBytes 64 :: IO (Ptr MiniObject)
+    memcpy olddata'' olddata' 64
+    let newdata' = unsafeManagedPtrGetPtr newdata
+    result <- gst_mini_object_take olddata'' newdata'
+    let result' = (/= 0) result
+    olddata''' <- (wrapPtr MiniObject) olddata''
+    touchManagedPtr olddata
+    touchManagedPtr newdata
+    return (result', olddata''')
+
+type family ResolveMiniObjectMethod (t :: Symbol) (o :: *) :: * where
+    ResolveMiniObjectMethod "isWritable" o = MiniObjectIsWritableMethodInfo
+    ResolveMiniObjectMethod "lock" o = MiniObjectLockMethodInfo
+    ResolveMiniObjectMethod "stealQdata" o = MiniObjectStealQdataMethodInfo
+    ResolveMiniObjectMethod "unlock" o = MiniObjectUnlockMethodInfo
+    ResolveMiniObjectMethod "getQdata" o = MiniObjectGetQdataMethodInfo
+    ResolveMiniObjectMethod "setQdata" o = MiniObjectSetQdataMethodInfo
+    ResolveMiniObjectMethod l o = MethodResolutionFailed l o
+
+instance (info ~ ResolveMiniObjectMethod t MiniObject, MethodInfo info MiniObject p) => IsLabelProxy t (MiniObject -> p) where
+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)
+
+#if MIN_VERSION_base(4,9,0)
+instance (info ~ ResolveMiniObjectMethod t MiniObject, MethodInfo info MiniObject p) => IsLabel t (MiniObject -> p) where
+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)
+#endif
+
+
diff --git a/GI/Gst/Structs/MiniObject.hs-boot b/GI/Gst/Structs/MiniObject.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/MiniObject.hs-boot
@@ -0,0 +1,16 @@
+module GI.Gst.Structs.MiniObject where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+newtype MiniObject = MiniObject (ForeignPtr MiniObject)
+data MiniObjectGetQdataMethodInfo
+data MiniObjectIsWritableMethodInfo
+data MiniObjectLockMethodInfo
+data MiniObjectSetQdataMethodInfo
+data MiniObjectStealQdataMethodInfo
+data MiniObjectUnlockMethodInfo
diff --git a/GI/Gst/Structs/PadProbeInfo.hs b/GI/Gst/Structs/PadProbeInfo.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/PadProbeInfo.hs
@@ -0,0 +1,243 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+
+Info passed in the #GstPadProbeCallback.
+-}
+
+module GI.Gst.Structs.PadProbeInfo
+    ( 
+
+-- * Exported types
+    PadProbeInfo(..)                        ,
+    newZeroPadProbeInfo                     ,
+    noPadProbeInfo                          ,
+
+
+ -- * Methods
+-- ** padProbeInfoGetBuffer
+    PadProbeInfoGetBufferMethodInfo         ,
+    padProbeInfoGetBuffer                   ,
+
+
+-- ** padProbeInfoGetBufferList
+    PadProbeInfoGetBufferListMethodInfo     ,
+    padProbeInfoGetBufferList               ,
+
+
+-- ** padProbeInfoGetEvent
+    PadProbeInfoGetEventMethodInfo          ,
+    padProbeInfoGetEvent                    ,
+
+
+-- ** padProbeInfoGetQuery
+    PadProbeInfoGetQueryMethodInfo          ,
+    padProbeInfoGetQuery                    ,
+
+
+
+
+ -- * Properties
+-- ** Data
+    padProbeInfoReadData                    ,
+
+
+-- ** Id
+    padProbeInfoReadId                      ,
+
+
+-- ** Offset
+    padProbeInfoReadOffset                  ,
+
+
+-- ** Size
+    padProbeInfoReadSize                    ,
+
+
+-- ** Type
+    padProbeInfoReadType                    ,
+
+
+
+
+    ) where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+import GI.Gst.Callbacks
+
+newtype PadProbeInfo = PadProbeInfo (ForeignPtr PadProbeInfo)
+-- | Construct a `PadProbeInfo` struct initialized to zero.
+newZeroPadProbeInfo :: MonadIO m => m PadProbeInfo
+newZeroPadProbeInfo = liftIO $ callocBytes 40 >>= wrapPtr PadProbeInfo
+
+noPadProbeInfo :: Maybe PadProbeInfo
+noPadProbeInfo = Nothing
+
+padProbeInfoReadType :: PadProbeInfo -> IO [PadProbeType]
+padProbeInfoReadType s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 0) :: IO CUInt
+    let val' = wordToGFlags val
+    return val'
+
+padProbeInfoReadId :: PadProbeInfo -> IO Word64
+padProbeInfoReadId s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 8) :: IO Word64
+    return val
+
+padProbeInfoReadData :: PadProbeInfo -> IO (Ptr ())
+padProbeInfoReadData s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 16) :: IO (Ptr ())
+    return val
+
+padProbeInfoReadOffset :: PadProbeInfo -> IO Word64
+padProbeInfoReadOffset s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 24) :: IO Word64
+    return val
+
+padProbeInfoReadSize :: PadProbeInfo -> IO Word32
+padProbeInfoReadSize s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 32) :: IO Word32
+    return val
+
+-- method PadProbeInfo::get_buffer
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "PadProbeInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Buffer"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_probe_info_get_buffer" gst_pad_probe_info_get_buffer :: 
+    Ptr PadProbeInfo ->                     -- _obj : TInterface "Gst" "PadProbeInfo"
+    IO (Ptr Buffer)
+
+
+padProbeInfoGetBuffer ::
+    (MonadIO m) =>
+    PadProbeInfo                            -- _obj
+    -> m Buffer                             -- result
+padProbeInfoGetBuffer _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_pad_probe_info_get_buffer _obj'
+    checkUnexpectedReturnNULL "gst_pad_probe_info_get_buffer" result
+    result' <- (newBoxed Buffer) result
+    touchManagedPtr _obj
+    return result'
+
+data PadProbeInfoGetBufferMethodInfo
+instance (signature ~ (m Buffer), MonadIO m) => MethodInfo PadProbeInfoGetBufferMethodInfo PadProbeInfo signature where
+    overloadedMethod _ = padProbeInfoGetBuffer
+
+-- method PadProbeInfo::get_buffer_list
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "PadProbeInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "BufferList"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_probe_info_get_buffer_list" gst_pad_probe_info_get_buffer_list :: 
+    Ptr PadProbeInfo ->                     -- _obj : TInterface "Gst" "PadProbeInfo"
+    IO (Ptr BufferList)
+
+
+padProbeInfoGetBufferList ::
+    (MonadIO m) =>
+    PadProbeInfo                            -- _obj
+    -> m BufferList                         -- result
+padProbeInfoGetBufferList _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_pad_probe_info_get_buffer_list _obj'
+    checkUnexpectedReturnNULL "gst_pad_probe_info_get_buffer_list" result
+    result' <- (newBoxed BufferList) result
+    touchManagedPtr _obj
+    return result'
+
+data PadProbeInfoGetBufferListMethodInfo
+instance (signature ~ (m BufferList), MonadIO m) => MethodInfo PadProbeInfoGetBufferListMethodInfo PadProbeInfo signature where
+    overloadedMethod _ = padProbeInfoGetBufferList
+
+-- method PadProbeInfo::get_event
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "PadProbeInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Event"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_probe_info_get_event" gst_pad_probe_info_get_event :: 
+    Ptr PadProbeInfo ->                     -- _obj : TInterface "Gst" "PadProbeInfo"
+    IO (Ptr Event)
+
+
+padProbeInfoGetEvent ::
+    (MonadIO m) =>
+    PadProbeInfo                            -- _obj
+    -> m Event                              -- result
+padProbeInfoGetEvent _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_pad_probe_info_get_event _obj'
+    checkUnexpectedReturnNULL "gst_pad_probe_info_get_event" result
+    result' <- (newBoxed Event) result
+    touchManagedPtr _obj
+    return result'
+
+data PadProbeInfoGetEventMethodInfo
+instance (signature ~ (m Event), MonadIO m) => MethodInfo PadProbeInfoGetEventMethodInfo PadProbeInfo signature where
+    overloadedMethod _ = padProbeInfoGetEvent
+
+-- method PadProbeInfo::get_query
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "PadProbeInfo", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Query"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_pad_probe_info_get_query" gst_pad_probe_info_get_query :: 
+    Ptr PadProbeInfo ->                     -- _obj : TInterface "Gst" "PadProbeInfo"
+    IO (Ptr Query)
+
+
+padProbeInfoGetQuery ::
+    (MonadIO m) =>
+    PadProbeInfo                            -- _obj
+    -> m Query                              -- result
+padProbeInfoGetQuery _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_pad_probe_info_get_query _obj'
+    checkUnexpectedReturnNULL "gst_pad_probe_info_get_query" result
+    result' <- (newBoxed Query) result
+    touchManagedPtr _obj
+    return result'
+
+data PadProbeInfoGetQueryMethodInfo
+instance (signature ~ (m Query), MonadIO m) => MethodInfo PadProbeInfoGetQueryMethodInfo PadProbeInfo signature where
+    overloadedMethod _ = padProbeInfoGetQuery
+
+type family ResolvePadProbeInfoMethod (t :: Symbol) (o :: *) :: * where
+    ResolvePadProbeInfoMethod "getBuffer" o = PadProbeInfoGetBufferMethodInfo
+    ResolvePadProbeInfoMethod "getBufferList" o = PadProbeInfoGetBufferListMethodInfo
+    ResolvePadProbeInfoMethod "getEvent" o = PadProbeInfoGetEventMethodInfo
+    ResolvePadProbeInfoMethod "getQuery" o = PadProbeInfoGetQueryMethodInfo
+    ResolvePadProbeInfoMethod l o = MethodResolutionFailed l o
+
+instance (info ~ ResolvePadProbeInfoMethod t PadProbeInfo, MethodInfo info PadProbeInfo p) => IsLabelProxy t (PadProbeInfo -> p) where
+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)
+
+#if MIN_VERSION_base(4,9,0)
+instance (info ~ ResolvePadProbeInfoMethod t PadProbeInfo, MethodInfo info PadProbeInfo p) => IsLabel t (PadProbeInfo -> p) where
+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)
+#endif
+
+
diff --git a/GI/Gst/Structs/PadProbeInfo.hs-boot b/GI/Gst/Structs/PadProbeInfo.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/PadProbeInfo.hs-boot
@@ -0,0 +1,14 @@
+module GI.Gst.Structs.PadProbeInfo where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+newtype PadProbeInfo = PadProbeInfo (ForeignPtr PadProbeInfo)
+data PadProbeInfoGetBufferMethodInfo
+data PadProbeInfoGetBufferListMethodInfo
+data PadProbeInfoGetEventMethodInfo
+data PadProbeInfoGetQueryMethodInfo
diff --git a/GI/Gst/Structs/ParamSpecFraction.hs b/GI/Gst/Structs/ParamSpecFraction.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/ParamSpecFraction.hs
@@ -0,0 +1,119 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+
+A GParamSpec derived structure that contains the meta data for fractional
+properties.
+-}
+
+module GI.Gst.Structs.ParamSpecFraction
+    ( 
+
+-- * Exported types
+    ParamSpecFraction(..)                   ,
+    newZeroParamSpecFraction                ,
+    noParamSpecFraction                     ,
+
+
+ -- * Properties
+-- ** DefDen
+    paramSpecFractionReadDefDen             ,
+
+
+-- ** DefNum
+    paramSpecFractionReadDefNum             ,
+
+
+-- ** MaxDen
+    paramSpecFractionReadMaxDen             ,
+
+
+-- ** MaxNum
+    paramSpecFractionReadMaxNum             ,
+
+
+-- ** MinDen
+    paramSpecFractionReadMinDen             ,
+
+
+-- ** MinNum
+    paramSpecFractionReadMinNum             ,
+
+
+-- ** ParentInstance
+    paramSpecFractionReadParentInstance     ,
+
+
+
+
+    ) where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+import GI.Gst.Callbacks
+
+newtype ParamSpecFraction = ParamSpecFraction (ForeignPtr ParamSpecFraction)
+-- | Construct a `ParamSpecFraction` struct initialized to zero.
+newZeroParamSpecFraction :: MonadIO m => m ParamSpecFraction
+newZeroParamSpecFraction = liftIO $ callocBytes 96 >>= wrapPtr ParamSpecFraction
+
+noParamSpecFraction :: Maybe ParamSpecFraction
+noParamSpecFraction = Nothing
+
+paramSpecFractionReadParentInstance :: ParamSpecFraction -> IO GParamSpec
+paramSpecFractionReadParentInstance s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 0) :: IO (Ptr GParamSpec)
+    val' <- newGParamSpecFromPtr val
+    return val'
+
+paramSpecFractionReadMinNum :: ParamSpecFraction -> IO Int32
+paramSpecFractionReadMinNum s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 72) :: IO Int32
+    return val
+
+paramSpecFractionReadMinDen :: ParamSpecFraction -> IO Int32
+paramSpecFractionReadMinDen s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 76) :: IO Int32
+    return val
+
+paramSpecFractionReadMaxNum :: ParamSpecFraction -> IO Int32
+paramSpecFractionReadMaxNum s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 80) :: IO Int32
+    return val
+
+paramSpecFractionReadMaxDen :: ParamSpecFraction -> IO Int32
+paramSpecFractionReadMaxDen s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 84) :: IO Int32
+    return val
+
+paramSpecFractionReadDefNum :: ParamSpecFraction -> IO Int32
+paramSpecFractionReadDefNum s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 88) :: IO Int32
+    return val
+
+paramSpecFractionReadDefDen :: ParamSpecFraction -> IO Int32
+paramSpecFractionReadDefDen s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 92) :: IO Int32
+    return val
+
+type family ResolveParamSpecFractionMethod (t :: Symbol) (o :: *) :: * where
+    ResolveParamSpecFractionMethod l o = MethodResolutionFailed l o
+
+instance (info ~ ResolveParamSpecFractionMethod t ParamSpecFraction, MethodInfo info ParamSpecFraction p) => IsLabelProxy t (ParamSpecFraction -> p) where
+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)
+
+#if MIN_VERSION_base(4,9,0)
+instance (info ~ ResolveParamSpecFractionMethod t ParamSpecFraction, MethodInfo info ParamSpecFraction p) => IsLabel t (ParamSpecFraction -> p) where
+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)
+#endif
+
+
diff --git a/GI/Gst/Structs/ParamSpecFraction.hs-boot b/GI/Gst/Structs/ParamSpecFraction.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/ParamSpecFraction.hs-boot
@@ -0,0 +1,10 @@
+module GI.Gst.Structs.ParamSpecFraction where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+newtype ParamSpecFraction = ParamSpecFraction (ForeignPtr ParamSpecFraction)
diff --git a/GI/Gst/Structs/ParentBufferMeta.hs b/GI/Gst/Structs/ParentBufferMeta.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/ParentBufferMeta.hs
@@ -0,0 +1,109 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+
+The #GstParentBufferMeta is a #GstMeta which can be attached to a #GstBuffer
+to hold a reference to another buffer that is only released when the child
+#GstBuffer is released.
+
+Typically, #GstParentBufferMeta is used when the child buffer is directly
+using the #GstMemory of the parent buffer, and wants to prevent the parent
+buffer from being returned to a buffer pool until the #GstMemory is available
+for re-use.
+-}
+
+module GI.Gst.Structs.ParentBufferMeta
+    ( 
+
+-- * Exported types
+    ParentBufferMeta(..)                    ,
+    newZeroParentBufferMeta                 ,
+    noParentBufferMeta                      ,
+
+
+ -- * Methods
+-- ** parentBufferMetaGetInfo
+    parentBufferMetaGetInfo                 ,
+
+
+
+
+ -- * Properties
+-- ** Buffer
+    parentBufferMetaReadBuffer              ,
+
+
+-- ** Parent
+    parentBufferMetaReadParent              ,
+
+
+
+
+    ) where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+import GI.Gst.Callbacks
+
+newtype ParentBufferMeta = ParentBufferMeta (ForeignPtr ParentBufferMeta)
+-- | Construct a `ParentBufferMeta` struct initialized to zero.
+newZeroParentBufferMeta :: MonadIO m => m ParentBufferMeta
+newZeroParentBufferMeta = liftIO $ callocBytes 24 >>= wrapPtr ParentBufferMeta
+
+noParentBufferMeta :: Maybe ParentBufferMeta
+noParentBufferMeta = Nothing
+
+parentBufferMetaReadParent :: ParentBufferMeta -> IO Meta
+parentBufferMetaReadParent s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 0) :: IO (Ptr Meta)
+    val' <- (newPtr 16 Meta) val
+    return val'
+
+parentBufferMetaReadBuffer :: ParentBufferMeta -> IO Buffer
+parentBufferMetaReadBuffer s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 16) :: IO (Ptr Buffer)
+    val' <- (newBoxed Buffer) val
+    return val'
+
+-- method ParentBufferMeta::get_info
+-- method type : MemberFunction
+-- Args : []
+-- Lengths : []
+-- returnType : TInterface "Gst" "MetaInfo"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_parent_buffer_meta_get_info" gst_parent_buffer_meta_get_info :: 
+    IO (Ptr MetaInfo)
+
+
+parentBufferMetaGetInfo ::
+    (MonadIO m) =>
+    m MetaInfo                              -- result
+parentBufferMetaGetInfo  = liftIO $ do
+    result <- gst_parent_buffer_meta_get_info
+    checkUnexpectedReturnNULL "gst_parent_buffer_meta_get_info" result
+    result' <- (newPtr 80 MetaInfo) result
+    return result'
+
+type family ResolveParentBufferMetaMethod (t :: Symbol) (o :: *) :: * where
+    ResolveParentBufferMetaMethod l o = MethodResolutionFailed l o
+
+instance (info ~ ResolveParentBufferMetaMethod t ParentBufferMeta, MethodInfo info ParentBufferMeta p) => IsLabelProxy t (ParentBufferMeta -> p) where
+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)
+
+#if MIN_VERSION_base(4,9,0)
+instance (info ~ ResolveParentBufferMetaMethod t ParentBufferMeta, MethodInfo info ParentBufferMeta p) => IsLabel t (ParentBufferMeta -> p) where
+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)
+#endif
+
+
diff --git a/GI/Gst/Structs/ParentBufferMeta.hs-boot b/GI/Gst/Structs/ParentBufferMeta.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/ParentBufferMeta.hs-boot
@@ -0,0 +1,10 @@
+module GI.Gst.Structs.ParentBufferMeta where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+newtype ParentBufferMeta = ParentBufferMeta (ForeignPtr ParentBufferMeta)
diff --git a/GI/Gst/Structs/ParseContext.hs b/GI/Gst/Structs/ParseContext.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/ParseContext.hs
@@ -0,0 +1,150 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+
+Opaque structure.
+-}
+
+module GI.Gst.Structs.ParseContext
+    ( 
+
+-- * Exported types
+    ParseContext(..)                        ,
+    noParseContext                          ,
+
+
+ -- * Methods
+-- ** parseContextFree
+    ParseContextFreeMethodInfo              ,
+    parseContextFree                        ,
+
+
+-- ** parseContextGetMissingElements
+    ParseContextGetMissingElementsMethodInfo,
+    parseContextGetMissingElements          ,
+
+
+-- ** parseContextNew
+    parseContextNew                         ,
+
+
+
+
+    ) where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+import GI.Gst.Callbacks
+
+newtype ParseContext = ParseContext (ForeignPtr ParseContext)
+foreign import ccall "gst_parse_context_get_type" c_gst_parse_context_get_type :: 
+    IO GType
+
+instance BoxedObject ParseContext where
+    boxedType _ = c_gst_parse_context_get_type
+
+noParseContext :: Maybe ParseContext
+noParseContext = Nothing
+
+-- method ParseContext::new
+-- method type : Constructor
+-- Args : []
+-- Lengths : []
+-- returnType : TInterface "Gst" "ParseContext"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_parse_context_new" gst_parse_context_new :: 
+    IO (Ptr ParseContext)
+
+
+parseContextNew ::
+    (MonadIO m) =>
+    m ParseContext                          -- result
+parseContextNew  = liftIO $ do
+    result <- gst_parse_context_new
+    checkUnexpectedReturnNULL "gst_parse_context_new" result
+    result' <- (wrapBoxed ParseContext) result
+    return result'
+
+-- method ParseContext::free
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "ParseContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_parse_context_free" gst_parse_context_free :: 
+    Ptr ParseContext ->                     -- _obj : TInterface "Gst" "ParseContext"
+    IO ()
+
+
+parseContextFree ::
+    (MonadIO m) =>
+    ParseContext                            -- _obj
+    -> m ()                                 -- result
+parseContextFree _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    gst_parse_context_free _obj'
+    touchManagedPtr _obj
+    return ()
+
+data ParseContextFreeMethodInfo
+instance (signature ~ (m ()), MonadIO m) => MethodInfo ParseContextFreeMethodInfo ParseContext signature where
+    overloadedMethod _ = parseContextFree
+
+-- method ParseContext::get_missing_elements
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "ParseContext", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TCArray True (-1) (-1) (TBasicType TUTF8)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_parse_context_get_missing_elements" gst_parse_context_get_missing_elements :: 
+    Ptr ParseContext ->                     -- _obj : TInterface "Gst" "ParseContext"
+    IO (Ptr CString)
+
+
+parseContextGetMissingElements ::
+    (MonadIO m) =>
+    ParseContext                            -- _obj
+    -> m [T.Text]                           -- result
+parseContextGetMissingElements _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_parse_context_get_missing_elements _obj'
+    checkUnexpectedReturnNULL "gst_parse_context_get_missing_elements" result
+    result' <- unpackZeroTerminatedUTF8CArray result
+    mapZeroTerminatedCArray freeMem result
+    freeMem result
+    touchManagedPtr _obj
+    return result'
+
+data ParseContextGetMissingElementsMethodInfo
+instance (signature ~ (m [T.Text]), MonadIO m) => MethodInfo ParseContextGetMissingElementsMethodInfo ParseContext signature where
+    overloadedMethod _ = parseContextGetMissingElements
+
+type family ResolveParseContextMethod (t :: Symbol) (o :: *) :: * where
+    ResolveParseContextMethod "free" o = ParseContextFreeMethodInfo
+    ResolveParseContextMethod "getMissingElements" o = ParseContextGetMissingElementsMethodInfo
+    ResolveParseContextMethod l o = MethodResolutionFailed l o
+
+instance (info ~ ResolveParseContextMethod t ParseContext, MethodInfo info ParseContext p) => IsLabelProxy t (ParseContext -> p) where
+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)
+
+#if MIN_VERSION_base(4,9,0)
+instance (info ~ ResolveParseContextMethod t ParseContext, MethodInfo info ParseContext p) => IsLabel t (ParseContext -> p) where
+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)
+#endif
+
+
diff --git a/GI/Gst/Structs/ParseContext.hs-boot b/GI/Gst/Structs/ParseContext.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/ParseContext.hs-boot
@@ -0,0 +1,13 @@
+module GI.Gst.Structs.ParseContext where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+newtype ParseContext = ParseContext (ForeignPtr ParseContext)
+instance BoxedObject ParseContext where
+data ParseContextFreeMethodInfo
+data ParseContextGetMissingElementsMethodInfo
diff --git a/GI/Gst/Structs/PluginDesc.hs b/GI/Gst/Structs/PluginDesc.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/PluginDesc.hs
@@ -0,0 +1,158 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+
+A plugin should export a variable of this type called plugin_desc. The plugin
+loader will use the data provided there to initialize the plugin.
+
+The @licence parameter must be one of: LGPL, GPL, QPL, GPL/QPL, MPL,
+BSD, MIT/X11, Proprietary, unknown.
+-}
+
+module GI.Gst.Structs.PluginDesc
+    ( 
+
+-- * Exported types
+    PluginDesc(..)                          ,
+    newZeroPluginDesc                       ,
+    noPluginDesc                            ,
+
+
+ -- * Properties
+-- ** Description
+    pluginDescReadDescription               ,
+
+
+-- ** License
+    pluginDescReadLicense                   ,
+
+
+-- ** MajorVersion
+    pluginDescReadMajorVersion              ,
+
+
+-- ** MinorVersion
+    pluginDescReadMinorVersion              ,
+
+
+-- ** Name
+    pluginDescReadName                      ,
+
+
+-- ** Origin
+    pluginDescReadOrigin                    ,
+
+
+-- ** Package
+    pluginDescReadPackage                   ,
+
+
+-- ** ReleaseDatetime
+    pluginDescReadReleaseDatetime           ,
+
+
+-- ** Source
+    pluginDescReadSource                    ,
+
+
+-- ** Version
+    pluginDescReadVersion                   ,
+
+
+
+
+    ) where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+import GI.Gst.Callbacks
+
+newtype PluginDesc = PluginDesc (ForeignPtr PluginDesc)
+-- | Construct a `PluginDesc` struct initialized to zero.
+newZeroPluginDesc :: MonadIO m => m PluginDesc
+newZeroPluginDesc = liftIO $ callocBytes 112 >>= wrapPtr PluginDesc
+
+noPluginDesc :: Maybe PluginDesc
+noPluginDesc = Nothing
+
+pluginDescReadMajorVersion :: PluginDesc -> IO Int32
+pluginDescReadMajorVersion s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 0) :: IO Int32
+    return val
+
+pluginDescReadMinorVersion :: PluginDesc -> IO Int32
+pluginDescReadMinorVersion s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 4) :: IO Int32
+    return val
+
+pluginDescReadName :: PluginDesc -> IO T.Text
+pluginDescReadName s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 8) :: IO CString
+    val' <- cstringToText val
+    return val'
+
+pluginDescReadDescription :: PluginDesc -> IO T.Text
+pluginDescReadDescription s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 16) :: IO CString
+    val' <- cstringToText val
+    return val'
+
+-- XXX Skipped getter for "PluginDesc:plugin_init" :: Not implemented: "Wrapping foreign callbacks is not supported yet"
+
+pluginDescReadVersion :: PluginDesc -> IO T.Text
+pluginDescReadVersion s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 32) :: IO CString
+    val' <- cstringToText val
+    return val'
+
+pluginDescReadLicense :: PluginDesc -> IO T.Text
+pluginDescReadLicense s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 40) :: IO CString
+    val' <- cstringToText val
+    return val'
+
+pluginDescReadSource :: PluginDesc -> IO T.Text
+pluginDescReadSource s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 48) :: IO CString
+    val' <- cstringToText val
+    return val'
+
+pluginDescReadPackage :: PluginDesc -> IO T.Text
+pluginDescReadPackage s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 56) :: IO CString
+    val' <- cstringToText val
+    return val'
+
+pluginDescReadOrigin :: PluginDesc -> IO T.Text
+pluginDescReadOrigin s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 64) :: IO CString
+    val' <- cstringToText val
+    return val'
+
+pluginDescReadReleaseDatetime :: PluginDesc -> IO T.Text
+pluginDescReadReleaseDatetime s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 72) :: IO CString
+    val' <- cstringToText val
+    return val'
+
+type family ResolvePluginDescMethod (t :: Symbol) (o :: *) :: * where
+    ResolvePluginDescMethod l o = MethodResolutionFailed l o
+
+instance (info ~ ResolvePluginDescMethod t PluginDesc, MethodInfo info PluginDesc p) => IsLabelProxy t (PluginDesc -> p) where
+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)
+
+#if MIN_VERSION_base(4,9,0)
+instance (info ~ ResolvePluginDescMethod t PluginDesc, MethodInfo info PluginDesc p) => IsLabel t (PluginDesc -> p) where
+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)
+#endif
+
+
diff --git a/GI/Gst/Structs/PluginDesc.hs-boot b/GI/Gst/Structs/PluginDesc.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/PluginDesc.hs-boot
@@ -0,0 +1,10 @@
+module GI.Gst.Structs.PluginDesc where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+newtype PluginDesc = PluginDesc (ForeignPtr PluginDesc)
diff --git a/GI/Gst/Structs/Poll.hs b/GI/Gst/Structs/Poll.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/Poll.hs
@@ -0,0 +1,698 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+
+A #GstPoll keeps track of file descriptors much like fd_set (used with
+select()) or a struct pollfd array (used with poll()). Once created with
+gst_poll_new(), the set can be used to wait for file descriptors to be
+readable and/or writable. It is possible to make this wait be controlled
+by specifying %TRUE for the @controllable flag when creating the set (or
+later calling gst_poll_set_controllable()).
+
+New file descriptors are added to the set using gst_poll_add_fd(), and
+removed using gst_poll_remove_fd(). Controlling which file descriptors
+should be waited for to become readable and/or writable are done using
+gst_poll_fd_ctl_read() and gst_poll_fd_ctl_write().
+
+Use gst_poll_wait() to wait for the file descriptors to actually become
+readable and/or writable, or to timeout if no file descriptor is available
+in time. The wait can be controlled by calling gst_poll_restart() and
+gst_poll_set_flushing().
+
+Once the file descriptor set has been waited for, one can use
+gst_poll_fd_has_closed() to see if the file descriptor has been closed,
+gst_poll_fd_has_error() to see if it has generated an error,
+gst_poll_fd_can_read() to see if it is possible to read from the file
+descriptor, and gst_poll_fd_can_write() to see if it is possible to
+write to it.
+-}
+
+module GI.Gst.Structs.Poll
+    ( 
+
+-- * Exported types
+    Poll(..)                                ,
+    noPoll                                  ,
+
+
+ -- * Methods
+-- ** pollAddFd
+    PollAddFdMethodInfo                     ,
+    pollAddFd                               ,
+
+
+-- ** pollFdCanRead
+    PollFdCanReadMethodInfo                 ,
+    pollFdCanRead                           ,
+
+
+-- ** pollFdCanWrite
+    PollFdCanWriteMethodInfo                ,
+    pollFdCanWrite                          ,
+
+
+-- ** pollFdCtlRead
+    PollFdCtlReadMethodInfo                 ,
+    pollFdCtlRead                           ,
+
+
+-- ** pollFdCtlWrite
+    PollFdCtlWriteMethodInfo                ,
+    pollFdCtlWrite                          ,
+
+
+-- ** pollFdHasClosed
+    PollFdHasClosedMethodInfo               ,
+    pollFdHasClosed                         ,
+
+
+-- ** pollFdHasError
+    PollFdHasErrorMethodInfo                ,
+    pollFdHasError                          ,
+
+
+-- ** pollFdIgnored
+    PollFdIgnoredMethodInfo                 ,
+    pollFdIgnored                           ,
+
+
+-- ** pollFree
+    PollFreeMethodInfo                      ,
+    pollFree                                ,
+
+
+-- ** pollGetReadGpollfd
+    PollGetReadGpollfdMethodInfo            ,
+    pollGetReadGpollfd                      ,
+
+
+-- ** pollReadControl
+    PollReadControlMethodInfo               ,
+    pollReadControl                         ,
+
+
+-- ** pollRemoveFd
+    PollRemoveFdMethodInfo                  ,
+    pollRemoveFd                            ,
+
+
+-- ** pollRestart
+    PollRestartMethodInfo                   ,
+    pollRestart                             ,
+
+
+-- ** pollSetControllable
+    PollSetControllableMethodInfo           ,
+    pollSetControllable                     ,
+
+
+-- ** pollSetFlushing
+    PollSetFlushingMethodInfo               ,
+    pollSetFlushing                         ,
+
+
+-- ** pollWait
+    PollWaitMethodInfo                      ,
+    pollWait                                ,
+
+
+-- ** pollWriteControl
+    PollWriteControlMethodInfo              ,
+    pollWriteControl                        ,
+
+
+
+
+    ) where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+import GI.Gst.Callbacks
+import qualified GI.GLib as GLib
+
+newtype Poll = Poll (ForeignPtr Poll)
+noPoll :: Maybe Poll
+noPoll = Nothing
+
+-- method Poll::add_fd
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Poll", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fd", argType = TInterface "Gst" "PollFD", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_poll_add_fd" gst_poll_add_fd :: 
+    Ptr Poll ->                             -- _obj : TInterface "Gst" "Poll"
+    Ptr PollFD ->                           -- fd : TInterface "Gst" "PollFD"
+    IO CInt
+
+
+pollAddFd ::
+    (MonadIO m) =>
+    Poll                                    -- _obj
+    -> PollFD                               -- fd
+    -> m Bool                               -- result
+pollAddFd _obj fd = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let fd' = unsafeManagedPtrGetPtr fd
+    result <- gst_poll_add_fd _obj' fd'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    touchManagedPtr fd
+    return result'
+
+data PollAddFdMethodInfo
+instance (signature ~ (PollFD -> m Bool), MonadIO m) => MethodInfo PollAddFdMethodInfo Poll signature where
+    overloadedMethod _ = pollAddFd
+
+-- method Poll::fd_can_read
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Poll", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fd", argType = TInterface "Gst" "PollFD", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_poll_fd_can_read" gst_poll_fd_can_read :: 
+    Ptr Poll ->                             -- _obj : TInterface "Gst" "Poll"
+    Ptr PollFD ->                           -- fd : TInterface "Gst" "PollFD"
+    IO CInt
+
+
+pollFdCanRead ::
+    (MonadIO m) =>
+    Poll                                    -- _obj
+    -> PollFD                               -- fd
+    -> m Bool                               -- result
+pollFdCanRead _obj fd = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let fd' = unsafeManagedPtrGetPtr fd
+    result <- gst_poll_fd_can_read _obj' fd'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    touchManagedPtr fd
+    return result'
+
+data PollFdCanReadMethodInfo
+instance (signature ~ (PollFD -> m Bool), MonadIO m) => MethodInfo PollFdCanReadMethodInfo Poll signature where
+    overloadedMethod _ = pollFdCanRead
+
+-- method Poll::fd_can_write
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Poll", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fd", argType = TInterface "Gst" "PollFD", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_poll_fd_can_write" gst_poll_fd_can_write :: 
+    Ptr Poll ->                             -- _obj : TInterface "Gst" "Poll"
+    Ptr PollFD ->                           -- fd : TInterface "Gst" "PollFD"
+    IO CInt
+
+
+pollFdCanWrite ::
+    (MonadIO m) =>
+    Poll                                    -- _obj
+    -> PollFD                               -- fd
+    -> m Bool                               -- result
+pollFdCanWrite _obj fd = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let fd' = unsafeManagedPtrGetPtr fd
+    result <- gst_poll_fd_can_write _obj' fd'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    touchManagedPtr fd
+    return result'
+
+data PollFdCanWriteMethodInfo
+instance (signature ~ (PollFD -> m Bool), MonadIO m) => MethodInfo PollFdCanWriteMethodInfo Poll signature where
+    overloadedMethod _ = pollFdCanWrite
+
+-- method Poll::fd_ctl_read
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Poll", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fd", argType = TInterface "Gst" "PollFD", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "active", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_poll_fd_ctl_read" gst_poll_fd_ctl_read :: 
+    Ptr Poll ->                             -- _obj : TInterface "Gst" "Poll"
+    Ptr PollFD ->                           -- fd : TInterface "Gst" "PollFD"
+    CInt ->                                 -- active : TBasicType TBoolean
+    IO CInt
+
+
+pollFdCtlRead ::
+    (MonadIO m) =>
+    Poll                                    -- _obj
+    -> PollFD                               -- fd
+    -> Bool                                 -- active
+    -> m Bool                               -- result
+pollFdCtlRead _obj fd active = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let fd' = unsafeManagedPtrGetPtr fd
+    let active' = (fromIntegral . fromEnum) active
+    result <- gst_poll_fd_ctl_read _obj' fd' active'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    touchManagedPtr fd
+    return result'
+
+data PollFdCtlReadMethodInfo
+instance (signature ~ (PollFD -> Bool -> m Bool), MonadIO m) => MethodInfo PollFdCtlReadMethodInfo Poll signature where
+    overloadedMethod _ = pollFdCtlRead
+
+-- method Poll::fd_ctl_write
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Poll", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fd", argType = TInterface "Gst" "PollFD", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "active", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_poll_fd_ctl_write" gst_poll_fd_ctl_write :: 
+    Ptr Poll ->                             -- _obj : TInterface "Gst" "Poll"
+    Ptr PollFD ->                           -- fd : TInterface "Gst" "PollFD"
+    CInt ->                                 -- active : TBasicType TBoolean
+    IO CInt
+
+
+pollFdCtlWrite ::
+    (MonadIO m) =>
+    Poll                                    -- _obj
+    -> PollFD                               -- fd
+    -> Bool                                 -- active
+    -> m Bool                               -- result
+pollFdCtlWrite _obj fd active = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let fd' = unsafeManagedPtrGetPtr fd
+    let active' = (fromIntegral . fromEnum) active
+    result <- gst_poll_fd_ctl_write _obj' fd' active'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    touchManagedPtr fd
+    return result'
+
+data PollFdCtlWriteMethodInfo
+instance (signature ~ (PollFD -> Bool -> m Bool), MonadIO m) => MethodInfo PollFdCtlWriteMethodInfo Poll signature where
+    overloadedMethod _ = pollFdCtlWrite
+
+-- method Poll::fd_has_closed
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Poll", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fd", argType = TInterface "Gst" "PollFD", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_poll_fd_has_closed" gst_poll_fd_has_closed :: 
+    Ptr Poll ->                             -- _obj : TInterface "Gst" "Poll"
+    Ptr PollFD ->                           -- fd : TInterface "Gst" "PollFD"
+    IO CInt
+
+
+pollFdHasClosed ::
+    (MonadIO m) =>
+    Poll                                    -- _obj
+    -> PollFD                               -- fd
+    -> m Bool                               -- result
+pollFdHasClosed _obj fd = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let fd' = unsafeManagedPtrGetPtr fd
+    result <- gst_poll_fd_has_closed _obj' fd'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    touchManagedPtr fd
+    return result'
+
+data PollFdHasClosedMethodInfo
+instance (signature ~ (PollFD -> m Bool), MonadIO m) => MethodInfo PollFdHasClosedMethodInfo Poll signature where
+    overloadedMethod _ = pollFdHasClosed
+
+-- method Poll::fd_has_error
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Poll", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fd", argType = TInterface "Gst" "PollFD", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_poll_fd_has_error" gst_poll_fd_has_error :: 
+    Ptr Poll ->                             -- _obj : TInterface "Gst" "Poll"
+    Ptr PollFD ->                           -- fd : TInterface "Gst" "PollFD"
+    IO CInt
+
+
+pollFdHasError ::
+    (MonadIO m) =>
+    Poll                                    -- _obj
+    -> PollFD                               -- fd
+    -> m Bool                               -- result
+pollFdHasError _obj fd = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let fd' = unsafeManagedPtrGetPtr fd
+    result <- gst_poll_fd_has_error _obj' fd'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    touchManagedPtr fd
+    return result'
+
+data PollFdHasErrorMethodInfo
+instance (signature ~ (PollFD -> m Bool), MonadIO m) => MethodInfo PollFdHasErrorMethodInfo Poll signature where
+    overloadedMethod _ = pollFdHasError
+
+-- method Poll::fd_ignored
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Poll", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fd", argType = TInterface "Gst" "PollFD", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_poll_fd_ignored" gst_poll_fd_ignored :: 
+    Ptr Poll ->                             -- _obj : TInterface "Gst" "Poll"
+    Ptr PollFD ->                           -- fd : TInterface "Gst" "PollFD"
+    IO ()
+
+
+pollFdIgnored ::
+    (MonadIO m) =>
+    Poll                                    -- _obj
+    -> PollFD                               -- fd
+    -> m ()                                 -- result
+pollFdIgnored _obj fd = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let fd' = unsafeManagedPtrGetPtr fd
+    gst_poll_fd_ignored _obj' fd'
+    touchManagedPtr _obj
+    touchManagedPtr fd
+    return ()
+
+data PollFdIgnoredMethodInfo
+instance (signature ~ (PollFD -> m ()), MonadIO m) => MethodInfo PollFdIgnoredMethodInfo Poll signature where
+    overloadedMethod _ = pollFdIgnored
+
+-- method Poll::free
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Poll", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_poll_free" gst_poll_free :: 
+    Ptr Poll ->                             -- _obj : TInterface "Gst" "Poll"
+    IO ()
+
+
+pollFree ::
+    (MonadIO m) =>
+    Poll                                    -- _obj
+    -> m ()                                 -- result
+pollFree _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    gst_poll_free _obj'
+    touchManagedPtr _obj
+    return ()
+
+data PollFreeMethodInfo
+instance (signature ~ (m ()), MonadIO m) => MethodInfo PollFreeMethodInfo Poll signature where
+    overloadedMethod _ = pollFree
+
+-- method Poll::get_read_gpollfd
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Poll", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fd", argType = TInterface "GLib" "PollFD", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_poll_get_read_gpollfd" gst_poll_get_read_gpollfd :: 
+    Ptr Poll ->                             -- _obj : TInterface "Gst" "Poll"
+    Ptr GLib.PollFD ->                      -- fd : TInterface "GLib" "PollFD"
+    IO ()
+
+
+pollGetReadGpollfd ::
+    (MonadIO m) =>
+    Poll                                    -- _obj
+    -> GLib.PollFD                          -- fd
+    -> m ()                                 -- result
+pollGetReadGpollfd _obj fd = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let fd' = unsafeManagedPtrGetPtr fd
+    gst_poll_get_read_gpollfd _obj' fd'
+    touchManagedPtr _obj
+    touchManagedPtr fd
+    return ()
+
+data PollGetReadGpollfdMethodInfo
+instance (signature ~ (GLib.PollFD -> m ()), MonadIO m) => MethodInfo PollGetReadGpollfdMethodInfo Poll signature where
+    overloadedMethod _ = pollGetReadGpollfd
+
+-- method Poll::read_control
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Poll", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_poll_read_control" gst_poll_read_control :: 
+    Ptr Poll ->                             -- _obj : TInterface "Gst" "Poll"
+    IO CInt
+
+
+pollReadControl ::
+    (MonadIO m) =>
+    Poll                                    -- _obj
+    -> m Bool                               -- result
+pollReadControl _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_poll_read_control _obj'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data PollReadControlMethodInfo
+instance (signature ~ (m Bool), MonadIO m) => MethodInfo PollReadControlMethodInfo Poll signature where
+    overloadedMethod _ = pollReadControl
+
+-- method Poll::remove_fd
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Poll", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fd", argType = TInterface "Gst" "PollFD", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_poll_remove_fd" gst_poll_remove_fd :: 
+    Ptr Poll ->                             -- _obj : TInterface "Gst" "Poll"
+    Ptr PollFD ->                           -- fd : TInterface "Gst" "PollFD"
+    IO CInt
+
+
+pollRemoveFd ::
+    (MonadIO m) =>
+    Poll                                    -- _obj
+    -> PollFD                               -- fd
+    -> m Bool                               -- result
+pollRemoveFd _obj fd = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let fd' = unsafeManagedPtrGetPtr fd
+    result <- gst_poll_remove_fd _obj' fd'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    touchManagedPtr fd
+    return result'
+
+data PollRemoveFdMethodInfo
+instance (signature ~ (PollFD -> m Bool), MonadIO m) => MethodInfo PollRemoveFdMethodInfo Poll signature where
+    overloadedMethod _ = pollRemoveFd
+
+-- method Poll::restart
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Poll", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_poll_restart" gst_poll_restart :: 
+    Ptr Poll ->                             -- _obj : TInterface "Gst" "Poll"
+    IO ()
+
+
+pollRestart ::
+    (MonadIO m) =>
+    Poll                                    -- _obj
+    -> m ()                                 -- result
+pollRestart _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    gst_poll_restart _obj'
+    touchManagedPtr _obj
+    return ()
+
+data PollRestartMethodInfo
+instance (signature ~ (m ()), MonadIO m) => MethodInfo PollRestartMethodInfo Poll signature where
+    overloadedMethod _ = pollRestart
+
+-- method Poll::set_controllable
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Poll", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "controllable", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_poll_set_controllable" gst_poll_set_controllable :: 
+    Ptr Poll ->                             -- _obj : TInterface "Gst" "Poll"
+    CInt ->                                 -- controllable : TBasicType TBoolean
+    IO CInt
+
+
+pollSetControllable ::
+    (MonadIO m) =>
+    Poll                                    -- _obj
+    -> Bool                                 -- controllable
+    -> m Bool                               -- result
+pollSetControllable _obj controllable = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let controllable' = (fromIntegral . fromEnum) controllable
+    result <- gst_poll_set_controllable _obj' controllable'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data PollSetControllableMethodInfo
+instance (signature ~ (Bool -> m Bool), MonadIO m) => MethodInfo PollSetControllableMethodInfo Poll signature where
+    overloadedMethod _ = pollSetControllable
+
+-- method Poll::set_flushing
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Poll", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flushing", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_poll_set_flushing" gst_poll_set_flushing :: 
+    Ptr Poll ->                             -- _obj : TInterface "Gst" "Poll"
+    CInt ->                                 -- flushing : TBasicType TBoolean
+    IO ()
+
+
+pollSetFlushing ::
+    (MonadIO m) =>
+    Poll                                    -- _obj
+    -> Bool                                 -- flushing
+    -> m ()                                 -- result
+pollSetFlushing _obj flushing = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let flushing' = (fromIntegral . fromEnum) flushing
+    gst_poll_set_flushing _obj' flushing'
+    touchManagedPtr _obj
+    return ()
+
+data PollSetFlushingMethodInfo
+instance (signature ~ (Bool -> m ()), MonadIO m) => MethodInfo PollSetFlushingMethodInfo Poll signature where
+    overloadedMethod _ = pollSetFlushing
+
+-- method Poll::wait
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Poll", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "timeout", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TInt32
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_poll_wait" gst_poll_wait :: 
+    Ptr Poll ->                             -- _obj : TInterface "Gst" "Poll"
+    Word64 ->                               -- timeout : TBasicType TUInt64
+    IO Int32
+
+
+pollWait ::
+    (MonadIO m) =>
+    Poll                                    -- _obj
+    -> Word64                               -- timeout
+    -> m Int32                              -- result
+pollWait _obj timeout = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_poll_wait _obj' timeout
+    touchManagedPtr _obj
+    return result
+
+data PollWaitMethodInfo
+instance (signature ~ (Word64 -> m Int32), MonadIO m) => MethodInfo PollWaitMethodInfo Poll signature where
+    overloadedMethod _ = pollWait
+
+-- method Poll::write_control
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Poll", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_poll_write_control" gst_poll_write_control :: 
+    Ptr Poll ->                             -- _obj : TInterface "Gst" "Poll"
+    IO CInt
+
+
+pollWriteControl ::
+    (MonadIO m) =>
+    Poll                                    -- _obj
+    -> m Bool                               -- result
+pollWriteControl _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_poll_write_control _obj'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data PollWriteControlMethodInfo
+instance (signature ~ (m Bool), MonadIO m) => MethodInfo PollWriteControlMethodInfo Poll signature where
+    overloadedMethod _ = pollWriteControl
+
+type family ResolvePollMethod (t :: Symbol) (o :: *) :: * where
+    ResolvePollMethod "addFd" o = PollAddFdMethodInfo
+    ResolvePollMethod "fdCanRead" o = PollFdCanReadMethodInfo
+    ResolvePollMethod "fdCanWrite" o = PollFdCanWriteMethodInfo
+    ResolvePollMethod "fdCtlRead" o = PollFdCtlReadMethodInfo
+    ResolvePollMethod "fdCtlWrite" o = PollFdCtlWriteMethodInfo
+    ResolvePollMethod "fdHasClosed" o = PollFdHasClosedMethodInfo
+    ResolvePollMethod "fdHasError" o = PollFdHasErrorMethodInfo
+    ResolvePollMethod "fdIgnored" o = PollFdIgnoredMethodInfo
+    ResolvePollMethod "free" o = PollFreeMethodInfo
+    ResolvePollMethod "readControl" o = PollReadControlMethodInfo
+    ResolvePollMethod "removeFd" o = PollRemoveFdMethodInfo
+    ResolvePollMethod "restart" o = PollRestartMethodInfo
+    ResolvePollMethod "wait" o = PollWaitMethodInfo
+    ResolvePollMethod "writeControl" o = PollWriteControlMethodInfo
+    ResolvePollMethod "getReadGpollfd" o = PollGetReadGpollfdMethodInfo
+    ResolvePollMethod "setControllable" o = PollSetControllableMethodInfo
+    ResolvePollMethod "setFlushing" o = PollSetFlushingMethodInfo
+    ResolvePollMethod l o = MethodResolutionFailed l o
+
+instance (info ~ ResolvePollMethod t Poll, MethodInfo info Poll p) => IsLabelProxy t (Poll -> p) where
+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)
+
+#if MIN_VERSION_base(4,9,0)
+instance (info ~ ResolvePollMethod t Poll, MethodInfo info Poll p) => IsLabel t (Poll -> p) where
+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)
+#endif
+
+
diff --git a/GI/Gst/Structs/Poll.hs-boot b/GI/Gst/Structs/Poll.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/Poll.hs-boot
@@ -0,0 +1,27 @@
+module GI.Gst.Structs.Poll where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+newtype Poll = Poll (ForeignPtr Poll)
+data PollAddFdMethodInfo
+data PollFdCanReadMethodInfo
+data PollFdCanWriteMethodInfo
+data PollFdCtlReadMethodInfo
+data PollFdCtlWriteMethodInfo
+data PollFdHasClosedMethodInfo
+data PollFdHasErrorMethodInfo
+data PollFdIgnoredMethodInfo
+data PollFreeMethodInfo
+data PollGetReadGpollfdMethodInfo
+data PollReadControlMethodInfo
+data PollRemoveFdMethodInfo
+data PollRestartMethodInfo
+data PollSetControllableMethodInfo
+data PollSetFlushingMethodInfo
+data PollWaitMethodInfo
+data PollWriteControlMethodInfo
diff --git a/GI/Gst/Structs/PollFD.hs b/GI/Gst/Structs/PollFD.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/PollFD.hs
@@ -0,0 +1,99 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+
+A file descriptor object.
+-}
+
+module GI.Gst.Structs.PollFD
+    ( 
+
+-- * Exported types
+    PollFD(..)                              ,
+    newZeroPollFD                           ,
+    noPollFD                                ,
+
+
+ -- * Methods
+-- ** pollFDInit
+    PollFDInitMethodInfo                    ,
+    pollFDInit                              ,
+
+
+
+
+ -- * Properties
+-- ** Fd
+    pollFDReadFd                            ,
+
+
+
+
+    ) where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+import GI.Gst.Callbacks
+
+newtype PollFD = PollFD (ForeignPtr PollFD)
+-- | Construct a `PollFD` struct initialized to zero.
+newZeroPollFD :: MonadIO m => m PollFD
+newZeroPollFD = liftIO $ callocBytes 8 >>= wrapPtr PollFD
+
+noPollFD :: Maybe PollFD
+noPollFD = Nothing
+
+pollFDReadFd :: PollFD -> IO Int32
+pollFDReadFd s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 0) :: IO Int32
+    return val
+
+-- method PollFD::init
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "PollFD", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_poll_fd_init" gst_poll_fd_init :: 
+    Ptr PollFD ->                           -- _obj : TInterface "Gst" "PollFD"
+    IO ()
+
+
+pollFDInit ::
+    (MonadIO m) =>
+    PollFD                                  -- _obj
+    -> m ()                                 -- result
+pollFDInit _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    gst_poll_fd_init _obj'
+    touchManagedPtr _obj
+    return ()
+
+data PollFDInitMethodInfo
+instance (signature ~ (m ()), MonadIO m) => MethodInfo PollFDInitMethodInfo PollFD signature where
+    overloadedMethod _ = pollFDInit
+
+type family ResolvePollFDMethod (t :: Symbol) (o :: *) :: * where
+    ResolvePollFDMethod "init" o = PollFDInitMethodInfo
+    ResolvePollFDMethod l o = MethodResolutionFailed l o
+
+instance (info ~ ResolvePollFDMethod t PollFD, MethodInfo info PollFD p) => IsLabelProxy t (PollFD -> p) where
+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)
+
+#if MIN_VERSION_base(4,9,0)
+instance (info ~ ResolvePollFDMethod t PollFD, MethodInfo info PollFD p) => IsLabel t (PollFD -> p) where
+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)
+#endif
+
+
diff --git a/GI/Gst/Structs/PollFD.hs-boot b/GI/Gst/Structs/PollFD.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/PollFD.hs-boot
@@ -0,0 +1,11 @@
+module GI.Gst.Structs.PollFD where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+newtype PollFD = PollFD (ForeignPtr PollFD)
+data PollFDInitMethodInfo
diff --git a/GI/Gst/Structs/ProtectionMeta.hs b/GI/Gst/Structs/ProtectionMeta.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/ProtectionMeta.hs
@@ -0,0 +1,103 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+
+Metadata type that holds information about a sample from a protection-protected
+track, including the information needed to decrypt it (if it is encrypted).
+-}
+
+module GI.Gst.Structs.ProtectionMeta
+    ( 
+
+-- * Exported types
+    ProtectionMeta(..)                      ,
+    newZeroProtectionMeta                   ,
+    noProtectionMeta                        ,
+
+
+ -- * Methods
+-- ** protectionMetaGetInfo
+    protectionMetaGetInfo                   ,
+
+
+
+
+ -- * Properties
+-- ** Info
+    protectionMetaReadInfo                  ,
+
+
+-- ** Meta
+    protectionMetaReadMeta                  ,
+
+
+
+
+    ) where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+import GI.Gst.Callbacks
+
+newtype ProtectionMeta = ProtectionMeta (ForeignPtr ProtectionMeta)
+-- | Construct a `ProtectionMeta` struct initialized to zero.
+newZeroProtectionMeta :: MonadIO m => m ProtectionMeta
+newZeroProtectionMeta = liftIO $ callocBytes 24 >>= wrapPtr ProtectionMeta
+
+noProtectionMeta :: Maybe ProtectionMeta
+noProtectionMeta = Nothing
+
+protectionMetaReadMeta :: ProtectionMeta -> IO Meta
+protectionMetaReadMeta s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 0) :: IO (Ptr Meta)
+    val' <- (newPtr 16 Meta) val
+    return val'
+
+protectionMetaReadInfo :: ProtectionMeta -> IO Structure
+protectionMetaReadInfo s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 16) :: IO (Ptr Structure)
+    val' <- (newBoxed Structure) val
+    return val'
+
+-- method ProtectionMeta::get_info
+-- method type : MemberFunction
+-- Args : []
+-- Lengths : []
+-- returnType : TInterface "Gst" "MetaInfo"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_protection_meta_get_info" gst_protection_meta_get_info :: 
+    IO (Ptr MetaInfo)
+
+
+protectionMetaGetInfo ::
+    (MonadIO m) =>
+    m MetaInfo                              -- result
+protectionMetaGetInfo  = liftIO $ do
+    result <- gst_protection_meta_get_info
+    checkUnexpectedReturnNULL "gst_protection_meta_get_info" result
+    result' <- (newPtr 80 MetaInfo) result
+    return result'
+
+type family ResolveProtectionMetaMethod (t :: Symbol) (o :: *) :: * where
+    ResolveProtectionMetaMethod l o = MethodResolutionFailed l o
+
+instance (info ~ ResolveProtectionMetaMethod t ProtectionMeta, MethodInfo info ProtectionMeta p) => IsLabelProxy t (ProtectionMeta -> p) where
+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)
+
+#if MIN_VERSION_base(4,9,0)
+instance (info ~ ResolveProtectionMetaMethod t ProtectionMeta, MethodInfo info ProtectionMeta p) => IsLabel t (ProtectionMeta -> p) where
+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)
+#endif
+
+
diff --git a/GI/Gst/Structs/ProtectionMeta.hs-boot b/GI/Gst/Structs/ProtectionMeta.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/ProtectionMeta.hs-boot
@@ -0,0 +1,10 @@
+module GI.Gst.Structs.ProtectionMeta where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+newtype ProtectionMeta = ProtectionMeta (ForeignPtr ProtectionMeta)
diff --git a/GI/Gst/Structs/Query.hs b/GI/Gst/Structs/Query.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/Query.hs
@@ -0,0 +1,3145 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+
+Queries can be performed on pads (gst_pad_query()) and elements
+(gst_element_query()). Please note that some queries might need a running
+pipeline to work.
+
+Queries can be created using the gst_query_new_*() functions.
+Query values can be set using gst_query_set_*(), and parsed using
+gst_query_parse_*() helpers.
+
+The following example shows how to query the duration of a pipeline:
+|[
+  GstQuery *query;
+  gboolean res;
+  query = gst_query_new_duration (GST_FORMAT_TIME);
+  res = gst_element_query (pipeline, query);
+  if (res) {
+    gint64 duration;
+    gst_query_parse_duration (query, NULL, &amp;duration);
+    g_print ("duration = %"GST_TIME_FORMAT, GST_TIME_ARGS (duration));
+  } else {
+    g_print ("duration query failed...");
+  }
+  gst_query_unref (query);
+]|
+-}
+
+module GI.Gst.Structs.Query
+    ( 
+
+-- * Exported types
+    Query(..)                               ,
+    newZeroQuery                            ,
+    noQuery                                 ,
+
+
+ -- * Methods
+-- ** queryAddAllocationMeta
+    QueryAddAllocationMetaMethodInfo        ,
+    queryAddAllocationMeta                  ,
+
+
+-- ** queryAddAllocationParam
+    QueryAddAllocationParamMethodInfo       ,
+    queryAddAllocationParam                 ,
+
+
+-- ** queryAddAllocationPool
+    QueryAddAllocationPoolMethodInfo        ,
+    queryAddAllocationPool                  ,
+
+
+-- ** queryAddBufferingRange
+    QueryAddBufferingRangeMethodInfo        ,
+    queryAddBufferingRange                  ,
+
+
+-- ** queryAddSchedulingMode
+    QueryAddSchedulingModeMethodInfo        ,
+    queryAddSchedulingMode                  ,
+
+
+-- ** queryFindAllocationMeta
+    QueryFindAllocationMetaMethodInfo       ,
+    queryFindAllocationMeta                 ,
+
+
+-- ** queryGetNAllocationMetas
+    QueryGetNAllocationMetasMethodInfo      ,
+    queryGetNAllocationMetas                ,
+
+
+-- ** queryGetNAllocationParams
+    QueryGetNAllocationParamsMethodInfo     ,
+    queryGetNAllocationParams               ,
+
+
+-- ** queryGetNAllocationPools
+    QueryGetNAllocationPoolsMethodInfo      ,
+    queryGetNAllocationPools                ,
+
+
+-- ** queryGetNBufferingRanges
+    QueryGetNBufferingRangesMethodInfo      ,
+    queryGetNBufferingRanges                ,
+
+
+-- ** queryGetNSchedulingModes
+    QueryGetNSchedulingModesMethodInfo      ,
+    queryGetNSchedulingModes                ,
+
+
+-- ** queryGetStructure
+    QueryGetStructureMethodInfo             ,
+    queryGetStructure                       ,
+
+
+-- ** queryHasSchedulingMode
+    QueryHasSchedulingModeMethodInfo        ,
+    queryHasSchedulingMode                  ,
+
+
+-- ** queryHasSchedulingModeWithFlags
+    QueryHasSchedulingModeWithFlagsMethodInfo,
+    queryHasSchedulingModeWithFlags         ,
+
+
+-- ** queryNewAcceptCaps
+    queryNewAcceptCaps                      ,
+
+
+-- ** queryNewAllocation
+    queryNewAllocation                      ,
+
+
+-- ** queryNewBuffering
+    queryNewBuffering                       ,
+
+
+-- ** queryNewCaps
+    queryNewCaps                            ,
+
+
+-- ** queryNewContext
+    queryNewContext                         ,
+
+
+-- ** queryNewConvert
+    queryNewConvert                         ,
+
+
+-- ** queryNewCustom
+    queryNewCustom                          ,
+
+
+-- ** queryNewDrain
+    queryNewDrain                           ,
+
+
+-- ** queryNewDuration
+    queryNewDuration                        ,
+
+
+-- ** queryNewFormats
+    queryNewFormats                         ,
+
+
+-- ** queryNewLatency
+    queryNewLatency                         ,
+
+
+-- ** queryNewPosition
+    queryNewPosition                        ,
+
+
+-- ** queryNewScheduling
+    queryNewScheduling                      ,
+
+
+-- ** queryNewSeeking
+    queryNewSeeking                         ,
+
+
+-- ** queryNewSegment
+    queryNewSegment                         ,
+
+
+-- ** queryNewUri
+    queryNewUri                             ,
+
+
+-- ** queryParseAcceptCaps
+    QueryParseAcceptCapsMethodInfo          ,
+    queryParseAcceptCaps                    ,
+
+
+-- ** queryParseAcceptCapsResult
+    QueryParseAcceptCapsResultMethodInfo    ,
+    queryParseAcceptCapsResult              ,
+
+
+-- ** queryParseAllocation
+    QueryParseAllocationMethodInfo          ,
+    queryParseAllocation                    ,
+
+
+-- ** queryParseBufferingPercent
+    QueryParseBufferingPercentMethodInfo    ,
+    queryParseBufferingPercent              ,
+
+
+-- ** queryParseBufferingRange
+    QueryParseBufferingRangeMethodInfo      ,
+    queryParseBufferingRange                ,
+
+
+-- ** queryParseBufferingStats
+    QueryParseBufferingStatsMethodInfo      ,
+    queryParseBufferingStats                ,
+
+
+-- ** queryParseCaps
+    QueryParseCapsMethodInfo                ,
+    queryParseCaps                          ,
+
+
+-- ** queryParseCapsResult
+    QueryParseCapsResultMethodInfo          ,
+    queryParseCapsResult                    ,
+
+
+-- ** queryParseContext
+    QueryParseContextMethodInfo             ,
+    queryParseContext                       ,
+
+
+-- ** queryParseContextType
+    QueryParseContextTypeMethodInfo         ,
+    queryParseContextType                   ,
+
+
+-- ** queryParseConvert
+    QueryParseConvertMethodInfo             ,
+    queryParseConvert                       ,
+
+
+-- ** queryParseDuration
+    QueryParseDurationMethodInfo            ,
+    queryParseDuration                      ,
+
+
+-- ** queryParseLatency
+    QueryParseLatencyMethodInfo             ,
+    queryParseLatency                       ,
+
+
+-- ** queryParseNFormats
+    QueryParseNFormatsMethodInfo            ,
+    queryParseNFormats                      ,
+
+
+-- ** queryParseNthAllocationMeta
+    QueryParseNthAllocationMetaMethodInfo   ,
+    queryParseNthAllocationMeta             ,
+
+
+-- ** queryParseNthAllocationParam
+    QueryParseNthAllocationParamMethodInfo  ,
+    queryParseNthAllocationParam            ,
+
+
+-- ** queryParseNthAllocationPool
+    QueryParseNthAllocationPoolMethodInfo   ,
+    queryParseNthAllocationPool             ,
+
+
+-- ** queryParseNthBufferingRange
+    QueryParseNthBufferingRangeMethodInfo   ,
+    queryParseNthBufferingRange             ,
+
+
+-- ** queryParseNthFormat
+    QueryParseNthFormatMethodInfo           ,
+    queryParseNthFormat                     ,
+
+
+-- ** queryParseNthSchedulingMode
+    QueryParseNthSchedulingModeMethodInfo   ,
+    queryParseNthSchedulingMode             ,
+
+
+-- ** queryParsePosition
+    QueryParsePositionMethodInfo            ,
+    queryParsePosition                      ,
+
+
+-- ** queryParseScheduling
+    QueryParseSchedulingMethodInfo          ,
+    queryParseScheduling                    ,
+
+
+-- ** queryParseSeeking
+    QueryParseSeekingMethodInfo             ,
+    queryParseSeeking                       ,
+
+
+-- ** queryParseSegment
+    QueryParseSegmentMethodInfo             ,
+    queryParseSegment                       ,
+
+
+-- ** queryParseUri
+    QueryParseUriMethodInfo                 ,
+    queryParseUri                           ,
+
+
+-- ** queryParseUriRedirection
+    QueryParseUriRedirectionMethodInfo      ,
+    queryParseUriRedirection                ,
+
+
+-- ** queryParseUriRedirectionPermanent
+    QueryParseUriRedirectionPermanentMethodInfo,
+    queryParseUriRedirectionPermanent       ,
+
+
+-- ** queryRemoveNthAllocationMeta
+    QueryRemoveNthAllocationMetaMethodInfo  ,
+    queryRemoveNthAllocationMeta            ,
+
+
+-- ** queryRemoveNthAllocationParam
+    QueryRemoveNthAllocationParamMethodInfo ,
+    queryRemoveNthAllocationParam           ,
+
+
+-- ** queryRemoveNthAllocationPool
+    QueryRemoveNthAllocationPoolMethodInfo  ,
+    queryRemoveNthAllocationPool            ,
+
+
+-- ** querySetAcceptCapsResult
+    QuerySetAcceptCapsResultMethodInfo      ,
+    querySetAcceptCapsResult                ,
+
+
+-- ** querySetBufferingPercent
+    QuerySetBufferingPercentMethodInfo      ,
+    querySetBufferingPercent                ,
+
+
+-- ** querySetBufferingRange
+    QuerySetBufferingRangeMethodInfo        ,
+    querySetBufferingRange                  ,
+
+
+-- ** querySetBufferingStats
+    QuerySetBufferingStatsMethodInfo        ,
+    querySetBufferingStats                  ,
+
+
+-- ** querySetCapsResult
+    QuerySetCapsResultMethodInfo            ,
+    querySetCapsResult                      ,
+
+
+-- ** querySetContext
+    QuerySetContextMethodInfo               ,
+    querySetContext                         ,
+
+
+-- ** querySetConvert
+    QuerySetConvertMethodInfo               ,
+    querySetConvert                         ,
+
+
+-- ** querySetDuration
+    QuerySetDurationMethodInfo              ,
+    querySetDuration                        ,
+
+
+-- ** querySetFormatsv
+    QuerySetFormatsvMethodInfo              ,
+    querySetFormatsv                        ,
+
+
+-- ** querySetLatency
+    QuerySetLatencyMethodInfo               ,
+    querySetLatency                         ,
+
+
+-- ** querySetNthAllocationParam
+    QuerySetNthAllocationParamMethodInfo    ,
+    querySetNthAllocationParam              ,
+
+
+-- ** querySetNthAllocationPool
+    QuerySetNthAllocationPoolMethodInfo     ,
+    querySetNthAllocationPool               ,
+
+
+-- ** querySetPosition
+    QuerySetPositionMethodInfo              ,
+    querySetPosition                        ,
+
+
+-- ** querySetScheduling
+    QuerySetSchedulingMethodInfo            ,
+    querySetScheduling                      ,
+
+
+-- ** querySetSeeking
+    QuerySetSeekingMethodInfo               ,
+    querySetSeeking                         ,
+
+
+-- ** querySetSegment
+    QuerySetSegmentMethodInfo               ,
+    querySetSegment                         ,
+
+
+-- ** querySetUri
+    QuerySetUriMethodInfo                   ,
+    querySetUri                             ,
+
+
+-- ** querySetUriRedirection
+    QuerySetUriRedirectionMethodInfo        ,
+    querySetUriRedirection                  ,
+
+
+-- ** querySetUriRedirectionPermanent
+    QuerySetUriRedirectionPermanentMethodInfo,
+    querySetUriRedirectionPermanent         ,
+
+
+-- ** queryWritableStructure
+    QueryWritableStructureMethodInfo        ,
+    queryWritableStructure                  ,
+
+
+
+
+ -- * Properties
+-- ** MiniObject
+    queryReadMiniObject                     ,
+
+
+-- ** Type
+    queryReadType                           ,
+
+
+
+
+    ) where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+import GI.Gst.Callbacks
+
+newtype Query = Query (ForeignPtr Query)
+foreign import ccall "gst_query_get_type" c_gst_query_get_type :: 
+    IO GType
+
+instance BoxedObject Query where
+    boxedType _ = c_gst_query_get_type
+
+-- | Construct a `Query` struct initialized to zero.
+newZeroQuery :: MonadIO m => m Query
+newZeroQuery = liftIO $ callocBoxedBytes 72 >>= wrapBoxed Query
+
+noQuery :: Maybe Query
+noQuery = Nothing
+
+queryReadMiniObject :: Query -> IO MiniObject
+queryReadMiniObject s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 0) :: IO (Ptr MiniObject)
+    val' <- (newPtr 64 MiniObject) val
+    return val'
+
+queryReadType :: Query -> IO QueryType
+queryReadType s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 64) :: IO CUInt
+    let val' = (toEnum . fromIntegral) val
+    return val'
+
+-- method Query::new_accept_caps
+-- method type : Constructor
+-- Args : [Arg {argCName = "caps", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Query"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_query_new_accept_caps" gst_query_new_accept_caps :: 
+    Ptr Caps ->                             -- caps : TInterface "Gst" "Caps"
+    IO (Ptr Query)
+
+
+queryNewAcceptCaps ::
+    (MonadIO m) =>
+    Caps                                    -- caps
+    -> m Query                              -- result
+queryNewAcceptCaps caps = liftIO $ do
+    let caps' = unsafeManagedPtrGetPtr caps
+    result <- gst_query_new_accept_caps caps'
+    checkUnexpectedReturnNULL "gst_query_new_accept_caps" result
+    result' <- (wrapBoxed Query) result
+    touchManagedPtr caps
+    return result'
+
+-- method Query::new_allocation
+-- method type : Constructor
+-- Args : [Arg {argCName = "caps", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "need_pool", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Query"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_query_new_allocation" gst_query_new_allocation :: 
+    Ptr Caps ->                             -- caps : TInterface "Gst" "Caps"
+    CInt ->                                 -- need_pool : TBasicType TBoolean
+    IO (Ptr Query)
+
+
+queryNewAllocation ::
+    (MonadIO m) =>
+    Caps                                    -- caps
+    -> Bool                                 -- needPool
+    -> m Query                              -- result
+queryNewAllocation caps needPool = liftIO $ do
+    let caps' = unsafeManagedPtrGetPtr caps
+    let needPool' = (fromIntegral . fromEnum) needPool
+    result <- gst_query_new_allocation caps' needPool'
+    checkUnexpectedReturnNULL "gst_query_new_allocation" result
+    result' <- (wrapBoxed Query) result
+    touchManagedPtr caps
+    return result'
+
+-- method Query::new_buffering
+-- method type : Constructor
+-- Args : [Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Query"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_query_new_buffering" gst_query_new_buffering :: 
+    CUInt ->                                -- format : TInterface "Gst" "Format"
+    IO (Ptr Query)
+
+
+queryNewBuffering ::
+    (MonadIO m) =>
+    Format                                  -- format
+    -> m Query                              -- result
+queryNewBuffering format = liftIO $ do
+    let format' = (fromIntegral . fromEnum) format
+    result <- gst_query_new_buffering format'
+    checkUnexpectedReturnNULL "gst_query_new_buffering" result
+    result' <- (wrapBoxed Query) result
+    return result'
+
+-- method Query::new_caps
+-- method type : Constructor
+-- Args : [Arg {argCName = "filter", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Query"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_query_new_caps" gst_query_new_caps :: 
+    Ptr Caps ->                             -- filter : TInterface "Gst" "Caps"
+    IO (Ptr Query)
+
+
+queryNewCaps ::
+    (MonadIO m) =>
+    Caps                                    -- filter
+    -> m Query                              -- result
+queryNewCaps filter = liftIO $ do
+    let filter' = unsafeManagedPtrGetPtr filter
+    result <- gst_query_new_caps filter'
+    checkUnexpectedReturnNULL "gst_query_new_caps" result
+    result' <- (wrapBoxed Query) result
+    touchManagedPtr filter
+    return result'
+
+-- method Query::new_context
+-- method type : Constructor
+-- Args : [Arg {argCName = "context_type", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Query"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_query_new_context" gst_query_new_context :: 
+    CString ->                              -- context_type : TBasicType TUTF8
+    IO (Ptr Query)
+
+
+queryNewContext ::
+    (MonadIO m) =>
+    T.Text                                  -- contextType
+    -> m Query                              -- result
+queryNewContext contextType = liftIO $ do
+    contextType' <- textToCString contextType
+    result <- gst_query_new_context contextType'
+    checkUnexpectedReturnNULL "gst_query_new_context" result
+    result' <- (wrapBoxed Query) result
+    freeMem contextType'
+    return result'
+
+-- method Query::new_convert
+-- method type : Constructor
+-- Args : [Arg {argCName = "src_format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest_format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Query"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_query_new_convert" gst_query_new_convert :: 
+    CUInt ->                                -- src_format : TInterface "Gst" "Format"
+    Int64 ->                                -- value : TBasicType TInt64
+    CUInt ->                                -- dest_format : TInterface "Gst" "Format"
+    IO (Ptr Query)
+
+
+queryNewConvert ::
+    (MonadIO m) =>
+    Format                                  -- srcFormat
+    -> Int64                                -- value
+    -> Format                               -- destFormat
+    -> m Query                              -- result
+queryNewConvert srcFormat value destFormat = liftIO $ do
+    let srcFormat' = (fromIntegral . fromEnum) srcFormat
+    let destFormat' = (fromIntegral . fromEnum) destFormat
+    result <- gst_query_new_convert srcFormat' value destFormat'
+    checkUnexpectedReturnNULL "gst_query_new_convert" result
+    result' <- (wrapBoxed Query) result
+    return result'
+
+-- method Query::new_custom
+-- method type : Constructor
+-- Args : [Arg {argCName = "type", argType = TInterface "Gst" "QueryType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "structure", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Query"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_query_new_custom" gst_query_new_custom :: 
+    CUInt ->                                -- type : TInterface "Gst" "QueryType"
+    Ptr Structure ->                        -- structure : TInterface "Gst" "Structure"
+    IO (Ptr Query)
+
+
+queryNewCustom ::
+    (MonadIO m) =>
+    QueryType                               -- type_
+    -> Maybe (Structure)                    -- structure
+    -> m Query                              -- result
+queryNewCustom type_ structure = liftIO $ do
+    let type_' = (fromIntegral . fromEnum) type_
+    maybeStructure <- case structure of
+        Nothing -> return nullPtr
+        Just jStructure -> do
+            jStructure' <- copyBoxed jStructure
+            return jStructure'
+    result <- gst_query_new_custom type_' maybeStructure
+    checkUnexpectedReturnNULL "gst_query_new_custom" result
+    result' <- (wrapBoxed Query) result
+    whenJust structure touchManagedPtr
+    return result'
+
+-- method Query::new_drain
+-- method type : Constructor
+-- Args : []
+-- Lengths : []
+-- returnType : TInterface "Gst" "Query"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_query_new_drain" gst_query_new_drain :: 
+    IO (Ptr Query)
+
+
+queryNewDrain ::
+    (MonadIO m) =>
+    m Query                                 -- result
+queryNewDrain  = liftIO $ do
+    result <- gst_query_new_drain
+    checkUnexpectedReturnNULL "gst_query_new_drain" result
+    result' <- (wrapBoxed Query) result
+    return result'
+
+-- method Query::new_duration
+-- method type : Constructor
+-- Args : [Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Query"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_query_new_duration" gst_query_new_duration :: 
+    CUInt ->                                -- format : TInterface "Gst" "Format"
+    IO (Ptr Query)
+
+
+queryNewDuration ::
+    (MonadIO m) =>
+    Format                                  -- format
+    -> m Query                              -- result
+queryNewDuration format = liftIO $ do
+    let format' = (fromIntegral . fromEnum) format
+    result <- gst_query_new_duration format'
+    checkUnexpectedReturnNULL "gst_query_new_duration" result
+    result' <- (wrapBoxed Query) result
+    return result'
+
+-- method Query::new_formats
+-- method type : Constructor
+-- Args : []
+-- Lengths : []
+-- returnType : TInterface "Gst" "Query"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_query_new_formats" gst_query_new_formats :: 
+    IO (Ptr Query)
+
+
+queryNewFormats ::
+    (MonadIO m) =>
+    m Query                                 -- result
+queryNewFormats  = liftIO $ do
+    result <- gst_query_new_formats
+    checkUnexpectedReturnNULL "gst_query_new_formats" result
+    result' <- (wrapBoxed Query) result
+    return result'
+
+-- method Query::new_latency
+-- method type : Constructor
+-- Args : []
+-- Lengths : []
+-- returnType : TInterface "Gst" "Query"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_query_new_latency" gst_query_new_latency :: 
+    IO (Ptr Query)
+
+
+queryNewLatency ::
+    (MonadIO m) =>
+    m Query                                 -- result
+queryNewLatency  = liftIO $ do
+    result <- gst_query_new_latency
+    checkUnexpectedReturnNULL "gst_query_new_latency" result
+    result' <- (wrapBoxed Query) result
+    return result'
+
+-- method Query::new_position
+-- method type : Constructor
+-- Args : [Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Query"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_query_new_position" gst_query_new_position :: 
+    CUInt ->                                -- format : TInterface "Gst" "Format"
+    IO (Ptr Query)
+
+
+queryNewPosition ::
+    (MonadIO m) =>
+    Format                                  -- format
+    -> m Query                              -- result
+queryNewPosition format = liftIO $ do
+    let format' = (fromIntegral . fromEnum) format
+    result <- gst_query_new_position format'
+    checkUnexpectedReturnNULL "gst_query_new_position" result
+    result' <- (wrapBoxed Query) result
+    return result'
+
+-- method Query::new_scheduling
+-- method type : Constructor
+-- Args : []
+-- Lengths : []
+-- returnType : TInterface "Gst" "Query"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_query_new_scheduling" gst_query_new_scheduling :: 
+    IO (Ptr Query)
+
+
+queryNewScheduling ::
+    (MonadIO m) =>
+    m Query                                 -- result
+queryNewScheduling  = liftIO $ do
+    result <- gst_query_new_scheduling
+    checkUnexpectedReturnNULL "gst_query_new_scheduling" result
+    result' <- (wrapBoxed Query) result
+    return result'
+
+-- method Query::new_seeking
+-- method type : Constructor
+-- Args : [Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Query"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_query_new_seeking" gst_query_new_seeking :: 
+    CUInt ->                                -- format : TInterface "Gst" "Format"
+    IO (Ptr Query)
+
+
+queryNewSeeking ::
+    (MonadIO m) =>
+    Format                                  -- format
+    -> m Query                              -- result
+queryNewSeeking format = liftIO $ do
+    let format' = (fromIntegral . fromEnum) format
+    result <- gst_query_new_seeking format'
+    checkUnexpectedReturnNULL "gst_query_new_seeking" result
+    result' <- (wrapBoxed Query) result
+    return result'
+
+-- method Query::new_segment
+-- method type : Constructor
+-- Args : [Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Query"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_query_new_segment" gst_query_new_segment :: 
+    CUInt ->                                -- format : TInterface "Gst" "Format"
+    IO (Ptr Query)
+
+
+queryNewSegment ::
+    (MonadIO m) =>
+    Format                                  -- format
+    -> m Query                              -- result
+queryNewSegment format = liftIO $ do
+    let format' = (fromIntegral . fromEnum) format
+    result <- gst_query_new_segment format'
+    checkUnexpectedReturnNULL "gst_query_new_segment" result
+    result' <- (wrapBoxed Query) result
+    return result'
+
+-- method Query::new_uri
+-- method type : Constructor
+-- Args : []
+-- Lengths : []
+-- returnType : TInterface "Gst" "Query"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_query_new_uri" gst_query_new_uri :: 
+    IO (Ptr Query)
+
+
+queryNewUri ::
+    (MonadIO m) =>
+    m Query                                 -- result
+queryNewUri  = liftIO $ do
+    result <- gst_query_new_uri
+    checkUnexpectedReturnNULL "gst_query_new_uri" result
+    result' <- (wrapBoxed Query) result
+    return result'
+
+-- method Query::add_allocation_meta
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "api", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "params", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_query_add_allocation_meta" gst_query_add_allocation_meta :: 
+    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"
+    CGType ->                               -- api : TBasicType TGType
+    Ptr Structure ->                        -- params : TInterface "Gst" "Structure"
+    IO ()
+
+
+queryAddAllocationMeta ::
+    (MonadIO m) =>
+    Query                                   -- _obj
+    -> GType                                -- api
+    -> Maybe (Structure)                    -- params
+    -> m ()                                 -- result
+queryAddAllocationMeta _obj api params = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let api' = gtypeToCGType api
+    maybeParams <- case params of
+        Nothing -> return nullPtr
+        Just jParams -> do
+            let jParams' = unsafeManagedPtrGetPtr jParams
+            return jParams'
+    gst_query_add_allocation_meta _obj' api' maybeParams
+    touchManagedPtr _obj
+    whenJust params touchManagedPtr
+    return ()
+
+data QueryAddAllocationMetaMethodInfo
+instance (signature ~ (GType -> Maybe (Structure) -> m ()), MonadIO m) => MethodInfo QueryAddAllocationMetaMethodInfo Query signature where
+    overloadedMethod _ = queryAddAllocationMeta
+
+-- method Query::add_allocation_param
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "allocator", argType = TInterface "Gst" "Allocator", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "params", argType = TInterface "Gst" "AllocationParams", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_query_add_allocation_param" gst_query_add_allocation_param :: 
+    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"
+    Ptr Allocator ->                        -- allocator : TInterface "Gst" "Allocator"
+    Ptr AllocationParams ->                 -- params : TInterface "Gst" "AllocationParams"
+    IO ()
+
+
+queryAddAllocationParam ::
+    (MonadIO m, AllocatorK a) =>
+    Query                                   -- _obj
+    -> Maybe (a)                            -- allocator
+    -> Maybe (AllocationParams)             -- params
+    -> m ()                                 -- result
+queryAddAllocationParam _obj allocator params = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    maybeAllocator <- case allocator of
+        Nothing -> return nullPtr
+        Just jAllocator -> do
+            let jAllocator' = unsafeManagedPtrCastPtr jAllocator
+            return jAllocator'
+    maybeParams <- case params of
+        Nothing -> return nullPtr
+        Just jParams -> do
+            let jParams' = unsafeManagedPtrGetPtr jParams
+            return jParams'
+    gst_query_add_allocation_param _obj' maybeAllocator maybeParams
+    touchManagedPtr _obj
+    whenJust allocator touchManagedPtr
+    whenJust params touchManagedPtr
+    return ()
+
+data QueryAddAllocationParamMethodInfo
+instance (signature ~ (Maybe (a) -> Maybe (AllocationParams) -> m ()), MonadIO m, AllocatorK a) => MethodInfo QueryAddAllocationParamMethodInfo Query signature where
+    overloadedMethod _ = queryAddAllocationParam
+
+-- method Query::add_allocation_pool
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pool", argType = TInterface "Gst" "BufferPool", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "min_buffers", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "max_buffers", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_query_add_allocation_pool" gst_query_add_allocation_pool :: 
+    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"
+    Ptr BufferPool ->                       -- pool : TInterface "Gst" "BufferPool"
+    Word32 ->                               -- size : TBasicType TUInt32
+    Word32 ->                               -- min_buffers : TBasicType TUInt32
+    Word32 ->                               -- max_buffers : TBasicType TUInt32
+    IO ()
+
+
+queryAddAllocationPool ::
+    (MonadIO m, BufferPoolK a) =>
+    Query                                   -- _obj
+    -> Maybe (a)                            -- pool
+    -> Word32                               -- size
+    -> Word32                               -- minBuffers
+    -> Word32                               -- maxBuffers
+    -> m ()                                 -- result
+queryAddAllocationPool _obj pool size minBuffers maxBuffers = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    maybePool <- case pool of
+        Nothing -> return nullPtr
+        Just jPool -> do
+            let jPool' = unsafeManagedPtrCastPtr jPool
+            return jPool'
+    gst_query_add_allocation_pool _obj' maybePool size minBuffers maxBuffers
+    touchManagedPtr _obj
+    whenJust pool touchManagedPtr
+    return ()
+
+data QueryAddAllocationPoolMethodInfo
+instance (signature ~ (Maybe (a) -> Word32 -> Word32 -> Word32 -> m ()), MonadIO m, BufferPoolK a) => MethodInfo QueryAddAllocationPoolMethodInfo Query signature where
+    overloadedMethod _ = queryAddAllocationPool
+
+-- method Query::add_buffering_range
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stop", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_query_add_buffering_range" gst_query_add_buffering_range :: 
+    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"
+    Int64 ->                                -- start : TBasicType TInt64
+    Int64 ->                                -- stop : TBasicType TInt64
+    IO CInt
+
+
+queryAddBufferingRange ::
+    (MonadIO m) =>
+    Query                                   -- _obj
+    -> Int64                                -- start
+    -> Int64                                -- stop
+    -> m Bool                               -- result
+queryAddBufferingRange _obj start stop = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_query_add_buffering_range _obj' start stop
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data QueryAddBufferingRangeMethodInfo
+instance (signature ~ (Int64 -> Int64 -> m Bool), MonadIO m) => MethodInfo QueryAddBufferingRangeMethodInfo Query signature where
+    overloadedMethod _ = queryAddBufferingRange
+
+-- method Query::add_scheduling_mode
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mode", argType = TInterface "Gst" "PadMode", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_query_add_scheduling_mode" gst_query_add_scheduling_mode :: 
+    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"
+    CUInt ->                                -- mode : TInterface "Gst" "PadMode"
+    IO ()
+
+
+queryAddSchedulingMode ::
+    (MonadIO m) =>
+    Query                                   -- _obj
+    -> PadMode                              -- mode
+    -> m ()                                 -- result
+queryAddSchedulingMode _obj mode = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let mode' = (fromIntegral . fromEnum) mode
+    gst_query_add_scheduling_mode _obj' mode'
+    touchManagedPtr _obj
+    return ()
+
+data QueryAddSchedulingModeMethodInfo
+instance (signature ~ (PadMode -> m ()), MonadIO m) => MethodInfo QueryAddSchedulingModeMethodInfo Query signature where
+    overloadedMethod _ = queryAddSchedulingMode
+
+-- method Query::find_allocation_meta
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "api", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_query_find_allocation_meta" gst_query_find_allocation_meta :: 
+    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"
+    CGType ->                               -- api : TBasicType TGType
+    Ptr Word32 ->                           -- index : TBasicType TUInt32
+    IO CInt
+
+
+queryFindAllocationMeta ::
+    (MonadIO m) =>
+    Query                                   -- _obj
+    -> GType                                -- api
+    -> m (Bool,Word32)                      -- result
+queryFindAllocationMeta _obj api = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let api' = gtypeToCGType api
+    index <- allocMem :: IO (Ptr Word32)
+    result <- gst_query_find_allocation_meta _obj' api' index
+    let result' = (/= 0) result
+    index' <- peek index
+    touchManagedPtr _obj
+    freeMem index
+    return (result', index')
+
+data QueryFindAllocationMetaMethodInfo
+instance (signature ~ (GType -> m (Bool,Word32)), MonadIO m) => MethodInfo QueryFindAllocationMetaMethodInfo Query signature where
+    overloadedMethod _ = queryFindAllocationMeta
+
+-- method Query::get_n_allocation_metas
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUInt32
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_query_get_n_allocation_metas" gst_query_get_n_allocation_metas :: 
+    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"
+    IO Word32
+
+
+queryGetNAllocationMetas ::
+    (MonadIO m) =>
+    Query                                   -- _obj
+    -> m Word32                             -- result
+queryGetNAllocationMetas _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_query_get_n_allocation_metas _obj'
+    touchManagedPtr _obj
+    return result
+
+data QueryGetNAllocationMetasMethodInfo
+instance (signature ~ (m Word32), MonadIO m) => MethodInfo QueryGetNAllocationMetasMethodInfo Query signature where
+    overloadedMethod _ = queryGetNAllocationMetas
+
+-- method Query::get_n_allocation_params
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUInt32
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_query_get_n_allocation_params" gst_query_get_n_allocation_params :: 
+    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"
+    IO Word32
+
+
+queryGetNAllocationParams ::
+    (MonadIO m) =>
+    Query                                   -- _obj
+    -> m Word32                             -- result
+queryGetNAllocationParams _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_query_get_n_allocation_params _obj'
+    touchManagedPtr _obj
+    return result
+
+data QueryGetNAllocationParamsMethodInfo
+instance (signature ~ (m Word32), MonadIO m) => MethodInfo QueryGetNAllocationParamsMethodInfo Query signature where
+    overloadedMethod _ = queryGetNAllocationParams
+
+-- method Query::get_n_allocation_pools
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUInt32
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_query_get_n_allocation_pools" gst_query_get_n_allocation_pools :: 
+    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"
+    IO Word32
+
+
+queryGetNAllocationPools ::
+    (MonadIO m) =>
+    Query                                   -- _obj
+    -> m Word32                             -- result
+queryGetNAllocationPools _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_query_get_n_allocation_pools _obj'
+    touchManagedPtr _obj
+    return result
+
+data QueryGetNAllocationPoolsMethodInfo
+instance (signature ~ (m Word32), MonadIO m) => MethodInfo QueryGetNAllocationPoolsMethodInfo Query signature where
+    overloadedMethod _ = queryGetNAllocationPools
+
+-- method Query::get_n_buffering_ranges
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUInt32
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_query_get_n_buffering_ranges" gst_query_get_n_buffering_ranges :: 
+    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"
+    IO Word32
+
+
+queryGetNBufferingRanges ::
+    (MonadIO m) =>
+    Query                                   -- _obj
+    -> m Word32                             -- result
+queryGetNBufferingRanges _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_query_get_n_buffering_ranges _obj'
+    touchManagedPtr _obj
+    return result
+
+data QueryGetNBufferingRangesMethodInfo
+instance (signature ~ (m Word32), MonadIO m) => MethodInfo QueryGetNBufferingRangesMethodInfo Query signature where
+    overloadedMethod _ = queryGetNBufferingRanges
+
+-- method Query::get_n_scheduling_modes
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUInt32
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_query_get_n_scheduling_modes" gst_query_get_n_scheduling_modes :: 
+    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"
+    IO Word32
+
+
+queryGetNSchedulingModes ::
+    (MonadIO m) =>
+    Query                                   -- _obj
+    -> m Word32                             -- result
+queryGetNSchedulingModes _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_query_get_n_scheduling_modes _obj'
+    touchManagedPtr _obj
+    return result
+
+data QueryGetNSchedulingModesMethodInfo
+instance (signature ~ (m Word32), MonadIO m) => MethodInfo QueryGetNSchedulingModesMethodInfo Query signature where
+    overloadedMethod _ = queryGetNSchedulingModes
+
+-- method Query::get_structure
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Structure"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_query_get_structure" gst_query_get_structure :: 
+    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"
+    IO (Ptr Structure)
+
+
+queryGetStructure ::
+    (MonadIO m) =>
+    Query                                   -- _obj
+    -> m Structure                          -- result
+queryGetStructure _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_query_get_structure _obj'
+    checkUnexpectedReturnNULL "gst_query_get_structure" result
+    result' <- (newBoxed Structure) result
+    touchManagedPtr _obj
+    return result'
+
+data QueryGetStructureMethodInfo
+instance (signature ~ (m Structure), MonadIO m) => MethodInfo QueryGetStructureMethodInfo Query signature where
+    overloadedMethod _ = queryGetStructure
+
+-- method Query::has_scheduling_mode
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mode", argType = TInterface "Gst" "PadMode", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_query_has_scheduling_mode" gst_query_has_scheduling_mode :: 
+    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"
+    CUInt ->                                -- mode : TInterface "Gst" "PadMode"
+    IO CInt
+
+
+queryHasSchedulingMode ::
+    (MonadIO m) =>
+    Query                                   -- _obj
+    -> PadMode                              -- mode
+    -> m Bool                               -- result
+queryHasSchedulingMode _obj mode = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let mode' = (fromIntegral . fromEnum) mode
+    result <- gst_query_has_scheduling_mode _obj' mode'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data QueryHasSchedulingModeMethodInfo
+instance (signature ~ (PadMode -> m Bool), MonadIO m) => MethodInfo QueryHasSchedulingModeMethodInfo Query signature where
+    overloadedMethod _ = queryHasSchedulingMode
+
+-- method Query::has_scheduling_mode_with_flags
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mode", argType = TInterface "Gst" "PadMode", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface "Gst" "SchedulingFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_query_has_scheduling_mode_with_flags" gst_query_has_scheduling_mode_with_flags :: 
+    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"
+    CUInt ->                                -- mode : TInterface "Gst" "PadMode"
+    CUInt ->                                -- flags : TInterface "Gst" "SchedulingFlags"
+    IO CInt
+
+
+queryHasSchedulingModeWithFlags ::
+    (MonadIO m) =>
+    Query                                   -- _obj
+    -> PadMode                              -- mode
+    -> [SchedulingFlags]                    -- flags
+    -> m Bool                               -- result
+queryHasSchedulingModeWithFlags _obj mode flags = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let mode' = (fromIntegral . fromEnum) mode
+    let flags' = gflagsToWord flags
+    result <- gst_query_has_scheduling_mode_with_flags _obj' mode' flags'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data QueryHasSchedulingModeWithFlagsMethodInfo
+instance (signature ~ (PadMode -> [SchedulingFlags] -> m Bool), MonadIO m) => MethodInfo QueryHasSchedulingModeWithFlagsMethodInfo Query signature where
+    overloadedMethod _ = queryHasSchedulingModeWithFlags
+
+-- method Query::parse_accept_caps
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps", argType = TInterface "Gst" "Caps", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_query_parse_accept_caps" gst_query_parse_accept_caps :: 
+    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"
+    Ptr Caps ->                             -- caps : TInterface "Gst" "Caps"
+    IO ()
+
+
+queryParseAcceptCaps ::
+    (MonadIO m) =>
+    Query                                   -- _obj
+    -> m (Caps)                             -- result
+queryParseAcceptCaps _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    caps <- callocBoxedBytes 64 :: IO (Ptr Caps)
+    gst_query_parse_accept_caps _obj' caps
+    caps' <- (wrapBoxed Caps) caps
+    touchManagedPtr _obj
+    return caps'
+
+data QueryParseAcceptCapsMethodInfo
+instance (signature ~ (m (Caps)), MonadIO m) => MethodInfo QueryParseAcceptCapsMethodInfo Query signature where
+    overloadedMethod _ = queryParseAcceptCaps
+
+-- method Query::parse_accept_caps_result
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_query_parse_accept_caps_result" gst_query_parse_accept_caps_result :: 
+    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"
+    CInt ->                                 -- result : TBasicType TBoolean
+    IO ()
+
+
+queryParseAcceptCapsResult ::
+    (MonadIO m) =>
+    Query                                   -- _obj
+    -> Bool                                 -- result_
+    -> m ()                                 -- result
+queryParseAcceptCapsResult _obj result_ = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let result_' = (fromIntegral . fromEnum) result_
+    gst_query_parse_accept_caps_result _obj' result_'
+    touchManagedPtr _obj
+    return ()
+
+data QueryParseAcceptCapsResultMethodInfo
+instance (signature ~ (Bool -> m ()), MonadIO m) => MethodInfo QueryParseAcceptCapsResultMethodInfo Query signature where
+    overloadedMethod _ = queryParseAcceptCapsResult
+
+-- method Query::parse_allocation
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps", argType = TInterface "Gst" "Caps", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "need_pool", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_query_parse_allocation" gst_query_parse_allocation :: 
+    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"
+    Ptr Caps ->                             -- caps : TInterface "Gst" "Caps"
+    Ptr CInt ->                             -- need_pool : TBasicType TBoolean
+    IO ()
+
+
+queryParseAllocation ::
+    (MonadIO m) =>
+    Query                                   -- _obj
+    -> m (Caps,Bool)                        -- result
+queryParseAllocation _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    caps <- callocBoxedBytes 64 :: IO (Ptr Caps)
+    needPool <- allocMem :: IO (Ptr CInt)
+    gst_query_parse_allocation _obj' caps needPool
+    caps' <- (wrapBoxed Caps) caps
+    needPool' <- peek needPool
+    let needPool'' = (/= 0) needPool'
+    touchManagedPtr _obj
+    freeMem needPool
+    return (caps', needPool'')
+
+data QueryParseAllocationMethodInfo
+instance (signature ~ (m (Caps,Bool)), MonadIO m) => MethodInfo QueryParseAllocationMethodInfo Query signature where
+    overloadedMethod _ = queryParseAllocation
+
+-- method Query::parse_buffering_percent
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "busy", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "percent", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_query_parse_buffering_percent" gst_query_parse_buffering_percent :: 
+    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"
+    Ptr CInt ->                             -- busy : TBasicType TBoolean
+    Ptr Int32 ->                            -- percent : TBasicType TInt32
+    IO ()
+
+
+queryParseBufferingPercent ::
+    (MonadIO m) =>
+    Query                                   -- _obj
+    -> m (Bool,Int32)                       -- result
+queryParseBufferingPercent _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    busy <- allocMem :: IO (Ptr CInt)
+    percent <- allocMem :: IO (Ptr Int32)
+    gst_query_parse_buffering_percent _obj' busy percent
+    busy' <- peek busy
+    let busy'' = (/= 0) busy'
+    percent' <- peek percent
+    touchManagedPtr _obj
+    freeMem busy
+    freeMem percent
+    return (busy'', percent')
+
+data QueryParseBufferingPercentMethodInfo
+instance (signature ~ (m (Bool,Int32)), MonadIO m) => MethodInfo QueryParseBufferingPercentMethodInfo Query signature where
+    overloadedMethod _ = queryParseBufferingPercent
+
+-- method Query::parse_buffering_range
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "start", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "stop", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "estimated_total", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_query_parse_buffering_range" gst_query_parse_buffering_range :: 
+    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"
+    Ptr CUInt ->                            -- format : TInterface "Gst" "Format"
+    Ptr Int64 ->                            -- start : TBasicType TInt64
+    Ptr Int64 ->                            -- stop : TBasicType TInt64
+    Ptr Int64 ->                            -- estimated_total : TBasicType TInt64
+    IO ()
+
+
+queryParseBufferingRange ::
+    (MonadIO m) =>
+    Query                                   -- _obj
+    -> m (Format,Int64,Int64,Int64)         -- result
+queryParseBufferingRange _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    format <- allocMem :: IO (Ptr CUInt)
+    start <- allocMem :: IO (Ptr Int64)
+    stop <- allocMem :: IO (Ptr Int64)
+    estimatedTotal <- allocMem :: IO (Ptr Int64)
+    gst_query_parse_buffering_range _obj' format start stop estimatedTotal
+    format' <- peek format
+    let format'' = (toEnum . fromIntegral) format'
+    start' <- peek start
+    stop' <- peek stop
+    estimatedTotal' <- peek estimatedTotal
+    touchManagedPtr _obj
+    freeMem format
+    freeMem start
+    freeMem stop
+    freeMem estimatedTotal
+    return (format'', start', stop', estimatedTotal')
+
+data QueryParseBufferingRangeMethodInfo
+instance (signature ~ (m (Format,Int64,Int64,Int64)), MonadIO m) => MethodInfo QueryParseBufferingRangeMethodInfo Query signature where
+    overloadedMethod _ = queryParseBufferingRange
+
+-- method Query::parse_buffering_stats
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mode", argType = TInterface "Gst" "BufferingMode", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "avg_in", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "avg_out", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "buffering_left", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_query_parse_buffering_stats" gst_query_parse_buffering_stats :: 
+    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"
+    Ptr CUInt ->                            -- mode : TInterface "Gst" "BufferingMode"
+    Ptr Int32 ->                            -- avg_in : TBasicType TInt32
+    Ptr Int32 ->                            -- avg_out : TBasicType TInt32
+    Ptr Int64 ->                            -- buffering_left : TBasicType TInt64
+    IO ()
+
+
+queryParseBufferingStats ::
+    (MonadIO m) =>
+    Query                                   -- _obj
+    -> m (BufferingMode,Int32,Int32,Int64)  -- result
+queryParseBufferingStats _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    mode <- allocMem :: IO (Ptr CUInt)
+    avgIn <- allocMem :: IO (Ptr Int32)
+    avgOut <- allocMem :: IO (Ptr Int32)
+    bufferingLeft <- allocMem :: IO (Ptr Int64)
+    gst_query_parse_buffering_stats _obj' mode avgIn avgOut bufferingLeft
+    mode' <- peek mode
+    let mode'' = (toEnum . fromIntegral) mode'
+    avgIn' <- peek avgIn
+    avgOut' <- peek avgOut
+    bufferingLeft' <- peek bufferingLeft
+    touchManagedPtr _obj
+    freeMem mode
+    freeMem avgIn
+    freeMem avgOut
+    freeMem bufferingLeft
+    return (mode'', avgIn', avgOut', bufferingLeft')
+
+data QueryParseBufferingStatsMethodInfo
+instance (signature ~ (m (BufferingMode,Int32,Int32,Int64)), MonadIO m) => MethodInfo QueryParseBufferingStatsMethodInfo Query signature where
+    overloadedMethod _ = queryParseBufferingStats
+
+-- method Query::parse_caps
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "filter", argType = TInterface "Gst" "Caps", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_query_parse_caps" gst_query_parse_caps :: 
+    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"
+    Ptr Caps ->                             -- filter : TInterface "Gst" "Caps"
+    IO ()
+
+
+queryParseCaps ::
+    (MonadIO m) =>
+    Query                                   -- _obj
+    -> m (Caps)                             -- result
+queryParseCaps _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    filter <- callocBoxedBytes 64 :: IO (Ptr Caps)
+    gst_query_parse_caps _obj' filter
+    filter' <- (wrapBoxed Caps) filter
+    touchManagedPtr _obj
+    return filter'
+
+data QueryParseCapsMethodInfo
+instance (signature ~ (m (Caps)), MonadIO m) => MethodInfo QueryParseCapsMethodInfo Query signature where
+    overloadedMethod _ = queryParseCaps
+
+-- method Query::parse_caps_result
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps", argType = TInterface "Gst" "Caps", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_query_parse_caps_result" gst_query_parse_caps_result :: 
+    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"
+    Ptr Caps ->                             -- caps : TInterface "Gst" "Caps"
+    IO ()
+
+
+queryParseCapsResult ::
+    (MonadIO m) =>
+    Query                                   -- _obj
+    -> m (Caps)                             -- result
+queryParseCapsResult _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    caps <- callocBoxedBytes 64 :: IO (Ptr Caps)
+    gst_query_parse_caps_result _obj' caps
+    caps' <- (wrapBoxed Caps) caps
+    touchManagedPtr _obj
+    return caps'
+
+data QueryParseCapsResultMethodInfo
+instance (signature ~ (m (Caps)), MonadIO m) => MethodInfo QueryParseCapsResultMethodInfo Query signature where
+    overloadedMethod _ = queryParseCapsResult
+
+-- method Query::parse_context
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "context", argType = TInterface "Gst" "Context", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_query_parse_context" gst_query_parse_context :: 
+    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"
+    Ptr (Ptr Context) ->                    -- context : TInterface "Gst" "Context"
+    IO ()
+
+
+queryParseContext ::
+    (MonadIO m) =>
+    Query                                   -- _obj
+    -> m (Context)                          -- result
+queryParseContext _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    context <- allocMem :: IO (Ptr (Ptr Context))
+    gst_query_parse_context _obj' context
+    context' <- peek context
+    context'' <- (newBoxed Context) context'
+    touchManagedPtr _obj
+    freeMem context
+    return context''
+
+data QueryParseContextMethodInfo
+instance (signature ~ (m (Context)), MonadIO m) => MethodInfo QueryParseContextMethodInfo Query signature where
+    overloadedMethod _ = queryParseContext
+
+-- method Query::parse_context_type
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "context_type", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_query_parse_context_type" gst_query_parse_context_type :: 
+    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"
+    Ptr CString ->                          -- context_type : TBasicType TUTF8
+    IO CInt
+
+
+queryParseContextType ::
+    (MonadIO m) =>
+    Query                                   -- _obj
+    -> m (Bool,T.Text)                      -- result
+queryParseContextType _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    contextType <- allocMem :: IO (Ptr CString)
+    result <- gst_query_parse_context_type _obj' contextType
+    let result' = (/= 0) result
+    contextType' <- peek contextType
+    contextType'' <- cstringToText contextType'
+    touchManagedPtr _obj
+    freeMem contextType
+    return (result', contextType'')
+
+data QueryParseContextTypeMethodInfo
+instance (signature ~ (m (Bool,T.Text)), MonadIO m) => MethodInfo QueryParseContextTypeMethodInfo Query signature where
+    overloadedMethod _ = queryParseContextType
+
+-- method Query::parse_convert
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "src_format", argType = TInterface "Gst" "Format", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "src_value", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "dest_format", argType = TInterface "Gst" "Format", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "dest_value", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_query_parse_convert" gst_query_parse_convert :: 
+    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"
+    Ptr CUInt ->                            -- src_format : TInterface "Gst" "Format"
+    Ptr Int64 ->                            -- src_value : TBasicType TInt64
+    Ptr CUInt ->                            -- dest_format : TInterface "Gst" "Format"
+    Ptr Int64 ->                            -- dest_value : TBasicType TInt64
+    IO ()
+
+
+queryParseConvert ::
+    (MonadIO m) =>
+    Query                                   -- _obj
+    -> m (Format,Int64,Format,Int64)        -- result
+queryParseConvert _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    srcFormat <- allocMem :: IO (Ptr CUInt)
+    srcValue <- allocMem :: IO (Ptr Int64)
+    destFormat <- allocMem :: IO (Ptr CUInt)
+    destValue <- allocMem :: IO (Ptr Int64)
+    gst_query_parse_convert _obj' srcFormat srcValue destFormat destValue
+    srcFormat' <- peek srcFormat
+    let srcFormat'' = (toEnum . fromIntegral) srcFormat'
+    srcValue' <- peek srcValue
+    destFormat' <- peek destFormat
+    let destFormat'' = (toEnum . fromIntegral) destFormat'
+    destValue' <- peek destValue
+    touchManagedPtr _obj
+    freeMem srcFormat
+    freeMem srcValue
+    freeMem destFormat
+    freeMem destValue
+    return (srcFormat'', srcValue', destFormat'', destValue')
+
+data QueryParseConvertMethodInfo
+instance (signature ~ (m (Format,Int64,Format,Int64)), MonadIO m) => MethodInfo QueryParseConvertMethodInfo Query signature where
+    overloadedMethod _ = queryParseConvert
+
+-- method Query::parse_duration
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "duration", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_query_parse_duration" gst_query_parse_duration :: 
+    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"
+    Ptr CUInt ->                            -- format : TInterface "Gst" "Format"
+    Ptr Int64 ->                            -- duration : TBasicType TInt64
+    IO ()
+
+
+queryParseDuration ::
+    (MonadIO m) =>
+    Query                                   -- _obj
+    -> m (Format,Int64)                     -- result
+queryParseDuration _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    format <- allocMem :: IO (Ptr CUInt)
+    duration <- allocMem :: IO (Ptr Int64)
+    gst_query_parse_duration _obj' format duration
+    format' <- peek format
+    let format'' = (toEnum . fromIntegral) format'
+    duration' <- peek duration
+    touchManagedPtr _obj
+    freeMem format
+    freeMem duration
+    return (format'', duration')
+
+data QueryParseDurationMethodInfo
+instance (signature ~ (m (Format,Int64)), MonadIO m) => MethodInfo QueryParseDurationMethodInfo Query signature where
+    overloadedMethod _ = queryParseDuration
+
+-- method Query::parse_latency
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "live", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "min_latency", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "max_latency", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_query_parse_latency" gst_query_parse_latency :: 
+    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"
+    Ptr CInt ->                             -- live : TBasicType TBoolean
+    Ptr Word64 ->                           -- min_latency : TBasicType TUInt64
+    Ptr Word64 ->                           -- max_latency : TBasicType TUInt64
+    IO ()
+
+
+queryParseLatency ::
+    (MonadIO m) =>
+    Query                                   -- _obj
+    -> m (Bool,Word64,Word64)               -- result
+queryParseLatency _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    live <- allocMem :: IO (Ptr CInt)
+    minLatency <- allocMem :: IO (Ptr Word64)
+    maxLatency <- allocMem :: IO (Ptr Word64)
+    gst_query_parse_latency _obj' live minLatency maxLatency
+    live' <- peek live
+    let live'' = (/= 0) live'
+    minLatency' <- peek minLatency
+    maxLatency' <- peek maxLatency
+    touchManagedPtr _obj
+    freeMem live
+    freeMem minLatency
+    freeMem maxLatency
+    return (live'', minLatency', maxLatency')
+
+data QueryParseLatencyMethodInfo
+instance (signature ~ (m (Bool,Word64,Word64)), MonadIO m) => MethodInfo QueryParseLatencyMethodInfo Query signature where
+    overloadedMethod _ = queryParseLatency
+
+-- method Query::parse_n_formats
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_formats", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_query_parse_n_formats" gst_query_parse_n_formats :: 
+    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"
+    Ptr Word32 ->                           -- n_formats : TBasicType TUInt32
+    IO ()
+
+
+queryParseNFormats ::
+    (MonadIO m) =>
+    Query                                   -- _obj
+    -> m (Word32)                           -- result
+queryParseNFormats _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    nFormats <- allocMem :: IO (Ptr Word32)
+    gst_query_parse_n_formats _obj' nFormats
+    nFormats' <- peek nFormats
+    touchManagedPtr _obj
+    freeMem nFormats
+    return nFormats'
+
+data QueryParseNFormatsMethodInfo
+instance (signature ~ (m (Word32)), MonadIO m) => MethodInfo QueryParseNFormatsMethodInfo Query signature where
+    overloadedMethod _ = queryParseNFormats
+
+-- method Query::parse_nth_allocation_meta
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "params", argType = TInterface "Gst" "Structure", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TGType
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_query_parse_nth_allocation_meta" gst_query_parse_nth_allocation_meta :: 
+    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"
+    Word32 ->                               -- index : TBasicType TUInt32
+    Ptr Structure ->                        -- params : TInterface "Gst" "Structure"
+    IO CGType
+
+
+queryParseNthAllocationMeta ::
+    (MonadIO m) =>
+    Query                                   -- _obj
+    -> Word32                               -- index
+    -> m (GType,Structure)                  -- result
+queryParseNthAllocationMeta _obj index = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    params <- callocBoxedBytes 16 :: IO (Ptr Structure)
+    result <- gst_query_parse_nth_allocation_meta _obj' index params
+    let result' = GType result
+    params' <- (wrapBoxed Structure) params
+    touchManagedPtr _obj
+    return (result', params')
+
+data QueryParseNthAllocationMetaMethodInfo
+instance (signature ~ (Word32 -> m (GType,Structure)), MonadIO m) => MethodInfo QueryParseNthAllocationMetaMethodInfo Query signature where
+    overloadedMethod _ = queryParseNthAllocationMeta
+
+-- method Query::parse_nth_allocation_param
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "allocator", argType = TInterface "Gst" "Allocator", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "params", argType = TInterface "Gst" "AllocationParams", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_query_parse_nth_allocation_param" gst_query_parse_nth_allocation_param :: 
+    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"
+    Word32 ->                               -- index : TBasicType TUInt32
+    Ptr (Ptr Allocator) ->                  -- allocator : TInterface "Gst" "Allocator"
+    Ptr AllocationParams ->                 -- params : TInterface "Gst" "AllocationParams"
+    IO ()
+
+
+queryParseNthAllocationParam ::
+    (MonadIO m) =>
+    Query                                   -- _obj
+    -> Word32                               -- index
+    -> m (Allocator,AllocationParams)       -- result
+queryParseNthAllocationParam _obj index = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    allocator <- allocMem :: IO (Ptr (Ptr Allocator))
+    params <- callocBoxedBytes 64 :: IO (Ptr AllocationParams)
+    gst_query_parse_nth_allocation_param _obj' index allocator params
+    allocator' <- peek allocator
+    allocator'' <- (wrapObject Allocator) allocator'
+    params' <- (wrapBoxed AllocationParams) params
+    touchManagedPtr _obj
+    freeMem allocator
+    return (allocator'', params')
+
+data QueryParseNthAllocationParamMethodInfo
+instance (signature ~ (Word32 -> m (Allocator,AllocationParams)), MonadIO m) => MethodInfo QueryParseNthAllocationParamMethodInfo Query signature where
+    overloadedMethod _ = queryParseNthAllocationParam
+
+-- method Query::parse_nth_allocation_pool
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pool", argType = TInterface "Gst" "BufferPool", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "size", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "min_buffers", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "max_buffers", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_query_parse_nth_allocation_pool" gst_query_parse_nth_allocation_pool :: 
+    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"
+    Word32 ->                               -- index : TBasicType TUInt32
+    Ptr (Ptr BufferPool) ->                 -- pool : TInterface "Gst" "BufferPool"
+    Ptr Word32 ->                           -- size : TBasicType TUInt32
+    Ptr Word32 ->                           -- min_buffers : TBasicType TUInt32
+    Ptr Word32 ->                           -- max_buffers : TBasicType TUInt32
+    IO ()
+
+
+queryParseNthAllocationPool ::
+    (MonadIO m) =>
+    Query                                   -- _obj
+    -> Word32                               -- index
+    -> m (BufferPool,Word32,Word32,Word32)  -- result
+queryParseNthAllocationPool _obj index = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    pool <- allocMem :: IO (Ptr (Ptr BufferPool))
+    size <- allocMem :: IO (Ptr Word32)
+    minBuffers <- allocMem :: IO (Ptr Word32)
+    maxBuffers <- allocMem :: IO (Ptr Word32)
+    gst_query_parse_nth_allocation_pool _obj' index pool size minBuffers maxBuffers
+    pool' <- peek pool
+    pool'' <- (wrapObject BufferPool) pool'
+    size' <- peek size
+    minBuffers' <- peek minBuffers
+    maxBuffers' <- peek maxBuffers
+    touchManagedPtr _obj
+    freeMem pool
+    freeMem size
+    freeMem minBuffers
+    freeMem maxBuffers
+    return (pool'', size', minBuffers', maxBuffers')
+
+data QueryParseNthAllocationPoolMethodInfo
+instance (signature ~ (Word32 -> m (BufferPool,Word32,Word32,Word32)), MonadIO m) => MethodInfo QueryParseNthAllocationPoolMethodInfo Query signature where
+    overloadedMethod _ = queryParseNthAllocationPool
+
+-- method Query::parse_nth_buffering_range
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "stop", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_query_parse_nth_buffering_range" gst_query_parse_nth_buffering_range :: 
+    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"
+    Word32 ->                               -- index : TBasicType TUInt32
+    Ptr Int64 ->                            -- start : TBasicType TInt64
+    Ptr Int64 ->                            -- stop : TBasicType TInt64
+    IO CInt
+
+
+queryParseNthBufferingRange ::
+    (MonadIO m) =>
+    Query                                   -- _obj
+    -> Word32                               -- index
+    -> m (Bool,Int64,Int64)                 -- result
+queryParseNthBufferingRange _obj index = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    start <- allocMem :: IO (Ptr Int64)
+    stop <- allocMem :: IO (Ptr Int64)
+    result <- gst_query_parse_nth_buffering_range _obj' index start stop
+    let result' = (/= 0) result
+    start' <- peek start
+    stop' <- peek stop
+    touchManagedPtr _obj
+    freeMem start
+    freeMem stop
+    return (result', start', stop')
+
+data QueryParseNthBufferingRangeMethodInfo
+instance (signature ~ (Word32 -> m (Bool,Int64,Int64)), MonadIO m) => MethodInfo QueryParseNthBufferingRangeMethodInfo Query signature where
+    overloadedMethod _ = queryParseNthBufferingRange
+
+-- method Query::parse_nth_format
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "nth", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_query_parse_nth_format" gst_query_parse_nth_format :: 
+    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"
+    Ptr Word32 ->                           -- nth : TBasicType TUInt32
+    Ptr CUInt ->                            -- format : TInterface "Gst" "Format"
+    IO ()
+
+
+queryParseNthFormat ::
+    (MonadIO m) =>
+    Query                                   -- _obj
+    -> m (Word32,Format)                    -- result
+queryParseNthFormat _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    nth <- allocMem :: IO (Ptr Word32)
+    format <- allocMem :: IO (Ptr CUInt)
+    gst_query_parse_nth_format _obj' nth format
+    nth' <- peek nth
+    format' <- peek format
+    let format'' = (toEnum . fromIntegral) format'
+    touchManagedPtr _obj
+    freeMem nth
+    freeMem format
+    return (nth', format'')
+
+data QueryParseNthFormatMethodInfo
+instance (signature ~ (m (Word32,Format)), MonadIO m) => MethodInfo QueryParseNthFormatMethodInfo Query signature where
+    overloadedMethod _ = queryParseNthFormat
+
+-- method Query::parse_nth_scheduling_mode
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "PadMode"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_query_parse_nth_scheduling_mode" gst_query_parse_nth_scheduling_mode :: 
+    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"
+    Word32 ->                               -- index : TBasicType TUInt32
+    IO CUInt
+
+
+queryParseNthSchedulingMode ::
+    (MonadIO m) =>
+    Query                                   -- _obj
+    -> Word32                               -- index
+    -> m PadMode                            -- result
+queryParseNthSchedulingMode _obj index = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_query_parse_nth_scheduling_mode _obj' index
+    let result' = (toEnum . fromIntegral) result
+    touchManagedPtr _obj
+    return result'
+
+data QueryParseNthSchedulingModeMethodInfo
+instance (signature ~ (Word32 -> m PadMode), MonadIO m) => MethodInfo QueryParseNthSchedulingModeMethodInfo Query signature where
+    overloadedMethod _ = queryParseNthSchedulingMode
+
+-- method Query::parse_position
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "cur", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_query_parse_position" gst_query_parse_position :: 
+    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"
+    Ptr CUInt ->                            -- format : TInterface "Gst" "Format"
+    Ptr Int64 ->                            -- cur : TBasicType TInt64
+    IO ()
+
+
+queryParsePosition ::
+    (MonadIO m) =>
+    Query                                   -- _obj
+    -> m (Format,Int64)                     -- result
+queryParsePosition _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    format <- allocMem :: IO (Ptr CUInt)
+    cur <- allocMem :: IO (Ptr Int64)
+    gst_query_parse_position _obj' format cur
+    format' <- peek format
+    let format'' = (toEnum . fromIntegral) format'
+    cur' <- peek cur
+    touchManagedPtr _obj
+    freeMem format
+    freeMem cur
+    return (format'', cur')
+
+data QueryParsePositionMethodInfo
+instance (signature ~ (m (Format,Int64)), MonadIO m) => MethodInfo QueryParsePositionMethodInfo Query signature where
+    overloadedMethod _ = queryParsePosition
+
+-- method Query::parse_scheduling
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface "Gst" "SchedulingFlags", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "minsize", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "maxsize", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "align", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_query_parse_scheduling" gst_query_parse_scheduling :: 
+    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"
+    Ptr CUInt ->                            -- flags : TInterface "Gst" "SchedulingFlags"
+    Ptr Int32 ->                            -- minsize : TBasicType TInt32
+    Ptr Int32 ->                            -- maxsize : TBasicType TInt32
+    Ptr Int32 ->                            -- align : TBasicType TInt32
+    IO ()
+
+
+queryParseScheduling ::
+    (MonadIO m) =>
+    Query                                   -- _obj
+    -> m ([SchedulingFlags],Int32,Int32,Int32)-- result
+queryParseScheduling _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    flags <- allocMem :: IO (Ptr CUInt)
+    minsize <- allocMem :: IO (Ptr Int32)
+    maxsize <- allocMem :: IO (Ptr Int32)
+    align <- allocMem :: IO (Ptr Int32)
+    gst_query_parse_scheduling _obj' flags minsize maxsize align
+    flags' <- peek flags
+    let flags'' = wordToGFlags flags'
+    minsize' <- peek minsize
+    maxsize' <- peek maxsize
+    align' <- peek align
+    touchManagedPtr _obj
+    freeMem flags
+    freeMem minsize
+    freeMem maxsize
+    freeMem align
+    return (flags'', minsize', maxsize', align')
+
+data QueryParseSchedulingMethodInfo
+instance (signature ~ (m ([SchedulingFlags],Int32,Int32,Int32)), MonadIO m) => MethodInfo QueryParseSchedulingMethodInfo Query signature where
+    overloadedMethod _ = queryParseScheduling
+
+-- method Query::parse_seeking
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "seekable", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "segment_start", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "segment_end", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_query_parse_seeking" gst_query_parse_seeking :: 
+    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"
+    Ptr CUInt ->                            -- format : TInterface "Gst" "Format"
+    Ptr CInt ->                             -- seekable : TBasicType TBoolean
+    Ptr Int64 ->                            -- segment_start : TBasicType TInt64
+    Ptr Int64 ->                            -- segment_end : TBasicType TInt64
+    IO ()
+
+
+queryParseSeeking ::
+    (MonadIO m) =>
+    Query                                   -- _obj
+    -> m (Format,Bool,Int64,Int64)          -- result
+queryParseSeeking _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    format <- allocMem :: IO (Ptr CUInt)
+    seekable <- allocMem :: IO (Ptr CInt)
+    segmentStart <- allocMem :: IO (Ptr Int64)
+    segmentEnd <- allocMem :: IO (Ptr Int64)
+    gst_query_parse_seeking _obj' format seekable segmentStart segmentEnd
+    format' <- peek format
+    let format'' = (toEnum . fromIntegral) format'
+    seekable' <- peek seekable
+    let seekable'' = (/= 0) seekable'
+    segmentStart' <- peek segmentStart
+    segmentEnd' <- peek segmentEnd
+    touchManagedPtr _obj
+    freeMem format
+    freeMem seekable
+    freeMem segmentStart
+    freeMem segmentEnd
+    return (format'', seekable'', segmentStart', segmentEnd')
+
+data QueryParseSeekingMethodInfo
+instance (signature ~ (m (Format,Bool,Int64,Int64)), MonadIO m) => MethodInfo QueryParseSeekingMethodInfo Query signature where
+    overloadedMethod _ = queryParseSeeking
+
+-- method Query::parse_segment
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "rate", argType = TBasicType TDouble, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "start_value", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "stop_value", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_query_parse_segment" gst_query_parse_segment :: 
+    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"
+    Ptr CDouble ->                          -- rate : TBasicType TDouble
+    Ptr CUInt ->                            -- format : TInterface "Gst" "Format"
+    Ptr Int64 ->                            -- start_value : TBasicType TInt64
+    Ptr Int64 ->                            -- stop_value : TBasicType TInt64
+    IO ()
+
+
+queryParseSegment ::
+    (MonadIO m) =>
+    Query                                   -- _obj
+    -> m (Double,Format,Int64,Int64)        -- result
+queryParseSegment _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    rate <- allocMem :: IO (Ptr CDouble)
+    format <- allocMem :: IO (Ptr CUInt)
+    startValue <- allocMem :: IO (Ptr Int64)
+    stopValue <- allocMem :: IO (Ptr Int64)
+    gst_query_parse_segment _obj' rate format startValue stopValue
+    rate' <- peek rate
+    let rate'' = realToFrac rate'
+    format' <- peek format
+    let format'' = (toEnum . fromIntegral) format'
+    startValue' <- peek startValue
+    stopValue' <- peek stopValue
+    touchManagedPtr _obj
+    freeMem rate
+    freeMem format
+    freeMem startValue
+    freeMem stopValue
+    return (rate'', format'', startValue', stopValue')
+
+data QueryParseSegmentMethodInfo
+instance (signature ~ (m (Double,Format,Int64,Int64)), MonadIO m) => MethodInfo QueryParseSegmentMethodInfo Query signature where
+    overloadedMethod _ = queryParseSegment
+
+-- method Query::parse_uri
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "uri", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_query_parse_uri" gst_query_parse_uri :: 
+    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"
+    Ptr CString ->                          -- uri : TBasicType TUTF8
+    IO ()
+
+
+queryParseUri ::
+    (MonadIO m) =>
+    Query                                   -- _obj
+    -> m (T.Text)                           -- result
+queryParseUri _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    uri <- allocMem :: IO (Ptr CString)
+    gst_query_parse_uri _obj' uri
+    uri' <- peek uri
+    uri'' <- cstringToText uri'
+    freeMem uri'
+    touchManagedPtr _obj
+    freeMem uri
+    return uri''
+
+data QueryParseUriMethodInfo
+instance (signature ~ (m (T.Text)), MonadIO m) => MethodInfo QueryParseUriMethodInfo Query signature where
+    overloadedMethod _ = queryParseUri
+
+-- method Query::parse_uri_redirection
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "uri", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_query_parse_uri_redirection" gst_query_parse_uri_redirection :: 
+    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"
+    Ptr CString ->                          -- uri : TBasicType TUTF8
+    IO ()
+
+
+queryParseUriRedirection ::
+    (MonadIO m) =>
+    Query                                   -- _obj
+    -> m (T.Text)                           -- result
+queryParseUriRedirection _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    uri <- allocMem :: IO (Ptr CString)
+    gst_query_parse_uri_redirection _obj' uri
+    uri' <- peek uri
+    uri'' <- cstringToText uri'
+    freeMem uri'
+    touchManagedPtr _obj
+    freeMem uri
+    return uri''
+
+data QueryParseUriRedirectionMethodInfo
+instance (signature ~ (m (T.Text)), MonadIO m) => MethodInfo QueryParseUriRedirectionMethodInfo Query signature where
+    overloadedMethod _ = queryParseUriRedirection
+
+-- method Query::parse_uri_redirection_permanent
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "permanent", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_query_parse_uri_redirection_permanent" gst_query_parse_uri_redirection_permanent :: 
+    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"
+    Ptr CInt ->                             -- permanent : TBasicType TBoolean
+    IO ()
+
+
+queryParseUriRedirectionPermanent ::
+    (MonadIO m) =>
+    Query                                   -- _obj
+    -> m (Bool)                             -- result
+queryParseUriRedirectionPermanent _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    permanent <- allocMem :: IO (Ptr CInt)
+    gst_query_parse_uri_redirection_permanent _obj' permanent
+    permanent' <- peek permanent
+    let permanent'' = (/= 0) permanent'
+    touchManagedPtr _obj
+    freeMem permanent
+    return permanent''
+
+data QueryParseUriRedirectionPermanentMethodInfo
+instance (signature ~ (m (Bool)), MonadIO m) => MethodInfo QueryParseUriRedirectionPermanentMethodInfo Query signature where
+    overloadedMethod _ = queryParseUriRedirectionPermanent
+
+-- method Query::remove_nth_allocation_meta
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_query_remove_nth_allocation_meta" gst_query_remove_nth_allocation_meta :: 
+    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"
+    Word32 ->                               -- index : TBasicType TUInt32
+    IO ()
+
+
+queryRemoveNthAllocationMeta ::
+    (MonadIO m) =>
+    Query                                   -- _obj
+    -> Word32                               -- index
+    -> m ()                                 -- result
+queryRemoveNthAllocationMeta _obj index = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    gst_query_remove_nth_allocation_meta _obj' index
+    touchManagedPtr _obj
+    return ()
+
+data QueryRemoveNthAllocationMetaMethodInfo
+instance (signature ~ (Word32 -> m ()), MonadIO m) => MethodInfo QueryRemoveNthAllocationMetaMethodInfo Query signature where
+    overloadedMethod _ = queryRemoveNthAllocationMeta
+
+-- method Query::remove_nth_allocation_param
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_query_remove_nth_allocation_param" gst_query_remove_nth_allocation_param :: 
+    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"
+    Word32 ->                               -- index : TBasicType TUInt32
+    IO ()
+
+
+queryRemoveNthAllocationParam ::
+    (MonadIO m) =>
+    Query                                   -- _obj
+    -> Word32                               -- index
+    -> m ()                                 -- result
+queryRemoveNthAllocationParam _obj index = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    gst_query_remove_nth_allocation_param _obj' index
+    touchManagedPtr _obj
+    return ()
+
+data QueryRemoveNthAllocationParamMethodInfo
+instance (signature ~ (Word32 -> m ()), MonadIO m) => MethodInfo QueryRemoveNthAllocationParamMethodInfo Query signature where
+    overloadedMethod _ = queryRemoveNthAllocationParam
+
+-- method Query::remove_nth_allocation_pool
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_query_remove_nth_allocation_pool" gst_query_remove_nth_allocation_pool :: 
+    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"
+    Word32 ->                               -- index : TBasicType TUInt32
+    IO ()
+
+
+queryRemoveNthAllocationPool ::
+    (MonadIO m) =>
+    Query                                   -- _obj
+    -> Word32                               -- index
+    -> m ()                                 -- result
+queryRemoveNthAllocationPool _obj index = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    gst_query_remove_nth_allocation_pool _obj' index
+    touchManagedPtr _obj
+    return ()
+
+data QueryRemoveNthAllocationPoolMethodInfo
+instance (signature ~ (Word32 -> m ()), MonadIO m) => MethodInfo QueryRemoveNthAllocationPoolMethodInfo Query signature where
+    overloadedMethod _ = queryRemoveNthAllocationPool
+
+-- method Query::set_accept_caps_result
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_query_set_accept_caps_result" gst_query_set_accept_caps_result :: 
+    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"
+    CInt ->                                 -- result : TBasicType TBoolean
+    IO ()
+
+
+querySetAcceptCapsResult ::
+    (MonadIO m) =>
+    Query                                   -- _obj
+    -> Bool                                 -- result_
+    -> m ()                                 -- result
+querySetAcceptCapsResult _obj result_ = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let result_' = (fromIntegral . fromEnum) result_
+    gst_query_set_accept_caps_result _obj' result_'
+    touchManagedPtr _obj
+    return ()
+
+data QuerySetAcceptCapsResultMethodInfo
+instance (signature ~ (Bool -> m ()), MonadIO m) => MethodInfo QuerySetAcceptCapsResultMethodInfo Query signature where
+    overloadedMethod _ = querySetAcceptCapsResult
+
+-- method Query::set_buffering_percent
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "busy", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "percent", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_query_set_buffering_percent" gst_query_set_buffering_percent :: 
+    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"
+    CInt ->                                 -- busy : TBasicType TBoolean
+    Int32 ->                                -- percent : TBasicType TInt32
+    IO ()
+
+
+querySetBufferingPercent ::
+    (MonadIO m) =>
+    Query                                   -- _obj
+    -> Bool                                 -- busy
+    -> Int32                                -- percent
+    -> m ()                                 -- result
+querySetBufferingPercent _obj busy percent = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let busy' = (fromIntegral . fromEnum) busy
+    gst_query_set_buffering_percent _obj' busy' percent
+    touchManagedPtr _obj
+    return ()
+
+data QuerySetBufferingPercentMethodInfo
+instance (signature ~ (Bool -> Int32 -> m ()), MonadIO m) => MethodInfo QuerySetBufferingPercentMethodInfo Query signature where
+    overloadedMethod _ = querySetBufferingPercent
+
+-- method Query::set_buffering_range
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stop", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "estimated_total", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_query_set_buffering_range" gst_query_set_buffering_range :: 
+    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"
+    CUInt ->                                -- format : TInterface "Gst" "Format"
+    Int64 ->                                -- start : TBasicType TInt64
+    Int64 ->                                -- stop : TBasicType TInt64
+    Int64 ->                                -- estimated_total : TBasicType TInt64
+    IO ()
+
+
+querySetBufferingRange ::
+    (MonadIO m) =>
+    Query                                   -- _obj
+    -> Format                               -- format
+    -> Int64                                -- start
+    -> Int64                                -- stop
+    -> Int64                                -- estimatedTotal
+    -> m ()                                 -- result
+querySetBufferingRange _obj format start stop estimatedTotal = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let format' = (fromIntegral . fromEnum) format
+    gst_query_set_buffering_range _obj' format' start stop estimatedTotal
+    touchManagedPtr _obj
+    return ()
+
+data QuerySetBufferingRangeMethodInfo
+instance (signature ~ (Format -> Int64 -> Int64 -> Int64 -> m ()), MonadIO m) => MethodInfo QuerySetBufferingRangeMethodInfo Query signature where
+    overloadedMethod _ = querySetBufferingRange
+
+-- method Query::set_buffering_stats
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mode", argType = TInterface "Gst" "BufferingMode", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "avg_in", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "avg_out", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "buffering_left", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_query_set_buffering_stats" gst_query_set_buffering_stats :: 
+    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"
+    CUInt ->                                -- mode : TInterface "Gst" "BufferingMode"
+    Int32 ->                                -- avg_in : TBasicType TInt32
+    Int32 ->                                -- avg_out : TBasicType TInt32
+    Int64 ->                                -- buffering_left : TBasicType TInt64
+    IO ()
+
+
+querySetBufferingStats ::
+    (MonadIO m) =>
+    Query                                   -- _obj
+    -> BufferingMode                        -- mode
+    -> Int32                                -- avgIn
+    -> Int32                                -- avgOut
+    -> Int64                                -- bufferingLeft
+    -> m ()                                 -- result
+querySetBufferingStats _obj mode avgIn avgOut bufferingLeft = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let mode' = (fromIntegral . fromEnum) mode
+    gst_query_set_buffering_stats _obj' mode' avgIn avgOut bufferingLeft
+    touchManagedPtr _obj
+    return ()
+
+data QuerySetBufferingStatsMethodInfo
+instance (signature ~ (BufferingMode -> Int32 -> Int32 -> Int64 -> m ()), MonadIO m) => MethodInfo QuerySetBufferingStatsMethodInfo Query signature where
+    overloadedMethod _ = querySetBufferingStats
+
+-- method Query::set_caps_result
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_query_set_caps_result" gst_query_set_caps_result :: 
+    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"
+    Ptr Caps ->                             -- caps : TInterface "Gst" "Caps"
+    IO ()
+
+
+querySetCapsResult ::
+    (MonadIO m) =>
+    Query                                   -- _obj
+    -> Caps                                 -- caps
+    -> m ()                                 -- result
+querySetCapsResult _obj caps = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let caps' = unsafeManagedPtrGetPtr caps
+    gst_query_set_caps_result _obj' caps'
+    touchManagedPtr _obj
+    touchManagedPtr caps
+    return ()
+
+data QuerySetCapsResultMethodInfo
+instance (signature ~ (Caps -> m ()), MonadIO m) => MethodInfo QuerySetCapsResultMethodInfo Query signature where
+    overloadedMethod _ = querySetCapsResult
+
+-- method Query::set_context
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "context", argType = TInterface "Gst" "Context", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_query_set_context" gst_query_set_context :: 
+    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"
+    Ptr Context ->                          -- context : TInterface "Gst" "Context"
+    IO ()
+
+
+querySetContext ::
+    (MonadIO m) =>
+    Query                                   -- _obj
+    -> Context                              -- context
+    -> m ()                                 -- result
+querySetContext _obj context = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let context' = unsafeManagedPtrGetPtr context
+    gst_query_set_context _obj' context'
+    touchManagedPtr _obj
+    touchManagedPtr context
+    return ()
+
+data QuerySetContextMethodInfo
+instance (signature ~ (Context -> m ()), MonadIO m) => MethodInfo QuerySetContextMethodInfo Query signature where
+    overloadedMethod _ = querySetContext
+
+-- method Query::set_convert
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "src_format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "src_value", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest_format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest_value", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_query_set_convert" gst_query_set_convert :: 
+    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"
+    CUInt ->                                -- src_format : TInterface "Gst" "Format"
+    Int64 ->                                -- src_value : TBasicType TInt64
+    CUInt ->                                -- dest_format : TInterface "Gst" "Format"
+    Int64 ->                                -- dest_value : TBasicType TInt64
+    IO ()
+
+
+querySetConvert ::
+    (MonadIO m) =>
+    Query                                   -- _obj
+    -> Format                               -- srcFormat
+    -> Int64                                -- srcValue
+    -> Format                               -- destFormat
+    -> Int64                                -- destValue
+    -> m ()                                 -- result
+querySetConvert _obj srcFormat srcValue destFormat destValue = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let srcFormat' = (fromIntegral . fromEnum) srcFormat
+    let destFormat' = (fromIntegral . fromEnum) destFormat
+    gst_query_set_convert _obj' srcFormat' srcValue destFormat' destValue
+    touchManagedPtr _obj
+    return ()
+
+data QuerySetConvertMethodInfo
+instance (signature ~ (Format -> Int64 -> Format -> Int64 -> m ()), MonadIO m) => MethodInfo QuerySetConvertMethodInfo Query signature where
+    overloadedMethod _ = querySetConvert
+
+-- method Query::set_duration
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "duration", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_query_set_duration" gst_query_set_duration :: 
+    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"
+    CUInt ->                                -- format : TInterface "Gst" "Format"
+    Int64 ->                                -- duration : TBasicType TInt64
+    IO ()
+
+
+querySetDuration ::
+    (MonadIO m) =>
+    Query                                   -- _obj
+    -> Format                               -- format
+    -> Int64                                -- duration
+    -> m ()                                 -- result
+querySetDuration _obj format duration = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let format' = (fromIntegral . fromEnum) format
+    gst_query_set_duration _obj' format' duration
+    touchManagedPtr _obj
+    return ()
+
+data QuerySetDurationMethodInfo
+instance (signature ~ (Format -> Int64 -> m ()), MonadIO m) => MethodInfo QuerySetDurationMethodInfo Query signature where
+    overloadedMethod _ = querySetDuration
+
+-- method Query::set_formatsv
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "n_formats", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "formats", argType = TCArray False (-1) 1 (TInterface "Gst" "Format"), direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : [Arg {argCName = "n_formats", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_query_set_formatsv" gst_query_set_formatsv :: 
+    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"
+    Int32 ->                                -- n_formats : TBasicType TInt32
+    Ptr CUInt ->                            -- formats : TCArray False (-1) 1 (TInterface "Gst" "Format")
+    IO ()
+
+
+querySetFormatsv ::
+    (MonadIO m) =>
+    Query                                   -- _obj
+    -> [Format]                             -- formats
+    -> m ()                                 -- result
+querySetFormatsv _obj formats = liftIO $ do
+    let nFormats = fromIntegral $ length formats
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let formats' = map (fromIntegral . fromEnum) formats
+    formats'' <- packStorableArray formats'
+    gst_query_set_formatsv _obj' nFormats formats''
+    touchManagedPtr _obj
+    freeMem formats''
+    return ()
+
+data QuerySetFormatsvMethodInfo
+instance (signature ~ ([Format] -> m ()), MonadIO m) => MethodInfo QuerySetFormatsvMethodInfo Query signature where
+    overloadedMethod _ = querySetFormatsv
+
+-- method Query::set_latency
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "live", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "min_latency", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "max_latency", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_query_set_latency" gst_query_set_latency :: 
+    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"
+    CInt ->                                 -- live : TBasicType TBoolean
+    Word64 ->                               -- min_latency : TBasicType TUInt64
+    Word64 ->                               -- max_latency : TBasicType TUInt64
+    IO ()
+
+
+querySetLatency ::
+    (MonadIO m) =>
+    Query                                   -- _obj
+    -> Bool                                 -- live
+    -> Word64                               -- minLatency
+    -> Word64                               -- maxLatency
+    -> m ()                                 -- result
+querySetLatency _obj live minLatency maxLatency = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let live' = (fromIntegral . fromEnum) live
+    gst_query_set_latency _obj' live' minLatency maxLatency
+    touchManagedPtr _obj
+    return ()
+
+data QuerySetLatencyMethodInfo
+instance (signature ~ (Bool -> Word64 -> Word64 -> m ()), MonadIO m) => MethodInfo QuerySetLatencyMethodInfo Query signature where
+    overloadedMethod _ = querySetLatency
+
+-- method Query::set_nth_allocation_param
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "allocator", argType = TInterface "Gst" "Allocator", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "params", argType = TInterface "Gst" "AllocationParams", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_query_set_nth_allocation_param" gst_query_set_nth_allocation_param :: 
+    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"
+    Word32 ->                               -- index : TBasicType TUInt32
+    Ptr Allocator ->                        -- allocator : TInterface "Gst" "Allocator"
+    Ptr AllocationParams ->                 -- params : TInterface "Gst" "AllocationParams"
+    IO ()
+
+
+querySetNthAllocationParam ::
+    (MonadIO m, AllocatorK a) =>
+    Query                                   -- _obj
+    -> Word32                               -- index
+    -> Maybe (a)                            -- allocator
+    -> Maybe (AllocationParams)             -- params
+    -> m ()                                 -- result
+querySetNthAllocationParam _obj index allocator params = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    maybeAllocator <- case allocator of
+        Nothing -> return nullPtr
+        Just jAllocator -> do
+            let jAllocator' = unsafeManagedPtrCastPtr jAllocator
+            return jAllocator'
+    maybeParams <- case params of
+        Nothing -> return nullPtr
+        Just jParams -> do
+            let jParams' = unsafeManagedPtrGetPtr jParams
+            return jParams'
+    gst_query_set_nth_allocation_param _obj' index maybeAllocator maybeParams
+    touchManagedPtr _obj
+    whenJust allocator touchManagedPtr
+    whenJust params touchManagedPtr
+    return ()
+
+data QuerySetNthAllocationParamMethodInfo
+instance (signature ~ (Word32 -> Maybe (a) -> Maybe (AllocationParams) -> m ()), MonadIO m, AllocatorK a) => MethodInfo QuerySetNthAllocationParamMethodInfo Query signature where
+    overloadedMethod _ = querySetNthAllocationParam
+
+-- method Query::set_nth_allocation_pool
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "pool", argType = TInterface "Gst" "BufferPool", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "min_buffers", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "max_buffers", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_query_set_nth_allocation_pool" gst_query_set_nth_allocation_pool :: 
+    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"
+    Word32 ->                               -- index : TBasicType TUInt32
+    Ptr BufferPool ->                       -- pool : TInterface "Gst" "BufferPool"
+    Word32 ->                               -- size : TBasicType TUInt32
+    Word32 ->                               -- min_buffers : TBasicType TUInt32
+    Word32 ->                               -- max_buffers : TBasicType TUInt32
+    IO ()
+
+
+querySetNthAllocationPool ::
+    (MonadIO m, BufferPoolK a) =>
+    Query                                   -- _obj
+    -> Word32                               -- index
+    -> Maybe (a)                            -- pool
+    -> Word32                               -- size
+    -> Word32                               -- minBuffers
+    -> Word32                               -- maxBuffers
+    -> m ()                                 -- result
+querySetNthAllocationPool _obj index pool size minBuffers maxBuffers = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    maybePool <- case pool of
+        Nothing -> return nullPtr
+        Just jPool -> do
+            let jPool' = unsafeManagedPtrCastPtr jPool
+            return jPool'
+    gst_query_set_nth_allocation_pool _obj' index maybePool size minBuffers maxBuffers
+    touchManagedPtr _obj
+    whenJust pool touchManagedPtr
+    return ()
+
+data QuerySetNthAllocationPoolMethodInfo
+instance (signature ~ (Word32 -> Maybe (a) -> Word32 -> Word32 -> Word32 -> m ()), MonadIO m, BufferPoolK a) => MethodInfo QuerySetNthAllocationPoolMethodInfo Query signature where
+    overloadedMethod _ = querySetNthAllocationPool
+
+-- method Query::set_position
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cur", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_query_set_position" gst_query_set_position :: 
+    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"
+    CUInt ->                                -- format : TInterface "Gst" "Format"
+    Int64 ->                                -- cur : TBasicType TInt64
+    IO ()
+
+
+querySetPosition ::
+    (MonadIO m) =>
+    Query                                   -- _obj
+    -> Format                               -- format
+    -> Int64                                -- cur
+    -> m ()                                 -- result
+querySetPosition _obj format cur = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let format' = (fromIntegral . fromEnum) format
+    gst_query_set_position _obj' format' cur
+    touchManagedPtr _obj
+    return ()
+
+data QuerySetPositionMethodInfo
+instance (signature ~ (Format -> Int64 -> m ()), MonadIO m) => MethodInfo QuerySetPositionMethodInfo Query signature where
+    overloadedMethod _ = querySetPosition
+
+-- method Query::set_scheduling
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface "Gst" "SchedulingFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "minsize", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "maxsize", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "align", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_query_set_scheduling" gst_query_set_scheduling :: 
+    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"
+    CUInt ->                                -- flags : TInterface "Gst" "SchedulingFlags"
+    Int32 ->                                -- minsize : TBasicType TInt32
+    Int32 ->                                -- maxsize : TBasicType TInt32
+    Int32 ->                                -- align : TBasicType TInt32
+    IO ()
+
+
+querySetScheduling ::
+    (MonadIO m) =>
+    Query                                   -- _obj
+    -> [SchedulingFlags]                    -- flags
+    -> Int32                                -- minsize
+    -> Int32                                -- maxsize
+    -> Int32                                -- align
+    -> m ()                                 -- result
+querySetScheduling _obj flags minsize maxsize align = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let flags' = gflagsToWord flags
+    gst_query_set_scheduling _obj' flags' minsize maxsize align
+    touchManagedPtr _obj
+    return ()
+
+data QuerySetSchedulingMethodInfo
+instance (signature ~ ([SchedulingFlags] -> Int32 -> Int32 -> Int32 -> m ()), MonadIO m) => MethodInfo QuerySetSchedulingMethodInfo Query signature where
+    overloadedMethod _ = querySetScheduling
+
+-- method Query::set_seeking
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "seekable", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "segment_start", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "segment_end", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_query_set_seeking" gst_query_set_seeking :: 
+    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"
+    CUInt ->                                -- format : TInterface "Gst" "Format"
+    CInt ->                                 -- seekable : TBasicType TBoolean
+    Int64 ->                                -- segment_start : TBasicType TInt64
+    Int64 ->                                -- segment_end : TBasicType TInt64
+    IO ()
+
+
+querySetSeeking ::
+    (MonadIO m) =>
+    Query                                   -- _obj
+    -> Format                               -- format
+    -> Bool                                 -- seekable
+    -> Int64                                -- segmentStart
+    -> Int64                                -- segmentEnd
+    -> m ()                                 -- result
+querySetSeeking _obj format seekable segmentStart segmentEnd = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let format' = (fromIntegral . fromEnum) format
+    let seekable' = (fromIntegral . fromEnum) seekable
+    gst_query_set_seeking _obj' format' seekable' segmentStart segmentEnd
+    touchManagedPtr _obj
+    return ()
+
+data QuerySetSeekingMethodInfo
+instance (signature ~ (Format -> Bool -> Int64 -> Int64 -> m ()), MonadIO m) => MethodInfo QuerySetSeekingMethodInfo Query signature where
+    overloadedMethod _ = querySetSeeking
+
+-- method Query::set_segment
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "rate", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start_value", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stop_value", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_query_set_segment" gst_query_set_segment :: 
+    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"
+    CDouble ->                              -- rate : TBasicType TDouble
+    CUInt ->                                -- format : TInterface "Gst" "Format"
+    Int64 ->                                -- start_value : TBasicType TInt64
+    Int64 ->                                -- stop_value : TBasicType TInt64
+    IO ()
+
+
+querySetSegment ::
+    (MonadIO m) =>
+    Query                                   -- _obj
+    -> Double                               -- rate
+    -> Format                               -- format
+    -> Int64                                -- startValue
+    -> Int64                                -- stopValue
+    -> m ()                                 -- result
+querySetSegment _obj rate format startValue stopValue = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let rate' = realToFrac rate
+    let format' = (fromIntegral . fromEnum) format
+    gst_query_set_segment _obj' rate' format' startValue stopValue
+    touchManagedPtr _obj
+    return ()
+
+data QuerySetSegmentMethodInfo
+instance (signature ~ (Double -> Format -> Int64 -> Int64 -> m ()), MonadIO m) => MethodInfo QuerySetSegmentMethodInfo Query signature where
+    overloadedMethod _ = querySetSegment
+
+-- method Query::set_uri
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_query_set_uri" gst_query_set_uri :: 
+    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"
+    CString ->                              -- uri : TBasicType TUTF8
+    IO ()
+
+
+querySetUri ::
+    (MonadIO m) =>
+    Query                                   -- _obj
+    -> T.Text                               -- uri
+    -> m ()                                 -- result
+querySetUri _obj uri = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    uri' <- textToCString uri
+    gst_query_set_uri _obj' uri'
+    touchManagedPtr _obj
+    freeMem uri'
+    return ()
+
+data QuerySetUriMethodInfo
+instance (signature ~ (T.Text -> m ()), MonadIO m) => MethodInfo QuerySetUriMethodInfo Query signature where
+    overloadedMethod _ = querySetUri
+
+-- method Query::set_uri_redirection
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_query_set_uri_redirection" gst_query_set_uri_redirection :: 
+    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"
+    CString ->                              -- uri : TBasicType TUTF8
+    IO ()
+
+
+querySetUriRedirection ::
+    (MonadIO m) =>
+    Query                                   -- _obj
+    -> T.Text                               -- uri
+    -> m ()                                 -- result
+querySetUriRedirection _obj uri = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    uri' <- textToCString uri
+    gst_query_set_uri_redirection _obj' uri'
+    touchManagedPtr _obj
+    freeMem uri'
+    return ()
+
+data QuerySetUriRedirectionMethodInfo
+instance (signature ~ (T.Text -> m ()), MonadIO m) => MethodInfo QuerySetUriRedirectionMethodInfo Query signature where
+    overloadedMethod _ = querySetUriRedirection
+
+-- method Query::set_uri_redirection_permanent
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "permanent", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_query_set_uri_redirection_permanent" gst_query_set_uri_redirection_permanent :: 
+    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"
+    CInt ->                                 -- permanent : TBasicType TBoolean
+    IO ()
+
+
+querySetUriRedirectionPermanent ::
+    (MonadIO m) =>
+    Query                                   -- _obj
+    -> Bool                                 -- permanent
+    -> m ()                                 -- result
+querySetUriRedirectionPermanent _obj permanent = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let permanent' = (fromIntegral . fromEnum) permanent
+    gst_query_set_uri_redirection_permanent _obj' permanent'
+    touchManagedPtr _obj
+    return ()
+
+data QuerySetUriRedirectionPermanentMethodInfo
+instance (signature ~ (Bool -> m ()), MonadIO m) => MethodInfo QuerySetUriRedirectionPermanentMethodInfo Query signature where
+    overloadedMethod _ = querySetUriRedirectionPermanent
+
+-- method Query::writable_structure
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Query", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Structure"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_query_writable_structure" gst_query_writable_structure :: 
+    Ptr Query ->                            -- _obj : TInterface "Gst" "Query"
+    IO (Ptr Structure)
+
+
+queryWritableStructure ::
+    (MonadIO m) =>
+    Query                                   -- _obj
+    -> m Structure                          -- result
+queryWritableStructure _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_query_writable_structure _obj'
+    checkUnexpectedReturnNULL "gst_query_writable_structure" result
+    result' <- (newBoxed Structure) result
+    touchManagedPtr _obj
+    return result'
+
+data QueryWritableStructureMethodInfo
+instance (signature ~ (m Structure), MonadIO m) => MethodInfo QueryWritableStructureMethodInfo Query signature where
+    overloadedMethod _ = queryWritableStructure
+
+type family ResolveQueryMethod (t :: Symbol) (o :: *) :: * where
+    ResolveQueryMethod "addAllocationMeta" o = QueryAddAllocationMetaMethodInfo
+    ResolveQueryMethod "addAllocationParam" o = QueryAddAllocationParamMethodInfo
+    ResolveQueryMethod "addAllocationPool" o = QueryAddAllocationPoolMethodInfo
+    ResolveQueryMethod "addBufferingRange" o = QueryAddBufferingRangeMethodInfo
+    ResolveQueryMethod "addSchedulingMode" o = QueryAddSchedulingModeMethodInfo
+    ResolveQueryMethod "findAllocationMeta" o = QueryFindAllocationMetaMethodInfo
+    ResolveQueryMethod "hasSchedulingMode" o = QueryHasSchedulingModeMethodInfo
+    ResolveQueryMethod "hasSchedulingModeWithFlags" o = QueryHasSchedulingModeWithFlagsMethodInfo
+    ResolveQueryMethod "parseAcceptCaps" o = QueryParseAcceptCapsMethodInfo
+    ResolveQueryMethod "parseAcceptCapsResult" o = QueryParseAcceptCapsResultMethodInfo
+    ResolveQueryMethod "parseAllocation" o = QueryParseAllocationMethodInfo
+    ResolveQueryMethod "parseBufferingPercent" o = QueryParseBufferingPercentMethodInfo
+    ResolveQueryMethod "parseBufferingRange" o = QueryParseBufferingRangeMethodInfo
+    ResolveQueryMethod "parseBufferingStats" o = QueryParseBufferingStatsMethodInfo
+    ResolveQueryMethod "parseCaps" o = QueryParseCapsMethodInfo
+    ResolveQueryMethod "parseCapsResult" o = QueryParseCapsResultMethodInfo
+    ResolveQueryMethod "parseContext" o = QueryParseContextMethodInfo
+    ResolveQueryMethod "parseContextType" o = QueryParseContextTypeMethodInfo
+    ResolveQueryMethod "parseConvert" o = QueryParseConvertMethodInfo
+    ResolveQueryMethod "parseDuration" o = QueryParseDurationMethodInfo
+    ResolveQueryMethod "parseLatency" o = QueryParseLatencyMethodInfo
+    ResolveQueryMethod "parseNFormats" o = QueryParseNFormatsMethodInfo
+    ResolveQueryMethod "parseNthAllocationMeta" o = QueryParseNthAllocationMetaMethodInfo
+    ResolveQueryMethod "parseNthAllocationParam" o = QueryParseNthAllocationParamMethodInfo
+    ResolveQueryMethod "parseNthAllocationPool" o = QueryParseNthAllocationPoolMethodInfo
+    ResolveQueryMethod "parseNthBufferingRange" o = QueryParseNthBufferingRangeMethodInfo
+    ResolveQueryMethod "parseNthFormat" o = QueryParseNthFormatMethodInfo
+    ResolveQueryMethod "parseNthSchedulingMode" o = QueryParseNthSchedulingModeMethodInfo
+    ResolveQueryMethod "parsePosition" o = QueryParsePositionMethodInfo
+    ResolveQueryMethod "parseScheduling" o = QueryParseSchedulingMethodInfo
+    ResolveQueryMethod "parseSeeking" o = QueryParseSeekingMethodInfo
+    ResolveQueryMethod "parseSegment" o = QueryParseSegmentMethodInfo
+    ResolveQueryMethod "parseUri" o = QueryParseUriMethodInfo
+    ResolveQueryMethod "parseUriRedirection" o = QueryParseUriRedirectionMethodInfo
+    ResolveQueryMethod "parseUriRedirectionPermanent" o = QueryParseUriRedirectionPermanentMethodInfo
+    ResolveQueryMethod "removeNthAllocationMeta" o = QueryRemoveNthAllocationMetaMethodInfo
+    ResolveQueryMethod "removeNthAllocationParam" o = QueryRemoveNthAllocationParamMethodInfo
+    ResolveQueryMethod "removeNthAllocationPool" o = QueryRemoveNthAllocationPoolMethodInfo
+    ResolveQueryMethod "writableStructure" o = QueryWritableStructureMethodInfo
+    ResolveQueryMethod "getNAllocationMetas" o = QueryGetNAllocationMetasMethodInfo
+    ResolveQueryMethod "getNAllocationParams" o = QueryGetNAllocationParamsMethodInfo
+    ResolveQueryMethod "getNAllocationPools" o = QueryGetNAllocationPoolsMethodInfo
+    ResolveQueryMethod "getNBufferingRanges" o = QueryGetNBufferingRangesMethodInfo
+    ResolveQueryMethod "getNSchedulingModes" o = QueryGetNSchedulingModesMethodInfo
+    ResolveQueryMethod "getStructure" o = QueryGetStructureMethodInfo
+    ResolveQueryMethod "setAcceptCapsResult" o = QuerySetAcceptCapsResultMethodInfo
+    ResolveQueryMethod "setBufferingPercent" o = QuerySetBufferingPercentMethodInfo
+    ResolveQueryMethod "setBufferingRange" o = QuerySetBufferingRangeMethodInfo
+    ResolveQueryMethod "setBufferingStats" o = QuerySetBufferingStatsMethodInfo
+    ResolveQueryMethod "setCapsResult" o = QuerySetCapsResultMethodInfo
+    ResolveQueryMethod "setContext" o = QuerySetContextMethodInfo
+    ResolveQueryMethod "setConvert" o = QuerySetConvertMethodInfo
+    ResolveQueryMethod "setDuration" o = QuerySetDurationMethodInfo
+    ResolveQueryMethod "setFormatsv" o = QuerySetFormatsvMethodInfo
+    ResolveQueryMethod "setLatency" o = QuerySetLatencyMethodInfo
+    ResolveQueryMethod "setNthAllocationParam" o = QuerySetNthAllocationParamMethodInfo
+    ResolveQueryMethod "setNthAllocationPool" o = QuerySetNthAllocationPoolMethodInfo
+    ResolveQueryMethod "setPosition" o = QuerySetPositionMethodInfo
+    ResolveQueryMethod "setScheduling" o = QuerySetSchedulingMethodInfo
+    ResolveQueryMethod "setSeeking" o = QuerySetSeekingMethodInfo
+    ResolveQueryMethod "setSegment" o = QuerySetSegmentMethodInfo
+    ResolveQueryMethod "setUri" o = QuerySetUriMethodInfo
+    ResolveQueryMethod "setUriRedirection" o = QuerySetUriRedirectionMethodInfo
+    ResolveQueryMethod "setUriRedirectionPermanent" o = QuerySetUriRedirectionPermanentMethodInfo
+    ResolveQueryMethod l o = MethodResolutionFailed l o
+
+instance (info ~ ResolveQueryMethod t Query, MethodInfo info Query p) => IsLabelProxy t (Query -> p) where
+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)
+
+#if MIN_VERSION_base(4,9,0)
+instance (info ~ ResolveQueryMethod t Query, MethodInfo info Query p) => IsLabel t (Query -> p) where
+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)
+#endif
+
+
diff --git a/GI/Gst/Structs/Query.hs-boot b/GI/Gst/Structs/Query.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/Query.hs-boot
@@ -0,0 +1,75 @@
+module GI.Gst.Structs.Query where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+newtype Query = Query (ForeignPtr Query)
+instance BoxedObject Query where
+data QueryAddAllocationMetaMethodInfo
+data QueryAddAllocationParamMethodInfo
+data QueryAddAllocationPoolMethodInfo
+data QueryAddBufferingRangeMethodInfo
+data QueryAddSchedulingModeMethodInfo
+data QueryFindAllocationMetaMethodInfo
+data QueryGetNAllocationMetasMethodInfo
+data QueryGetNAllocationParamsMethodInfo
+data QueryGetNAllocationPoolsMethodInfo
+data QueryGetNBufferingRangesMethodInfo
+data QueryGetNSchedulingModesMethodInfo
+data QueryGetStructureMethodInfo
+data QueryHasSchedulingModeMethodInfo
+data QueryHasSchedulingModeWithFlagsMethodInfo
+data QueryParseAcceptCapsMethodInfo
+data QueryParseAcceptCapsResultMethodInfo
+data QueryParseAllocationMethodInfo
+data QueryParseBufferingPercentMethodInfo
+data QueryParseBufferingRangeMethodInfo
+data QueryParseBufferingStatsMethodInfo
+data QueryParseCapsMethodInfo
+data QueryParseCapsResultMethodInfo
+data QueryParseContextMethodInfo
+data QueryParseContextTypeMethodInfo
+data QueryParseConvertMethodInfo
+data QueryParseDurationMethodInfo
+data QueryParseLatencyMethodInfo
+data QueryParseNFormatsMethodInfo
+data QueryParseNthAllocationMetaMethodInfo
+data QueryParseNthAllocationParamMethodInfo
+data QueryParseNthAllocationPoolMethodInfo
+data QueryParseNthBufferingRangeMethodInfo
+data QueryParseNthFormatMethodInfo
+data QueryParseNthSchedulingModeMethodInfo
+data QueryParsePositionMethodInfo
+data QueryParseSchedulingMethodInfo
+data QueryParseSeekingMethodInfo
+data QueryParseSegmentMethodInfo
+data QueryParseUriMethodInfo
+data QueryParseUriRedirectionMethodInfo
+data QueryParseUriRedirectionPermanentMethodInfo
+data QueryRemoveNthAllocationMetaMethodInfo
+data QueryRemoveNthAllocationParamMethodInfo
+data QueryRemoveNthAllocationPoolMethodInfo
+data QuerySetAcceptCapsResultMethodInfo
+data QuerySetBufferingPercentMethodInfo
+data QuerySetBufferingRangeMethodInfo
+data QuerySetBufferingStatsMethodInfo
+data QuerySetCapsResultMethodInfo
+data QuerySetContextMethodInfo
+data QuerySetConvertMethodInfo
+data QuerySetDurationMethodInfo
+data QuerySetFormatsvMethodInfo
+data QuerySetLatencyMethodInfo
+data QuerySetNthAllocationParamMethodInfo
+data QuerySetNthAllocationPoolMethodInfo
+data QuerySetPositionMethodInfo
+data QuerySetSchedulingMethodInfo
+data QuerySetSeekingMethodInfo
+data QuerySetSegmentMethodInfo
+data QuerySetUriMethodInfo
+data QuerySetUriRedirectionMethodInfo
+data QuerySetUriRedirectionPermanentMethodInfo
+data QueryWritableStructureMethodInfo
diff --git a/GI/Gst/Structs/Sample.hs b/GI/Gst/Structs/Sample.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/Sample.hs
@@ -0,0 +1,325 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+
+A #GstSample is a small object containing data, a type, timing and
+extra arbitrary information.
+-}
+
+module GI.Gst.Structs.Sample
+    ( 
+
+-- * Exported types
+    Sample(..)                              ,
+    noSample                                ,
+
+
+ -- * Methods
+-- ** sampleGetBuffer
+    SampleGetBufferMethodInfo               ,
+    sampleGetBuffer                         ,
+
+
+-- ** sampleGetBufferList
+    SampleGetBufferListMethodInfo           ,
+    sampleGetBufferList                     ,
+
+
+-- ** sampleGetCaps
+    SampleGetCapsMethodInfo                 ,
+    sampleGetCaps                           ,
+
+
+-- ** sampleGetInfo
+    SampleGetInfoMethodInfo                 ,
+    sampleGetInfo                           ,
+
+
+-- ** sampleGetSegment
+    SampleGetSegmentMethodInfo              ,
+    sampleGetSegment                        ,
+
+
+-- ** sampleNew
+    sampleNew                               ,
+
+
+-- ** sampleSetBufferList
+    SampleSetBufferListMethodInfo           ,
+    sampleSetBufferList                     ,
+
+
+
+
+    ) where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+import GI.Gst.Callbacks
+
+newtype Sample = Sample (ForeignPtr Sample)
+foreign import ccall "gst_sample_get_type" c_gst_sample_get_type :: 
+    IO GType
+
+instance BoxedObject Sample where
+    boxedType _ = c_gst_sample_get_type
+
+noSample :: Maybe Sample
+noSample = Nothing
+
+-- method Sample::new
+-- method type : Constructor
+-- Args : [Arg {argCName = "buffer", argType = TInterface "Gst" "Buffer", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "segment", argType = TInterface "Gst" "Segment", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "info", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Sample"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_sample_new" gst_sample_new :: 
+    Ptr Buffer ->                           -- buffer : TInterface "Gst" "Buffer"
+    Ptr Caps ->                             -- caps : TInterface "Gst" "Caps"
+    Ptr Segment ->                          -- segment : TInterface "Gst" "Segment"
+    Ptr Structure ->                        -- info : TInterface "Gst" "Structure"
+    IO (Ptr Sample)
+
+
+sampleNew ::
+    (MonadIO m) =>
+    Maybe (Buffer)                          -- buffer
+    -> Maybe (Caps)                         -- caps
+    -> Maybe (Segment)                      -- segment
+    -> Maybe (Structure)                    -- info
+    -> m Sample                             -- result
+sampleNew buffer caps segment info = liftIO $ do
+    maybeBuffer <- case buffer of
+        Nothing -> return nullPtr
+        Just jBuffer -> do
+            let jBuffer' = unsafeManagedPtrGetPtr jBuffer
+            return jBuffer'
+    maybeCaps <- case caps of
+        Nothing -> return nullPtr
+        Just jCaps -> do
+            let jCaps' = unsafeManagedPtrGetPtr jCaps
+            return jCaps'
+    maybeSegment <- case segment of
+        Nothing -> return nullPtr
+        Just jSegment -> do
+            let jSegment' = unsafeManagedPtrGetPtr jSegment
+            return jSegment'
+    maybeInfo <- case info of
+        Nothing -> return nullPtr
+        Just jInfo -> do
+            jInfo' <- copyBoxed jInfo
+            return jInfo'
+    result <- gst_sample_new maybeBuffer maybeCaps maybeSegment maybeInfo
+    checkUnexpectedReturnNULL "gst_sample_new" result
+    result' <- (wrapBoxed Sample) result
+    whenJust buffer touchManagedPtr
+    whenJust caps touchManagedPtr
+    whenJust segment touchManagedPtr
+    whenJust info touchManagedPtr
+    return result'
+
+-- method Sample::get_buffer
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Sample", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Buffer"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_sample_get_buffer" gst_sample_get_buffer :: 
+    Ptr Sample ->                           -- _obj : TInterface "Gst" "Sample"
+    IO (Ptr Buffer)
+
+
+sampleGetBuffer ::
+    (MonadIO m) =>
+    Sample                                  -- _obj
+    -> m Buffer                             -- result
+sampleGetBuffer _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_sample_get_buffer _obj'
+    checkUnexpectedReturnNULL "gst_sample_get_buffer" result
+    result' <- (newBoxed Buffer) result
+    touchManagedPtr _obj
+    return result'
+
+data SampleGetBufferMethodInfo
+instance (signature ~ (m Buffer), MonadIO m) => MethodInfo SampleGetBufferMethodInfo Sample signature where
+    overloadedMethod _ = sampleGetBuffer
+
+-- method Sample::get_buffer_list
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Sample", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "BufferList"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_sample_get_buffer_list" gst_sample_get_buffer_list :: 
+    Ptr Sample ->                           -- _obj : TInterface "Gst" "Sample"
+    IO (Ptr BufferList)
+
+
+sampleGetBufferList ::
+    (MonadIO m) =>
+    Sample                                  -- _obj
+    -> m BufferList                         -- result
+sampleGetBufferList _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_sample_get_buffer_list _obj'
+    checkUnexpectedReturnNULL "gst_sample_get_buffer_list" result
+    result' <- (newBoxed BufferList) result
+    touchManagedPtr _obj
+    return result'
+
+data SampleGetBufferListMethodInfo
+instance (signature ~ (m BufferList), MonadIO m) => MethodInfo SampleGetBufferListMethodInfo Sample signature where
+    overloadedMethod _ = sampleGetBufferList
+
+-- method Sample::get_caps
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Sample", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Caps"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_sample_get_caps" gst_sample_get_caps :: 
+    Ptr Sample ->                           -- _obj : TInterface "Gst" "Sample"
+    IO (Ptr Caps)
+
+
+sampleGetCaps ::
+    (MonadIO m) =>
+    Sample                                  -- _obj
+    -> m Caps                               -- result
+sampleGetCaps _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_sample_get_caps _obj'
+    checkUnexpectedReturnNULL "gst_sample_get_caps" result
+    result' <- (newBoxed Caps) result
+    touchManagedPtr _obj
+    return result'
+
+data SampleGetCapsMethodInfo
+instance (signature ~ (m Caps), MonadIO m) => MethodInfo SampleGetCapsMethodInfo Sample signature where
+    overloadedMethod _ = sampleGetCaps
+
+-- method Sample::get_info
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Sample", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Structure"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_sample_get_info" gst_sample_get_info :: 
+    Ptr Sample ->                           -- _obj : TInterface "Gst" "Sample"
+    IO (Ptr Structure)
+
+
+sampleGetInfo ::
+    (MonadIO m) =>
+    Sample                                  -- _obj
+    -> m Structure                          -- result
+sampleGetInfo _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_sample_get_info _obj'
+    checkUnexpectedReturnNULL "gst_sample_get_info" result
+    result' <- (newBoxed Structure) result
+    touchManagedPtr _obj
+    return result'
+
+data SampleGetInfoMethodInfo
+instance (signature ~ (m Structure), MonadIO m) => MethodInfo SampleGetInfoMethodInfo Sample signature where
+    overloadedMethod _ = sampleGetInfo
+
+-- method Sample::get_segment
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Sample", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Segment"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_sample_get_segment" gst_sample_get_segment :: 
+    Ptr Sample ->                           -- _obj : TInterface "Gst" "Sample"
+    IO (Ptr Segment)
+
+
+sampleGetSegment ::
+    (MonadIO m) =>
+    Sample                                  -- _obj
+    -> m Segment                            -- result
+sampleGetSegment _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_sample_get_segment _obj'
+    checkUnexpectedReturnNULL "gst_sample_get_segment" result
+    result' <- (newBoxed Segment) result
+    touchManagedPtr _obj
+    return result'
+
+data SampleGetSegmentMethodInfo
+instance (signature ~ (m Segment), MonadIO m) => MethodInfo SampleGetSegmentMethodInfo Sample signature where
+    overloadedMethod _ = sampleGetSegment
+
+-- method Sample::set_buffer_list
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Sample", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "buffer_list", argType = TInterface "Gst" "BufferList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_sample_set_buffer_list" gst_sample_set_buffer_list :: 
+    Ptr Sample ->                           -- _obj : TInterface "Gst" "Sample"
+    Ptr BufferList ->                       -- buffer_list : TInterface "Gst" "BufferList"
+    IO ()
+
+
+sampleSetBufferList ::
+    (MonadIO m) =>
+    Sample                                  -- _obj
+    -> BufferList                           -- bufferList
+    -> m ()                                 -- result
+sampleSetBufferList _obj bufferList = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let bufferList' = unsafeManagedPtrGetPtr bufferList
+    gst_sample_set_buffer_list _obj' bufferList'
+    touchManagedPtr _obj
+    touchManagedPtr bufferList
+    return ()
+
+data SampleSetBufferListMethodInfo
+instance (signature ~ (BufferList -> m ()), MonadIO m) => MethodInfo SampleSetBufferListMethodInfo Sample signature where
+    overloadedMethod _ = sampleSetBufferList
+
+type family ResolveSampleMethod (t :: Symbol) (o :: *) :: * where
+    ResolveSampleMethod "getBuffer" o = SampleGetBufferMethodInfo
+    ResolveSampleMethod "getBufferList" o = SampleGetBufferListMethodInfo
+    ResolveSampleMethod "getCaps" o = SampleGetCapsMethodInfo
+    ResolveSampleMethod "getInfo" o = SampleGetInfoMethodInfo
+    ResolveSampleMethod "getSegment" o = SampleGetSegmentMethodInfo
+    ResolveSampleMethod "setBufferList" o = SampleSetBufferListMethodInfo
+    ResolveSampleMethod l o = MethodResolutionFailed l o
+
+instance (info ~ ResolveSampleMethod t Sample, MethodInfo info Sample p) => IsLabelProxy t (Sample -> p) where
+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)
+
+#if MIN_VERSION_base(4,9,0)
+instance (info ~ ResolveSampleMethod t Sample, MethodInfo info Sample p) => IsLabel t (Sample -> p) where
+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)
+#endif
+
+
diff --git a/GI/Gst/Structs/Sample.hs-boot b/GI/Gst/Structs/Sample.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/Sample.hs-boot
@@ -0,0 +1,17 @@
+module GI.Gst.Structs.Sample where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+newtype Sample = Sample (ForeignPtr Sample)
+instance BoxedObject Sample where
+data SampleGetBufferMethodInfo
+data SampleGetBufferListMethodInfo
+data SampleGetCapsMethodInfo
+data SampleGetInfoMethodInfo
+data SampleGetSegmentMethodInfo
+data SampleSetBufferListMethodInfo
diff --git a/GI/Gst/Structs/Segment.hs b/GI/Gst/Structs/Segment.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/Segment.hs
@@ -0,0 +1,753 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+
+This helper structure holds the relevant values for tracking the region of
+interest in a media file, called a segment.
+
+The structure can be used for two purposes:
+<itemizedlist>
+  <listitem><para>performing seeks (handling seek events)</para></listitem>
+  <listitem><para>tracking playback regions (handling newsegment events)</para></listitem>
+</itemizedlist>
+
+The segment is usually configured by the application with a seek event which
+is propagated upstream and eventually handled by an element that performs the seek.
+
+The configured segment is then propagated back downstream with a newsegment event.
+This information is then used to clip media to the segment boundaries.
+
+A segment structure is initialized with gst_segment_init(), which takes a #GstFormat
+that will be used as the format of the segment values. The segment will be configured
+with a start value of 0 and a stop/duration of -1, which is undefined. The default
+rate and applied_rate is 1.0.
+
+The public duration field contains the duration of the segment. When using
+the segment for seeking, the start and time members should normally be left
+to their default 0 value. The stop position is left to -1 unless explicitly
+configured to a different value after a seek event.
+
+The current position in the segment should be set by changing the position
+member in the structure.
+
+For elements that perform seeks, the current segment should be updated with the
+gst_segment_do_seek() and the values from the seek event. This method will update
+all the segment fields. The position field will contain the new playback position.
+If the start_type was different from GST_SEEK_TYPE_NONE, playback continues from
+the position position, possibly with updated flags or rate.
+
+For elements that want to use #GstSegment to track the playback region,
+update the segment fields with the information from the newsegment event.
+The gst_segment_clip() method can be used to check and clip
+the media data to the segment boundaries.
+
+For elements that want to synchronize to the pipeline clock, gst_segment_to_running_time()
+can be used to convert a timestamp to a value that can be used to synchronize
+to the clock. This function takes into account the base as well as
+any rate or applied_rate conversions.
+
+For elements that need to perform operations on media data in stream_time,
+gst_segment_to_stream_time() can be used to convert a timestamp and the segment
+info to stream time (which is always between 0 and the duration of the stream).
+-}
+
+module GI.Gst.Structs.Segment
+    ( 
+
+-- * Exported types
+    Segment(..)                             ,
+    newZeroSegment                          ,
+    noSegment                               ,
+
+
+ -- * Methods
+-- ** segmentClip
+    SegmentClipMethodInfo                   ,
+    segmentClip                             ,
+
+
+-- ** segmentCopy
+    SegmentCopyMethodInfo                   ,
+    segmentCopy                             ,
+
+
+-- ** segmentCopyInto
+    SegmentCopyIntoMethodInfo               ,
+    segmentCopyInto                         ,
+
+
+-- ** segmentDoSeek
+    SegmentDoSeekMethodInfo                 ,
+    segmentDoSeek                           ,
+
+
+-- ** segmentFree
+    SegmentFreeMethodInfo                   ,
+    segmentFree                             ,
+
+
+-- ** segmentInit
+    SegmentInitMethodInfo                   ,
+    segmentInit                             ,
+
+
+-- ** segmentIsEqual
+    SegmentIsEqualMethodInfo                ,
+    segmentIsEqual                          ,
+
+
+-- ** segmentNew
+    segmentNew                              ,
+
+
+-- ** segmentOffsetRunningTime
+    SegmentOffsetRunningTimeMethodInfo      ,
+    segmentOffsetRunningTime                ,
+
+
+-- ** segmentSetRunningTime
+    SegmentSetRunningTimeMethodInfo         ,
+    segmentSetRunningTime                   ,
+
+
+-- ** segmentToPosition
+    SegmentToPositionMethodInfo             ,
+    segmentToPosition                       ,
+
+
+-- ** segmentToRunningTime
+    SegmentToRunningTimeMethodInfo          ,
+    segmentToRunningTime                    ,
+
+
+-- ** segmentToRunningTimeFull
+    SegmentToRunningTimeFullMethodInfo      ,
+    segmentToRunningTimeFull                ,
+
+
+-- ** segmentToStreamTime
+    SegmentToStreamTimeMethodInfo           ,
+    segmentToStreamTime                     ,
+
+
+
+
+ -- * Properties
+-- ** AppliedRate
+    segmentReadAppliedRate                  ,
+
+
+-- ** Base
+    segmentReadBase                         ,
+
+
+-- ** Duration
+    segmentReadDuration                     ,
+
+
+-- ** Flags
+    segmentReadFlags                        ,
+
+
+-- ** Format
+    segmentReadFormat                       ,
+
+
+-- ** Offset
+    segmentReadOffset                       ,
+
+
+-- ** Position
+    segmentReadPosition                     ,
+
+
+-- ** Rate
+    segmentReadRate                         ,
+
+
+-- ** Start
+    segmentReadStart                        ,
+
+
+-- ** Stop
+    segmentReadStop                         ,
+
+
+-- ** Time
+    segmentReadTime                         ,
+
+
+
+
+    ) where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+import GI.Gst.Callbacks
+
+newtype Segment = Segment (ForeignPtr Segment)
+foreign import ccall "gst_segment_get_type" c_gst_segment_get_type :: 
+    IO GType
+
+instance BoxedObject Segment where
+    boxedType _ = c_gst_segment_get_type
+
+-- | Construct a `Segment` struct initialized to zero.
+newZeroSegment :: MonadIO m => m Segment
+newZeroSegment = liftIO $ callocBoxedBytes 120 >>= wrapBoxed Segment
+
+noSegment :: Maybe Segment
+noSegment = Nothing
+
+segmentReadFlags :: Segment -> IO [SegmentFlags]
+segmentReadFlags s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 0) :: IO CUInt
+    let val' = wordToGFlags val
+    return val'
+
+segmentReadRate :: Segment -> IO Double
+segmentReadRate s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 8) :: IO CDouble
+    let val' = realToFrac val
+    return val'
+
+segmentReadAppliedRate :: Segment -> IO Double
+segmentReadAppliedRate s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 16) :: IO CDouble
+    let val' = realToFrac val
+    return val'
+
+segmentReadFormat :: Segment -> IO Format
+segmentReadFormat s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 24) :: IO CUInt
+    let val' = (toEnum . fromIntegral) val
+    return val'
+
+segmentReadBase :: Segment -> IO Word64
+segmentReadBase s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 32) :: IO Word64
+    return val
+
+segmentReadOffset :: Segment -> IO Word64
+segmentReadOffset s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 40) :: IO Word64
+    return val
+
+segmentReadStart :: Segment -> IO Word64
+segmentReadStart s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 48) :: IO Word64
+    return val
+
+segmentReadStop :: Segment -> IO Word64
+segmentReadStop s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 56) :: IO Word64
+    return val
+
+segmentReadTime :: Segment -> IO Word64
+segmentReadTime s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 64) :: IO Word64
+    return val
+
+segmentReadPosition :: Segment -> IO Word64
+segmentReadPosition s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 72) :: IO Word64
+    return val
+
+segmentReadDuration :: Segment -> IO Word64
+segmentReadDuration s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 80) :: IO Word64
+    return val
+
+-- method Segment::new
+-- method type : Constructor
+-- Args : []
+-- Lengths : []
+-- returnType : TInterface "Gst" "Segment"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_segment_new" gst_segment_new :: 
+    IO (Ptr Segment)
+
+
+segmentNew ::
+    (MonadIO m) =>
+    m Segment                               -- result
+segmentNew  = liftIO $ do
+    result <- gst_segment_new
+    checkUnexpectedReturnNULL "gst_segment_new" result
+    result' <- (wrapBoxed Segment) result
+    return result'
+
+-- method Segment::clip
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Segment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stop", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "clip_start", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "clip_stop", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_segment_clip" gst_segment_clip :: 
+    Ptr Segment ->                          -- _obj : TInterface "Gst" "Segment"
+    CUInt ->                                -- format : TInterface "Gst" "Format"
+    Word64 ->                               -- start : TBasicType TUInt64
+    Word64 ->                               -- stop : TBasicType TUInt64
+    Ptr Word64 ->                           -- clip_start : TBasicType TUInt64
+    Ptr Word64 ->                           -- clip_stop : TBasicType TUInt64
+    IO CInt
+
+
+segmentClip ::
+    (MonadIO m) =>
+    Segment                                 -- _obj
+    -> Format                               -- format
+    -> Word64                               -- start
+    -> Word64                               -- stop
+    -> m (Bool,Word64,Word64)               -- result
+segmentClip _obj format start stop = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let format' = (fromIntegral . fromEnum) format
+    clipStart <- allocMem :: IO (Ptr Word64)
+    clipStop <- allocMem :: IO (Ptr Word64)
+    result <- gst_segment_clip _obj' format' start stop clipStart clipStop
+    let result' = (/= 0) result
+    clipStart' <- peek clipStart
+    clipStop' <- peek clipStop
+    touchManagedPtr _obj
+    freeMem clipStart
+    freeMem clipStop
+    return (result', clipStart', clipStop')
+
+data SegmentClipMethodInfo
+instance (signature ~ (Format -> Word64 -> Word64 -> m (Bool,Word64,Word64)), MonadIO m) => MethodInfo SegmentClipMethodInfo Segment signature where
+    overloadedMethod _ = segmentClip
+
+-- method Segment::copy
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Segment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Segment"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_segment_copy" gst_segment_copy :: 
+    Ptr Segment ->                          -- _obj : TInterface "Gst" "Segment"
+    IO (Ptr Segment)
+
+
+segmentCopy ::
+    (MonadIO m) =>
+    Segment                                 -- _obj
+    -> m Segment                            -- result
+segmentCopy _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_segment_copy _obj'
+    checkUnexpectedReturnNULL "gst_segment_copy" result
+    result' <- (wrapBoxed Segment) result
+    touchManagedPtr _obj
+    return result'
+
+data SegmentCopyMethodInfo
+instance (signature ~ (m Segment), MonadIO m) => MethodInfo SegmentCopyMethodInfo Segment signature where
+    overloadedMethod _ = segmentCopy
+
+-- method Segment::copy_into
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Segment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "dest", argType = TInterface "Gst" "Segment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_segment_copy_into" gst_segment_copy_into :: 
+    Ptr Segment ->                          -- _obj : TInterface "Gst" "Segment"
+    Ptr Segment ->                          -- dest : TInterface "Gst" "Segment"
+    IO ()
+
+
+segmentCopyInto ::
+    (MonadIO m) =>
+    Segment                                 -- _obj
+    -> Segment                              -- dest
+    -> m ()                                 -- result
+segmentCopyInto _obj dest = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let dest' = unsafeManagedPtrGetPtr dest
+    gst_segment_copy_into _obj' dest'
+    touchManagedPtr _obj
+    touchManagedPtr dest
+    return ()
+
+data SegmentCopyIntoMethodInfo
+instance (signature ~ (Segment -> m ()), MonadIO m) => MethodInfo SegmentCopyIntoMethodInfo Segment signature where
+    overloadedMethod _ = segmentCopyInto
+
+-- method Segment::do_seek
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Segment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "rate", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface "Gst" "SeekFlags", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start_type", argType = TInterface "Gst" "SeekType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stop_type", argType = TInterface "Gst" "SeekType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stop", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "update", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_segment_do_seek" gst_segment_do_seek :: 
+    Ptr Segment ->                          -- _obj : TInterface "Gst" "Segment"
+    CDouble ->                              -- rate : TBasicType TDouble
+    CUInt ->                                -- format : TInterface "Gst" "Format"
+    CUInt ->                                -- flags : TInterface "Gst" "SeekFlags"
+    CUInt ->                                -- start_type : TInterface "Gst" "SeekType"
+    Word64 ->                               -- start : TBasicType TUInt64
+    CUInt ->                                -- stop_type : TInterface "Gst" "SeekType"
+    Word64 ->                               -- stop : TBasicType TUInt64
+    CInt ->                                 -- update : TBasicType TBoolean
+    IO CInt
+
+
+segmentDoSeek ::
+    (MonadIO m) =>
+    Segment                                 -- _obj
+    -> Double                               -- rate
+    -> Format                               -- format
+    -> [SeekFlags]                          -- flags
+    -> SeekType                             -- startType
+    -> Word64                               -- start
+    -> SeekType                             -- stopType
+    -> Word64                               -- stop
+    -> Bool                                 -- update
+    -> m Bool                               -- result
+segmentDoSeek _obj rate format flags startType start stopType stop update = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let rate' = realToFrac rate
+    let format' = (fromIntegral . fromEnum) format
+    let flags' = gflagsToWord flags
+    let startType' = (fromIntegral . fromEnum) startType
+    let stopType' = (fromIntegral . fromEnum) stopType
+    let update' = (fromIntegral . fromEnum) update
+    result <- gst_segment_do_seek _obj' rate' format' flags' startType' start stopType' stop update'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data SegmentDoSeekMethodInfo
+instance (signature ~ (Double -> Format -> [SeekFlags] -> SeekType -> Word64 -> SeekType -> Word64 -> Bool -> m Bool), MonadIO m) => MethodInfo SegmentDoSeekMethodInfo Segment signature where
+    overloadedMethod _ = segmentDoSeek
+
+-- method Segment::free
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Segment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_segment_free" gst_segment_free :: 
+    Ptr Segment ->                          -- _obj : TInterface "Gst" "Segment"
+    IO ()
+
+
+segmentFree ::
+    (MonadIO m) =>
+    Segment                                 -- _obj
+    -> m ()                                 -- result
+segmentFree _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    gst_segment_free _obj'
+    touchManagedPtr _obj
+    return ()
+
+data SegmentFreeMethodInfo
+instance (signature ~ (m ()), MonadIO m) => MethodInfo SegmentFreeMethodInfo Segment signature where
+    overloadedMethod _ = segmentFree
+
+-- method Segment::init
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Segment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_segment_init" gst_segment_init :: 
+    Ptr Segment ->                          -- _obj : TInterface "Gst" "Segment"
+    CUInt ->                                -- format : TInterface "Gst" "Format"
+    IO ()
+
+
+segmentInit ::
+    (MonadIO m) =>
+    Segment                                 -- _obj
+    -> Format                               -- format
+    -> m ()                                 -- result
+segmentInit _obj format = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let format' = (fromIntegral . fromEnum) format
+    gst_segment_init _obj' format'
+    touchManagedPtr _obj
+    return ()
+
+data SegmentInitMethodInfo
+instance (signature ~ (Format -> m ()), MonadIO m) => MethodInfo SegmentInitMethodInfo Segment signature where
+    overloadedMethod _ = segmentInit
+
+-- method Segment::is_equal
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Segment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "s1", argType = TInterface "Gst" "Segment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_segment_is_equal" gst_segment_is_equal :: 
+    Ptr Segment ->                          -- _obj : TInterface "Gst" "Segment"
+    Ptr Segment ->                          -- s1 : TInterface "Gst" "Segment"
+    IO CInt
+
+
+segmentIsEqual ::
+    (MonadIO m) =>
+    Segment                                 -- _obj
+    -> Segment                              -- s1
+    -> m Bool                               -- result
+segmentIsEqual _obj s1 = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let s1' = unsafeManagedPtrGetPtr s1
+    result <- gst_segment_is_equal _obj' s1'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    touchManagedPtr s1
+    return result'
+
+data SegmentIsEqualMethodInfo
+instance (signature ~ (Segment -> m Bool), MonadIO m) => MethodInfo SegmentIsEqualMethodInfo Segment signature where
+    overloadedMethod _ = segmentIsEqual
+
+-- method Segment::offset_running_time
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Segment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_segment_offset_running_time" gst_segment_offset_running_time :: 
+    Ptr Segment ->                          -- _obj : TInterface "Gst" "Segment"
+    CUInt ->                                -- format : TInterface "Gst" "Format"
+    Int64 ->                                -- offset : TBasicType TInt64
+    IO CInt
+
+
+segmentOffsetRunningTime ::
+    (MonadIO m) =>
+    Segment                                 -- _obj
+    -> Format                               -- format
+    -> Int64                                -- offset
+    -> m Bool                               -- result
+segmentOffsetRunningTime _obj format offset = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let format' = (fromIntegral . fromEnum) format
+    result <- gst_segment_offset_running_time _obj' format' offset
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data SegmentOffsetRunningTimeMethodInfo
+instance (signature ~ (Format -> Int64 -> m Bool), MonadIO m) => MethodInfo SegmentOffsetRunningTimeMethodInfo Segment signature where
+    overloadedMethod _ = segmentOffsetRunningTime
+
+-- method Segment::set_running_time
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Segment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "running_time", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_segment_set_running_time" gst_segment_set_running_time :: 
+    Ptr Segment ->                          -- _obj : TInterface "Gst" "Segment"
+    CUInt ->                                -- format : TInterface "Gst" "Format"
+    Word64 ->                               -- running_time : TBasicType TUInt64
+    IO CInt
+
+
+segmentSetRunningTime ::
+    (MonadIO m) =>
+    Segment                                 -- _obj
+    -> Format                               -- format
+    -> Word64                               -- runningTime
+    -> m Bool                               -- result
+segmentSetRunningTime _obj format runningTime = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let format' = (fromIntegral . fromEnum) format
+    result <- gst_segment_set_running_time _obj' format' runningTime
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data SegmentSetRunningTimeMethodInfo
+instance (signature ~ (Format -> Word64 -> m Bool), MonadIO m) => MethodInfo SegmentSetRunningTimeMethodInfo Segment signature where
+    overloadedMethod _ = segmentSetRunningTime
+
+-- method Segment::to_position
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Segment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "running_time", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUInt64
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_segment_to_position" gst_segment_to_position :: 
+    Ptr Segment ->                          -- _obj : TInterface "Gst" "Segment"
+    CUInt ->                                -- format : TInterface "Gst" "Format"
+    Word64 ->                               -- running_time : TBasicType TUInt64
+    IO Word64
+
+
+segmentToPosition ::
+    (MonadIO m) =>
+    Segment                                 -- _obj
+    -> Format                               -- format
+    -> Word64                               -- runningTime
+    -> m Word64                             -- result
+segmentToPosition _obj format runningTime = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let format' = (fromIntegral . fromEnum) format
+    result <- gst_segment_to_position _obj' format' runningTime
+    touchManagedPtr _obj
+    return result
+
+data SegmentToPositionMethodInfo
+instance (signature ~ (Format -> Word64 -> m Word64), MonadIO m) => MethodInfo SegmentToPositionMethodInfo Segment signature where
+    overloadedMethod _ = segmentToPosition
+
+-- method Segment::to_running_time
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Segment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "position", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUInt64
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_segment_to_running_time" gst_segment_to_running_time :: 
+    Ptr Segment ->                          -- _obj : TInterface "Gst" "Segment"
+    CUInt ->                                -- format : TInterface "Gst" "Format"
+    Word64 ->                               -- position : TBasicType TUInt64
+    IO Word64
+
+
+segmentToRunningTime ::
+    (MonadIO m) =>
+    Segment                                 -- _obj
+    -> Format                               -- format
+    -> Word64                               -- position
+    -> m Word64                             -- result
+segmentToRunningTime _obj format position = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let format' = (fromIntegral . fromEnum) format
+    result <- gst_segment_to_running_time _obj' format' position
+    touchManagedPtr _obj
+    return result
+
+data SegmentToRunningTimeMethodInfo
+instance (signature ~ (Format -> Word64 -> m Word64), MonadIO m) => MethodInfo SegmentToRunningTimeMethodInfo Segment signature where
+    overloadedMethod _ = segmentToRunningTime
+
+-- method Segment::to_running_time_full
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Segment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "position", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "running_time", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TInt32
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_segment_to_running_time_full" gst_segment_to_running_time_full :: 
+    Ptr Segment ->                          -- _obj : TInterface "Gst" "Segment"
+    CUInt ->                                -- format : TInterface "Gst" "Format"
+    Word64 ->                               -- position : TBasicType TUInt64
+    Word64 ->                               -- running_time : TBasicType TUInt64
+    IO Int32
+
+
+segmentToRunningTimeFull ::
+    (MonadIO m) =>
+    Segment                                 -- _obj
+    -> Format                               -- format
+    -> Word64                               -- position
+    -> Word64                               -- runningTime
+    -> m Int32                              -- result
+segmentToRunningTimeFull _obj format position runningTime = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let format' = (fromIntegral . fromEnum) format
+    result <- gst_segment_to_running_time_full _obj' format' position runningTime
+    touchManagedPtr _obj
+    return result
+
+data SegmentToRunningTimeFullMethodInfo
+instance (signature ~ (Format -> Word64 -> Word64 -> m Int32), MonadIO m) => MethodInfo SegmentToRunningTimeFullMethodInfo Segment signature where
+    overloadedMethod _ = segmentToRunningTimeFull
+
+-- method Segment::to_stream_time
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Segment", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "format", argType = TInterface "Gst" "Format", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "position", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUInt64
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_segment_to_stream_time" gst_segment_to_stream_time :: 
+    Ptr Segment ->                          -- _obj : TInterface "Gst" "Segment"
+    CUInt ->                                -- format : TInterface "Gst" "Format"
+    Word64 ->                               -- position : TBasicType TUInt64
+    IO Word64
+
+
+segmentToStreamTime ::
+    (MonadIO m) =>
+    Segment                                 -- _obj
+    -> Format                               -- format
+    -> Word64                               -- position
+    -> m Word64                             -- result
+segmentToStreamTime _obj format position = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let format' = (fromIntegral . fromEnum) format
+    result <- gst_segment_to_stream_time _obj' format' position
+    touchManagedPtr _obj
+    return result
+
+data SegmentToStreamTimeMethodInfo
+instance (signature ~ (Format -> Word64 -> m Word64), MonadIO m) => MethodInfo SegmentToStreamTimeMethodInfo Segment signature where
+    overloadedMethod _ = segmentToStreamTime
+
+type family ResolveSegmentMethod (t :: Symbol) (o :: *) :: * where
+    ResolveSegmentMethod "clip" o = SegmentClipMethodInfo
+    ResolveSegmentMethod "copy" o = SegmentCopyMethodInfo
+    ResolveSegmentMethod "copyInto" o = SegmentCopyIntoMethodInfo
+    ResolveSegmentMethod "doSeek" o = SegmentDoSeekMethodInfo
+    ResolveSegmentMethod "free" o = SegmentFreeMethodInfo
+    ResolveSegmentMethod "init" o = SegmentInitMethodInfo
+    ResolveSegmentMethod "isEqual" o = SegmentIsEqualMethodInfo
+    ResolveSegmentMethod "offsetRunningTime" o = SegmentOffsetRunningTimeMethodInfo
+    ResolveSegmentMethod "toPosition" o = SegmentToPositionMethodInfo
+    ResolveSegmentMethod "toRunningTime" o = SegmentToRunningTimeMethodInfo
+    ResolveSegmentMethod "toRunningTimeFull" o = SegmentToRunningTimeFullMethodInfo
+    ResolveSegmentMethod "toStreamTime" o = SegmentToStreamTimeMethodInfo
+    ResolveSegmentMethod "setRunningTime" o = SegmentSetRunningTimeMethodInfo
+    ResolveSegmentMethod l o = MethodResolutionFailed l o
+
+instance (info ~ ResolveSegmentMethod t Segment, MethodInfo info Segment p) => IsLabelProxy t (Segment -> p) where
+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)
+
+#if MIN_VERSION_base(4,9,0)
+instance (info ~ ResolveSegmentMethod t Segment, MethodInfo info Segment p) => IsLabel t (Segment -> p) where
+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)
+#endif
+
+
diff --git a/GI/Gst/Structs/Segment.hs-boot b/GI/Gst/Structs/Segment.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/Segment.hs-boot
@@ -0,0 +1,24 @@
+module GI.Gst.Structs.Segment where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+newtype Segment = Segment (ForeignPtr Segment)
+instance BoxedObject Segment where
+data SegmentClipMethodInfo
+data SegmentCopyMethodInfo
+data SegmentCopyIntoMethodInfo
+data SegmentDoSeekMethodInfo
+data SegmentFreeMethodInfo
+data SegmentInitMethodInfo
+data SegmentIsEqualMethodInfo
+data SegmentOffsetRunningTimeMethodInfo
+data SegmentSetRunningTimeMethodInfo
+data SegmentToPositionMethodInfo
+data SegmentToRunningTimeMethodInfo
+data SegmentToRunningTimeFullMethodInfo
+data SegmentToStreamTimeMethodInfo
diff --git a/GI/Gst/Structs/StaticCaps.hs b/GI/Gst/Structs/StaticCaps.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/StaticCaps.hs
@@ -0,0 +1,147 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+
+Datastructure to initialize #GstCaps from a string description usually
+used in conjunction with GST_STATIC_CAPS() and gst_static_caps_get() to
+instantiate a #GstCaps.
+-}
+
+module GI.Gst.Structs.StaticCaps
+    ( 
+
+-- * Exported types
+    StaticCaps(..)                          ,
+    newZeroStaticCaps                       ,
+    noStaticCaps                            ,
+
+
+ -- * Methods
+-- ** staticCapsCleanup
+    StaticCapsCleanupMethodInfo             ,
+    staticCapsCleanup                       ,
+
+
+-- ** staticCapsGet
+    StaticCapsGetMethodInfo                 ,
+    staticCapsGet                           ,
+
+
+
+
+ -- * Properties
+-- ** Caps
+    staticCapsReadCaps                      ,
+
+
+-- ** String
+    staticCapsReadString                    ,
+
+
+
+
+    ) where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+import GI.Gst.Callbacks
+
+newtype StaticCaps = StaticCaps (ForeignPtr StaticCaps)
+-- | Construct a `StaticCaps` struct initialized to zero.
+newZeroStaticCaps :: MonadIO m => m StaticCaps
+newZeroStaticCaps = liftIO $ callocBytes 48 >>= wrapPtr StaticCaps
+
+noStaticCaps :: Maybe StaticCaps
+noStaticCaps = Nothing
+
+staticCapsReadCaps :: StaticCaps -> IO Caps
+staticCapsReadCaps s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 0) :: IO (Ptr Caps)
+    val' <- (newBoxed Caps) val
+    return val'
+
+staticCapsReadString :: StaticCaps -> IO T.Text
+staticCapsReadString s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 8) :: IO CString
+    val' <- cstringToText val
+    return val'
+
+-- method StaticCaps::cleanup
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "StaticCaps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_static_caps_cleanup" gst_static_caps_cleanup :: 
+    Ptr StaticCaps ->                       -- _obj : TInterface "Gst" "StaticCaps"
+    IO ()
+
+
+staticCapsCleanup ::
+    (MonadIO m) =>
+    StaticCaps                              -- _obj
+    -> m ()                                 -- result
+staticCapsCleanup _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    gst_static_caps_cleanup _obj'
+    touchManagedPtr _obj
+    return ()
+
+data StaticCapsCleanupMethodInfo
+instance (signature ~ (m ()), MonadIO m) => MethodInfo StaticCapsCleanupMethodInfo StaticCaps signature where
+    overloadedMethod _ = staticCapsCleanup
+
+-- method StaticCaps::get
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "StaticCaps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Caps"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_static_caps_get" gst_static_caps_get :: 
+    Ptr StaticCaps ->                       -- _obj : TInterface "Gst" "StaticCaps"
+    IO (Ptr Caps)
+
+
+staticCapsGet ::
+    (MonadIO m) =>
+    StaticCaps                              -- _obj
+    -> m Caps                               -- result
+staticCapsGet _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_static_caps_get _obj'
+    checkUnexpectedReturnNULL "gst_static_caps_get" result
+    result' <- (wrapBoxed Caps) result
+    touchManagedPtr _obj
+    return result'
+
+data StaticCapsGetMethodInfo
+instance (signature ~ (m Caps), MonadIO m) => MethodInfo StaticCapsGetMethodInfo StaticCaps signature where
+    overloadedMethod _ = staticCapsGet
+
+type family ResolveStaticCapsMethod (t :: Symbol) (o :: *) :: * where
+    ResolveStaticCapsMethod "cleanup" o = StaticCapsCleanupMethodInfo
+    ResolveStaticCapsMethod "get" o = StaticCapsGetMethodInfo
+    ResolveStaticCapsMethod l o = MethodResolutionFailed l o
+
+instance (info ~ ResolveStaticCapsMethod t StaticCaps, MethodInfo info StaticCaps p) => IsLabelProxy t (StaticCaps -> p) where
+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)
+
+#if MIN_VERSION_base(4,9,0)
+instance (info ~ ResolveStaticCapsMethod t StaticCaps, MethodInfo info StaticCaps p) => IsLabel t (StaticCaps -> p) where
+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)
+#endif
+
+
diff --git a/GI/Gst/Structs/StaticCaps.hs-boot b/GI/Gst/Structs/StaticCaps.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/StaticCaps.hs-boot
@@ -0,0 +1,12 @@
+module GI.Gst.Structs.StaticCaps where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+newtype StaticCaps = StaticCaps (ForeignPtr StaticCaps)
+data StaticCapsCleanupMethodInfo
+data StaticCapsGetMethodInfo
diff --git a/GI/Gst/Structs/StaticPadTemplate.hs b/GI/Gst/Structs/StaticPadTemplate.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/StaticPadTemplate.hs
@@ -0,0 +1,167 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+
+Structure describing the #GstStaticPadTemplate.
+-}
+
+module GI.Gst.Structs.StaticPadTemplate
+    ( 
+
+-- * Exported types
+    StaticPadTemplate(..)                   ,
+    newZeroStaticPadTemplate                ,
+    noStaticPadTemplate                     ,
+
+
+ -- * Methods
+-- ** staticPadTemplateGet
+    StaticPadTemplateGetMethodInfo          ,
+    staticPadTemplateGet                    ,
+
+
+-- ** staticPadTemplateGetCaps
+    StaticPadTemplateGetCapsMethodInfo      ,
+    staticPadTemplateGetCaps                ,
+
+
+
+
+ -- * Properties
+-- ** Direction
+    staticPadTemplateReadDirection          ,
+
+
+-- ** NameTemplate
+    staticPadTemplateReadNameTemplate       ,
+
+
+-- ** Presence
+    staticPadTemplateReadPresence           ,
+
+
+-- ** StaticCaps
+    staticPadTemplateReadStaticCaps         ,
+
+
+
+
+    ) where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+import GI.Gst.Callbacks
+
+newtype StaticPadTemplate = StaticPadTemplate (ForeignPtr StaticPadTemplate)
+-- | Construct a `StaticPadTemplate` struct initialized to zero.
+newZeroStaticPadTemplate :: MonadIO m => m StaticPadTemplate
+newZeroStaticPadTemplate = liftIO $ callocBytes 64 >>= wrapPtr StaticPadTemplate
+
+noStaticPadTemplate :: Maybe StaticPadTemplate
+noStaticPadTemplate = Nothing
+
+staticPadTemplateReadNameTemplate :: StaticPadTemplate -> IO T.Text
+staticPadTemplateReadNameTemplate s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 0) :: IO CString
+    val' <- cstringToText val
+    return val'
+
+staticPadTemplateReadDirection :: StaticPadTemplate -> IO PadDirection
+staticPadTemplateReadDirection s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 8) :: IO CUInt
+    let val' = (toEnum . fromIntegral) val
+    return val'
+
+staticPadTemplateReadPresence :: StaticPadTemplate -> IO PadPresence
+staticPadTemplateReadPresence s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 12) :: IO CUInt
+    let val' = (toEnum . fromIntegral) val
+    return val'
+
+staticPadTemplateReadStaticCaps :: StaticPadTemplate -> IO StaticCaps
+staticPadTemplateReadStaticCaps s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 16) :: IO (Ptr StaticCaps)
+    val' <- (newPtr 48 StaticCaps) val
+    return val'
+
+-- method StaticPadTemplate::get
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "StaticPadTemplate", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "PadTemplate"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_static_pad_template_get" gst_static_pad_template_get :: 
+    Ptr StaticPadTemplate ->                -- _obj : TInterface "Gst" "StaticPadTemplate"
+    IO (Ptr PadTemplate)
+
+
+staticPadTemplateGet ::
+    (MonadIO m) =>
+    StaticPadTemplate                       -- _obj
+    -> m PadTemplate                        -- result
+staticPadTemplateGet _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_static_pad_template_get _obj'
+    checkUnexpectedReturnNULL "gst_static_pad_template_get" result
+    result' <- (wrapObject PadTemplate) result
+    touchManagedPtr _obj
+    return result'
+
+data StaticPadTemplateGetMethodInfo
+instance (signature ~ (m PadTemplate), MonadIO m) => MethodInfo StaticPadTemplateGetMethodInfo StaticPadTemplate signature where
+    overloadedMethod _ = staticPadTemplateGet
+
+-- method StaticPadTemplate::get_caps
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "StaticPadTemplate", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Caps"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_static_pad_template_get_caps" gst_static_pad_template_get_caps :: 
+    Ptr StaticPadTemplate ->                -- _obj : TInterface "Gst" "StaticPadTemplate"
+    IO (Ptr Caps)
+
+
+staticPadTemplateGetCaps ::
+    (MonadIO m) =>
+    StaticPadTemplate                       -- _obj
+    -> m Caps                               -- result
+staticPadTemplateGetCaps _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_static_pad_template_get_caps _obj'
+    checkUnexpectedReturnNULL "gst_static_pad_template_get_caps" result
+    result' <- (wrapBoxed Caps) result
+    touchManagedPtr _obj
+    return result'
+
+data StaticPadTemplateGetCapsMethodInfo
+instance (signature ~ (m Caps), MonadIO m) => MethodInfo StaticPadTemplateGetCapsMethodInfo StaticPadTemplate signature where
+    overloadedMethod _ = staticPadTemplateGetCaps
+
+type family ResolveStaticPadTemplateMethod (t :: Symbol) (o :: *) :: * where
+    ResolveStaticPadTemplateMethod "get" o = StaticPadTemplateGetMethodInfo
+    ResolveStaticPadTemplateMethod "getCaps" o = StaticPadTemplateGetCapsMethodInfo
+    ResolveStaticPadTemplateMethod l o = MethodResolutionFailed l o
+
+instance (info ~ ResolveStaticPadTemplateMethod t StaticPadTemplate, MethodInfo info StaticPadTemplate p) => IsLabelProxy t (StaticPadTemplate -> p) where
+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)
+
+#if MIN_VERSION_base(4,9,0)
+instance (info ~ ResolveStaticPadTemplateMethod t StaticPadTemplate, MethodInfo info StaticPadTemplate p) => IsLabel t (StaticPadTemplate -> p) where
+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)
+#endif
+
+
diff --git a/GI/Gst/Structs/StaticPadTemplate.hs-boot b/GI/Gst/Structs/StaticPadTemplate.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/StaticPadTemplate.hs-boot
@@ -0,0 +1,12 @@
+module GI.Gst.Structs.StaticPadTemplate where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+newtype StaticPadTemplate = StaticPadTemplate (ForeignPtr StaticPadTemplate)
+data StaticPadTemplateGetMethodInfo
+data StaticPadTemplateGetCapsMethodInfo
diff --git a/GI/Gst/Structs/Structure.hs b/GI/Gst/Structs/Structure.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/Structure.hs
@@ -0,0 +1,2182 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+
+A #GstStructure is a collection of key/value pairs. The keys are expressed
+as GQuarks and the values can be of any GType.
+
+In addition to the key/value pairs, a #GstStructure also has a name. The name
+starts with a letter and can be filled by letters, numbers and any of "/-_.:".
+
+#GstStructure is used by various GStreamer subsystems to store information
+in a flexible and extensible way. A #GstStructure does not have a refcount
+because it usually is part of a higher level object such as #GstCaps,
+#GstMessage, #GstEvent, #GstQuery. It provides a means to enforce mutability
+using the refcount of the parent with the gst_structure_set_parent_refcount()
+method.
+
+A #GstStructure can be created with gst_structure_new_empty() or
+gst_structure_new(), which both take a name and an optional set of
+key/value pairs along with the types of the values.
+
+Field values can be changed with gst_structure_set_value() or
+gst_structure_set().
+
+Field values can be retrieved with gst_structure_get_value() or the more
+convenient gst_structure_get_*() functions.
+
+Fields can be removed with gst_structure_remove_field() or
+gst_structure_remove_fields().
+
+Strings in structures must be ASCII or UTF-8 encoded. Other encodings are
+not allowed. Strings may be %NULL however.
+
+Be aware that the current #GstCaps / #GstStructure serialization into string
+has limited support for nested #GstCaps / #GstStructure fields. It can only
+support one level of nesting. Using more levels will lead to unexpected
+behavior when using serialization features, such as gst_caps_to_string() or
+gst_value_serialize() and their counterparts.
+-}
+
+module GI.Gst.Structs.Structure
+    ( 
+
+-- * Exported types
+    Structure(..)                           ,
+    newZeroStructure                        ,
+    noStructure                             ,
+
+
+ -- * Methods
+-- ** structureCanIntersect
+    StructureCanIntersectMethodInfo         ,
+    structureCanIntersect                   ,
+
+
+-- ** structureCopy
+    StructureCopyMethodInfo                 ,
+    structureCopy                           ,
+
+
+-- ** structureFilterAndMapInPlace
+    StructureFilterAndMapInPlaceMethodInfo  ,
+    structureFilterAndMapInPlace            ,
+
+
+-- ** structureFixate
+    StructureFixateMethodInfo               ,
+    structureFixate                         ,
+
+
+-- ** structureFixateField
+    StructureFixateFieldMethodInfo          ,
+    structureFixateField                    ,
+
+
+-- ** structureFixateFieldBoolean
+    StructureFixateFieldBooleanMethodInfo   ,
+    structureFixateFieldBoolean             ,
+
+
+-- ** structureFixateFieldNearestDouble
+    StructureFixateFieldNearestDoubleMethodInfo,
+    structureFixateFieldNearestDouble       ,
+
+
+-- ** structureFixateFieldNearestFraction
+    StructureFixateFieldNearestFractionMethodInfo,
+    structureFixateFieldNearestFraction     ,
+
+
+-- ** structureFixateFieldNearestInt
+    StructureFixateFieldNearestIntMethodInfo,
+    structureFixateFieldNearestInt          ,
+
+
+-- ** structureFixateFieldString
+    StructureFixateFieldStringMethodInfo    ,
+    structureFixateFieldString              ,
+
+
+-- ** structureForeach
+    StructureForeachMethodInfo              ,
+    structureForeach                        ,
+
+
+-- ** structureFree
+    StructureFreeMethodInfo                 ,
+    structureFree                           ,
+
+
+-- ** structureFromString
+    structureFromString                     ,
+
+
+-- ** structureGetBoolean
+    StructureGetBooleanMethodInfo           ,
+    structureGetBoolean                     ,
+
+
+-- ** structureGetClockTime
+    StructureGetClockTimeMethodInfo         ,
+    structureGetClockTime                   ,
+
+
+-- ** structureGetDate
+    StructureGetDateMethodInfo              ,
+    structureGetDate                        ,
+
+
+-- ** structureGetDateTime
+    StructureGetDateTimeMethodInfo          ,
+    structureGetDateTime                    ,
+
+
+-- ** structureGetDouble
+    StructureGetDoubleMethodInfo            ,
+    structureGetDouble                      ,
+
+
+-- ** structureGetEnum
+    StructureGetEnumMethodInfo              ,
+    structureGetEnum                        ,
+
+
+-- ** structureGetFieldType
+    StructureGetFieldTypeMethodInfo         ,
+    structureGetFieldType                   ,
+
+
+-- ** structureGetFlagset
+    StructureGetFlagsetMethodInfo           ,
+    structureGetFlagset                     ,
+
+
+-- ** structureGetFraction
+    StructureGetFractionMethodInfo          ,
+    structureGetFraction                    ,
+
+
+-- ** structureGetInt
+    StructureGetIntMethodInfo               ,
+    structureGetInt                         ,
+
+
+-- ** structureGetInt64
+    StructureGetInt64MethodInfo             ,
+    structureGetInt64                       ,
+
+
+-- ** structureGetName
+    StructureGetNameMethodInfo              ,
+    structureGetName                        ,
+
+
+-- ** structureGetNameId
+    StructureGetNameIdMethodInfo            ,
+    structureGetNameId                      ,
+
+
+-- ** structureGetString
+    StructureGetStringMethodInfo            ,
+    structureGetString                      ,
+
+
+-- ** structureGetUint
+    StructureGetUintMethodInfo              ,
+    structureGetUint                        ,
+
+
+-- ** structureGetUint64
+    StructureGetUint64MethodInfo            ,
+    structureGetUint64                      ,
+
+
+-- ** structureGetValue
+    StructureGetValueMethodInfo             ,
+    structureGetValue                       ,
+
+
+-- ** structureHasField
+    StructureHasFieldMethodInfo             ,
+    structureHasField                       ,
+
+
+-- ** structureHasFieldTyped
+    StructureHasFieldTypedMethodInfo        ,
+    structureHasFieldTyped                  ,
+
+
+-- ** structureHasName
+    StructureHasNameMethodInfo              ,
+    structureHasName                        ,
+
+
+-- ** structureIdGetValue
+    StructureIdGetValueMethodInfo           ,
+    structureIdGetValue                     ,
+
+
+-- ** structureIdHasField
+    StructureIdHasFieldMethodInfo           ,
+    structureIdHasField                     ,
+
+
+-- ** structureIdHasFieldTyped
+    StructureIdHasFieldTypedMethodInfo      ,
+    structureIdHasFieldTyped                ,
+
+
+-- ** structureIdSetValue
+    StructureIdSetValueMethodInfo           ,
+    structureIdSetValue                     ,
+
+
+-- ** structureIdTakeValue
+    StructureIdTakeValueMethodInfo          ,
+    structureIdTakeValue                    ,
+
+
+-- ** structureIntersect
+    StructureIntersectMethodInfo            ,
+    structureIntersect                      ,
+
+
+-- ** structureIsEqual
+    StructureIsEqualMethodInfo              ,
+    structureIsEqual                        ,
+
+
+-- ** structureIsSubset
+    StructureIsSubsetMethodInfo             ,
+    structureIsSubset                       ,
+
+
+-- ** structureMapInPlace
+    StructureMapInPlaceMethodInfo           ,
+    structureMapInPlace                     ,
+
+
+-- ** structureNFields
+    StructureNFieldsMethodInfo              ,
+    structureNFields                        ,
+
+
+-- ** structureNewEmpty
+    structureNewEmpty                       ,
+
+
+-- ** structureNewFromString
+    structureNewFromString                  ,
+
+
+-- ** structureNewIdEmpty
+    structureNewIdEmpty                     ,
+
+
+-- ** structureNthFieldName
+    StructureNthFieldNameMethodInfo         ,
+    structureNthFieldName                   ,
+
+
+-- ** structureRemoveAllFields
+    StructureRemoveAllFieldsMethodInfo      ,
+    structureRemoveAllFields                ,
+
+
+-- ** structureRemoveField
+    StructureRemoveFieldMethodInfo          ,
+    structureRemoveField                    ,
+
+
+-- ** structureSetName
+    StructureSetNameMethodInfo              ,
+    structureSetName                        ,
+
+
+-- ** structureSetParentRefcount
+    StructureSetParentRefcountMethodInfo    ,
+    structureSetParentRefcount              ,
+
+
+-- ** structureSetValue
+    StructureSetValueMethodInfo             ,
+    structureSetValue                       ,
+
+
+-- ** structureTakeValue
+    StructureTakeValueMethodInfo            ,
+    structureTakeValue                      ,
+
+
+-- ** structureToString
+    StructureToStringMethodInfo             ,
+    structureToString                       ,
+
+
+
+
+ -- * Properties
+-- ** Type
+    structureReadType                       ,
+
+
+
+
+    ) where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+import GI.Gst.Callbacks
+import qualified GI.GLib as GLib
+
+newtype Structure = Structure (ForeignPtr Structure)
+foreign import ccall "gst_structure_get_type" c_gst_structure_get_type :: 
+    IO GType
+
+instance BoxedObject Structure where
+    boxedType _ = c_gst_structure_get_type
+
+-- | Construct a `Structure` struct initialized to zero.
+newZeroStructure :: MonadIO m => m Structure
+newZeroStructure = liftIO $ callocBoxedBytes 16 >>= wrapBoxed Structure
+
+noStructure :: Maybe Structure
+noStructure = Nothing
+
+structureReadType :: Structure -> IO GType
+structureReadType s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 0) :: IO CGType
+    let val' = GType val
+    return val'
+
+-- method Structure::new_empty
+-- method type : Constructor
+-- Args : [Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Structure"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_structure_new_empty" gst_structure_new_empty :: 
+    CString ->                              -- name : TBasicType TUTF8
+    IO (Ptr Structure)
+
+
+structureNewEmpty ::
+    (MonadIO m) =>
+    T.Text                                  -- name
+    -> m Structure                          -- result
+structureNewEmpty name = liftIO $ do
+    name' <- textToCString name
+    result <- gst_structure_new_empty name'
+    checkUnexpectedReturnNULL "gst_structure_new_empty" result
+    result' <- (wrapBoxed Structure) result
+    freeMem name'
+    return result'
+
+-- method Structure::new_from_string
+-- method type : Constructor
+-- Args : [Arg {argCName = "string", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Structure"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_structure_new_from_string" gst_structure_new_from_string :: 
+    CString ->                              -- string : TBasicType TUTF8
+    IO (Ptr Structure)
+
+
+structureNewFromString ::
+    (MonadIO m) =>
+    T.Text                                  -- string
+    -> m Structure                          -- result
+structureNewFromString string = liftIO $ do
+    string' <- textToCString string
+    result <- gst_structure_new_from_string string'
+    checkUnexpectedReturnNULL "gst_structure_new_from_string" result
+    result' <- (wrapBoxed Structure) result
+    freeMem string'
+    return result'
+
+-- method Structure::new_id_empty
+-- method type : Constructor
+-- Args : [Arg {argCName = "quark", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Structure"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_structure_new_id_empty" gst_structure_new_id_empty :: 
+    Word32 ->                               -- quark : TBasicType TUInt32
+    IO (Ptr Structure)
+
+
+structureNewIdEmpty ::
+    (MonadIO m) =>
+    Word32                                  -- quark
+    -> m Structure                          -- result
+structureNewIdEmpty quark = liftIO $ do
+    result <- gst_structure_new_id_empty quark
+    checkUnexpectedReturnNULL "gst_structure_new_id_empty" result
+    result' <- (wrapBoxed Structure) result
+    return result'
+
+-- method Structure::can_intersect
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "struct2", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_structure_can_intersect" gst_structure_can_intersect :: 
+    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"
+    Ptr Structure ->                        -- struct2 : TInterface "Gst" "Structure"
+    IO CInt
+
+
+structureCanIntersect ::
+    (MonadIO m) =>
+    Structure                               -- _obj
+    -> Structure                            -- struct2
+    -> m Bool                               -- result
+structureCanIntersect _obj struct2 = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let struct2' = unsafeManagedPtrGetPtr struct2
+    result <- gst_structure_can_intersect _obj' struct2'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    touchManagedPtr struct2
+    return result'
+
+data StructureCanIntersectMethodInfo
+instance (signature ~ (Structure -> m Bool), MonadIO m) => MethodInfo StructureCanIntersectMethodInfo Structure signature where
+    overloadedMethod _ = structureCanIntersect
+
+-- method Structure::copy
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Structure"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_structure_copy" gst_structure_copy :: 
+    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"
+    IO (Ptr Structure)
+
+
+structureCopy ::
+    (MonadIO m) =>
+    Structure                               -- _obj
+    -> m Structure                          -- result
+structureCopy _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_structure_copy _obj'
+    checkUnexpectedReturnNULL "gst_structure_copy" result
+    result' <- (wrapBoxed Structure) result
+    touchManagedPtr _obj
+    return result'
+
+data StructureCopyMethodInfo
+instance (signature ~ (m Structure), MonadIO m) => MethodInfo StructureCopyMethodInfo Structure signature where
+    overloadedMethod _ = structureCopy
+
+-- method Structure::filter_and_map_in_place
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "func", argType = TInterface "Gst" "StructureFilterMapFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_structure_filter_and_map_in_place" gst_structure_filter_and_map_in_place :: 
+    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"
+    FunPtr StructureFilterMapFuncC ->       -- func : TInterface "Gst" "StructureFilterMapFunc"
+    Ptr () ->                               -- user_data : TBasicType TVoid
+    IO ()
+
+
+structureFilterAndMapInPlace ::
+    (MonadIO m) =>
+    Structure                               -- _obj
+    -> StructureFilterMapFunc               -- func
+    -> m ()                                 -- result
+structureFilterAndMapInPlace _obj func = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    func' <- mkStructureFilterMapFunc (structureFilterMapFuncWrapper Nothing func)
+    let userData = nullPtr
+    gst_structure_filter_and_map_in_place _obj' func' userData
+    safeFreeFunPtr $ castFunPtrToPtr func'
+    touchManagedPtr _obj
+    return ()
+
+data StructureFilterAndMapInPlaceMethodInfo
+instance (signature ~ (StructureFilterMapFunc -> m ()), MonadIO m) => MethodInfo StructureFilterAndMapInPlaceMethodInfo Structure signature where
+    overloadedMethod _ = structureFilterAndMapInPlace
+
+-- method Structure::fixate
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_structure_fixate" gst_structure_fixate :: 
+    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"
+    IO ()
+
+
+structureFixate ::
+    (MonadIO m) =>
+    Structure                               -- _obj
+    -> m ()                                 -- result
+structureFixate _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    gst_structure_fixate _obj'
+    touchManagedPtr _obj
+    return ()
+
+data StructureFixateMethodInfo
+instance (signature ~ (m ()), MonadIO m) => MethodInfo StructureFixateMethodInfo Structure signature where
+    overloadedMethod _ = structureFixate
+
+-- method Structure::fixate_field
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "field_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_structure_fixate_field" gst_structure_fixate_field :: 
+    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"
+    CString ->                              -- field_name : TBasicType TUTF8
+    IO CInt
+
+
+structureFixateField ::
+    (MonadIO m) =>
+    Structure                               -- _obj
+    -> T.Text                               -- fieldName
+    -> m Bool                               -- result
+structureFixateField _obj fieldName = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    fieldName' <- textToCString fieldName
+    result <- gst_structure_fixate_field _obj' fieldName'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    freeMem fieldName'
+    return result'
+
+data StructureFixateFieldMethodInfo
+instance (signature ~ (T.Text -> m Bool), MonadIO m) => MethodInfo StructureFixateFieldMethodInfo Structure signature where
+    overloadedMethod _ = structureFixateField
+
+-- method Structure::fixate_field_boolean
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "field_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "target", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_structure_fixate_field_boolean" gst_structure_fixate_field_boolean :: 
+    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"
+    CString ->                              -- field_name : TBasicType TUTF8
+    CInt ->                                 -- target : TBasicType TBoolean
+    IO CInt
+
+
+structureFixateFieldBoolean ::
+    (MonadIO m) =>
+    Structure                               -- _obj
+    -> T.Text                               -- fieldName
+    -> Bool                                 -- target
+    -> m Bool                               -- result
+structureFixateFieldBoolean _obj fieldName target = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    fieldName' <- textToCString fieldName
+    let target' = (fromIntegral . fromEnum) target
+    result <- gst_structure_fixate_field_boolean _obj' fieldName' target'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    freeMem fieldName'
+    return result'
+
+data StructureFixateFieldBooleanMethodInfo
+instance (signature ~ (T.Text -> Bool -> m Bool), MonadIO m) => MethodInfo StructureFixateFieldBooleanMethodInfo Structure signature where
+    overloadedMethod _ = structureFixateFieldBoolean
+
+-- method Structure::fixate_field_nearest_double
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "field_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "target", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_structure_fixate_field_nearest_double" gst_structure_fixate_field_nearest_double :: 
+    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"
+    CString ->                              -- field_name : TBasicType TUTF8
+    CDouble ->                              -- target : TBasicType TDouble
+    IO CInt
+
+
+structureFixateFieldNearestDouble ::
+    (MonadIO m) =>
+    Structure                               -- _obj
+    -> T.Text                               -- fieldName
+    -> Double                               -- target
+    -> m Bool                               -- result
+structureFixateFieldNearestDouble _obj fieldName target = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    fieldName' <- textToCString fieldName
+    let target' = realToFrac target
+    result <- gst_structure_fixate_field_nearest_double _obj' fieldName' target'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    freeMem fieldName'
+    return result'
+
+data StructureFixateFieldNearestDoubleMethodInfo
+instance (signature ~ (T.Text -> Double -> m Bool), MonadIO m) => MethodInfo StructureFixateFieldNearestDoubleMethodInfo Structure signature where
+    overloadedMethod _ = structureFixateFieldNearestDouble
+
+-- method Structure::fixate_field_nearest_fraction
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "field_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "target_numerator", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "target_denominator", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_structure_fixate_field_nearest_fraction" gst_structure_fixate_field_nearest_fraction :: 
+    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"
+    CString ->                              -- field_name : TBasicType TUTF8
+    Int32 ->                                -- target_numerator : TBasicType TInt32
+    Int32 ->                                -- target_denominator : TBasicType TInt32
+    IO CInt
+
+
+structureFixateFieldNearestFraction ::
+    (MonadIO m) =>
+    Structure                               -- _obj
+    -> T.Text                               -- fieldName
+    -> Int32                                -- targetNumerator
+    -> Int32                                -- targetDenominator
+    -> m Bool                               -- result
+structureFixateFieldNearestFraction _obj fieldName targetNumerator targetDenominator = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    fieldName' <- textToCString fieldName
+    result <- gst_structure_fixate_field_nearest_fraction _obj' fieldName' targetNumerator targetDenominator
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    freeMem fieldName'
+    return result'
+
+data StructureFixateFieldNearestFractionMethodInfo
+instance (signature ~ (T.Text -> Int32 -> Int32 -> m Bool), MonadIO m) => MethodInfo StructureFixateFieldNearestFractionMethodInfo Structure signature where
+    overloadedMethod _ = structureFixateFieldNearestFraction
+
+-- method Structure::fixate_field_nearest_int
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "field_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "target", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_structure_fixate_field_nearest_int" gst_structure_fixate_field_nearest_int :: 
+    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"
+    CString ->                              -- field_name : TBasicType TUTF8
+    Int32 ->                                -- target : TBasicType TInt32
+    IO CInt
+
+
+structureFixateFieldNearestInt ::
+    (MonadIO m) =>
+    Structure                               -- _obj
+    -> T.Text                               -- fieldName
+    -> Int32                                -- target
+    -> m Bool                               -- result
+structureFixateFieldNearestInt _obj fieldName target = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    fieldName' <- textToCString fieldName
+    result <- gst_structure_fixate_field_nearest_int _obj' fieldName' target
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    freeMem fieldName'
+    return result'
+
+data StructureFixateFieldNearestIntMethodInfo
+instance (signature ~ (T.Text -> Int32 -> m Bool), MonadIO m) => MethodInfo StructureFixateFieldNearestIntMethodInfo Structure signature where
+    overloadedMethod _ = structureFixateFieldNearestInt
+
+-- method Structure::fixate_field_string
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "field_name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "target", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_structure_fixate_field_string" gst_structure_fixate_field_string :: 
+    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"
+    CString ->                              -- field_name : TBasicType TUTF8
+    CString ->                              -- target : TBasicType TUTF8
+    IO CInt
+
+
+structureFixateFieldString ::
+    (MonadIO m) =>
+    Structure                               -- _obj
+    -> T.Text                               -- fieldName
+    -> T.Text                               -- target
+    -> m Bool                               -- result
+structureFixateFieldString _obj fieldName target = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    fieldName' <- textToCString fieldName
+    target' <- textToCString target
+    result <- gst_structure_fixate_field_string _obj' fieldName' target'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    freeMem fieldName'
+    freeMem target'
+    return result'
+
+data StructureFixateFieldStringMethodInfo
+instance (signature ~ (T.Text -> T.Text -> m Bool), MonadIO m) => MethodInfo StructureFixateFieldStringMethodInfo Structure signature where
+    overloadedMethod _ = structureFixateFieldString
+
+-- method Structure::foreach
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "func", argType = TInterface "Gst" "StructureForeachFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_structure_foreach" gst_structure_foreach :: 
+    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"
+    FunPtr StructureForeachFuncC ->         -- func : TInterface "Gst" "StructureForeachFunc"
+    Ptr () ->                               -- user_data : TBasicType TVoid
+    IO CInt
+
+
+structureForeach ::
+    (MonadIO m) =>
+    Structure                               -- _obj
+    -> StructureForeachFunc                 -- func
+    -> m Bool                               -- result
+structureForeach _obj func = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    func' <- mkStructureForeachFunc (structureForeachFuncWrapper Nothing func)
+    let userData = nullPtr
+    result <- gst_structure_foreach _obj' func' userData
+    let result' = (/= 0) result
+    safeFreeFunPtr $ castFunPtrToPtr func'
+    touchManagedPtr _obj
+    return result'
+
+data StructureForeachMethodInfo
+instance (signature ~ (StructureForeachFunc -> m Bool), MonadIO m) => MethodInfo StructureForeachMethodInfo Structure signature where
+    overloadedMethod _ = structureForeach
+
+-- method Structure::free
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_structure_free" gst_structure_free :: 
+    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"
+    IO ()
+
+
+structureFree ::
+    (MonadIO m) =>
+    Structure                               -- _obj
+    -> m ()                                 -- result
+structureFree _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    gst_structure_free _obj'
+    touchManagedPtr _obj
+    return ()
+
+data StructureFreeMethodInfo
+instance (signature ~ (m ()), MonadIO m) => MethodInfo StructureFreeMethodInfo Structure signature where
+    overloadedMethod _ = structureFree
+
+-- method Structure::get_boolean
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fieldname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_structure_get_boolean" gst_structure_get_boolean :: 
+    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"
+    CString ->                              -- fieldname : TBasicType TUTF8
+    Ptr CInt ->                             -- value : TBasicType TBoolean
+    IO CInt
+
+
+structureGetBoolean ::
+    (MonadIO m) =>
+    Structure                               -- _obj
+    -> T.Text                               -- fieldname
+    -> m (Bool,Bool)                        -- result
+structureGetBoolean _obj fieldname = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    fieldname' <- textToCString fieldname
+    value <- allocMem :: IO (Ptr CInt)
+    result <- gst_structure_get_boolean _obj' fieldname' value
+    let result' = (/= 0) result
+    value' <- peek value
+    let value'' = (/= 0) value'
+    touchManagedPtr _obj
+    freeMem fieldname'
+    freeMem value
+    return (result', value'')
+
+data StructureGetBooleanMethodInfo
+instance (signature ~ (T.Text -> m (Bool,Bool)), MonadIO m) => MethodInfo StructureGetBooleanMethodInfo Structure signature where
+    overloadedMethod _ = structureGetBoolean
+
+-- method Structure::get_clock_time
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fieldname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_structure_get_clock_time" gst_structure_get_clock_time :: 
+    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"
+    CString ->                              -- fieldname : TBasicType TUTF8
+    Ptr Word64 ->                           -- value : TBasicType TUInt64
+    IO CInt
+
+
+structureGetClockTime ::
+    (MonadIO m) =>
+    Structure                               -- _obj
+    -> T.Text                               -- fieldname
+    -> m (Bool,Word64)                      -- result
+structureGetClockTime _obj fieldname = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    fieldname' <- textToCString fieldname
+    value <- allocMem :: IO (Ptr Word64)
+    result <- gst_structure_get_clock_time _obj' fieldname' value
+    let result' = (/= 0) result
+    value' <- peek value
+    touchManagedPtr _obj
+    freeMem fieldname'
+    freeMem value
+    return (result', value')
+
+data StructureGetClockTimeMethodInfo
+instance (signature ~ (T.Text -> m (Bool,Word64)), MonadIO m) => MethodInfo StructureGetClockTimeMethodInfo Structure signature where
+    overloadedMethod _ = structureGetClockTime
+
+-- method Structure::get_date
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fieldname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TInterface "GLib" "Date", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_structure_get_date" gst_structure_get_date :: 
+    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"
+    CString ->                              -- fieldname : TBasicType TUTF8
+    Ptr GLib.Date ->                        -- value : TInterface "GLib" "Date"
+    IO CInt
+
+
+structureGetDate ::
+    (MonadIO m) =>
+    Structure                               -- _obj
+    -> T.Text                               -- fieldname
+    -> m (Bool,GLib.Date)                   -- result
+structureGetDate _obj fieldname = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    fieldname' <- textToCString fieldname
+    value <- callocBoxedBytes 24 :: IO (Ptr GLib.Date)
+    result <- gst_structure_get_date _obj' fieldname' value
+    let result' = (/= 0) result
+    value' <- (wrapBoxed GLib.Date) value
+    touchManagedPtr _obj
+    freeMem fieldname'
+    return (result', value')
+
+data StructureGetDateMethodInfo
+instance (signature ~ (T.Text -> m (Bool,GLib.Date)), MonadIO m) => MethodInfo StructureGetDateMethodInfo Structure signature where
+    overloadedMethod _ = structureGetDate
+
+-- method Structure::get_date_time
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fieldname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TInterface "Gst" "DateTime", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_structure_get_date_time" gst_structure_get_date_time :: 
+    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"
+    CString ->                              -- fieldname : TBasicType TUTF8
+    Ptr (Ptr DateTime) ->                   -- value : TInterface "Gst" "DateTime"
+    IO CInt
+
+
+structureGetDateTime ::
+    (MonadIO m) =>
+    Structure                               -- _obj
+    -> T.Text                               -- fieldname
+    -> m (Bool,DateTime)                    -- result
+structureGetDateTime _obj fieldname = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    fieldname' <- textToCString fieldname
+    value <- allocMem :: IO (Ptr (Ptr DateTime))
+    result <- gst_structure_get_date_time _obj' fieldname' value
+    let result' = (/= 0) result
+    value' <- peek value
+    value'' <- (wrapBoxed DateTime) value'
+    touchManagedPtr _obj
+    freeMem fieldname'
+    freeMem value
+    return (result', value'')
+
+data StructureGetDateTimeMethodInfo
+instance (signature ~ (T.Text -> m (Bool,DateTime)), MonadIO m) => MethodInfo StructureGetDateTimeMethodInfo Structure signature where
+    overloadedMethod _ = structureGetDateTime
+
+-- method Structure::get_double
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fieldname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TDouble, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_structure_get_double" gst_structure_get_double :: 
+    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"
+    CString ->                              -- fieldname : TBasicType TUTF8
+    Ptr CDouble ->                          -- value : TBasicType TDouble
+    IO CInt
+
+
+structureGetDouble ::
+    (MonadIO m) =>
+    Structure                               -- _obj
+    -> T.Text                               -- fieldname
+    -> m (Bool,Double)                      -- result
+structureGetDouble _obj fieldname = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    fieldname' <- textToCString fieldname
+    value <- allocMem :: IO (Ptr CDouble)
+    result <- gst_structure_get_double _obj' fieldname' value
+    let result' = (/= 0) result
+    value' <- peek value
+    let value'' = realToFrac value'
+    touchManagedPtr _obj
+    freeMem fieldname'
+    freeMem value
+    return (result', value'')
+
+data StructureGetDoubleMethodInfo
+instance (signature ~ (T.Text -> m (Bool,Double)), MonadIO m) => MethodInfo StructureGetDoubleMethodInfo Structure signature where
+    overloadedMethod _ = structureGetDouble
+
+-- method Structure::get_enum
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fieldname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "enumtype", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_structure_get_enum" gst_structure_get_enum :: 
+    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"
+    CString ->                              -- fieldname : TBasicType TUTF8
+    CGType ->                               -- enumtype : TBasicType TGType
+    Ptr Int32 ->                            -- value : TBasicType TInt32
+    IO CInt
+
+
+structureGetEnum ::
+    (MonadIO m) =>
+    Structure                               -- _obj
+    -> T.Text                               -- fieldname
+    -> GType                                -- enumtype
+    -> m (Bool,Int32)                       -- result
+structureGetEnum _obj fieldname enumtype = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    fieldname' <- textToCString fieldname
+    let enumtype' = gtypeToCGType enumtype
+    value <- allocMem :: IO (Ptr Int32)
+    result <- gst_structure_get_enum _obj' fieldname' enumtype' value
+    let result' = (/= 0) result
+    value' <- peek value
+    touchManagedPtr _obj
+    freeMem fieldname'
+    freeMem value
+    return (result', value')
+
+data StructureGetEnumMethodInfo
+instance (signature ~ (T.Text -> GType -> m (Bool,Int32)), MonadIO m) => MethodInfo StructureGetEnumMethodInfo Structure signature where
+    overloadedMethod _ = structureGetEnum
+
+-- method Structure::get_field_type
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fieldname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TGType
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_structure_get_field_type" gst_structure_get_field_type :: 
+    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"
+    CString ->                              -- fieldname : TBasicType TUTF8
+    IO CGType
+
+
+structureGetFieldType ::
+    (MonadIO m) =>
+    Structure                               -- _obj
+    -> T.Text                               -- fieldname
+    -> m GType                              -- result
+structureGetFieldType _obj fieldname = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    fieldname' <- textToCString fieldname
+    result <- gst_structure_get_field_type _obj' fieldname'
+    let result' = GType result
+    touchManagedPtr _obj
+    freeMem fieldname'
+    return result'
+
+data StructureGetFieldTypeMethodInfo
+instance (signature ~ (T.Text -> m GType), MonadIO m) => MethodInfo StructureGetFieldTypeMethodInfo Structure signature where
+    overloadedMethod _ = structureGetFieldType
+
+-- method Structure::get_flagset
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fieldname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value_flags", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "value_mask", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_structure_get_flagset" gst_structure_get_flagset :: 
+    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"
+    CString ->                              -- fieldname : TBasicType TUTF8
+    Ptr Word32 ->                           -- value_flags : TBasicType TUInt32
+    Ptr Word32 ->                           -- value_mask : TBasicType TUInt32
+    IO CInt
+
+
+structureGetFlagset ::
+    (MonadIO m) =>
+    Structure                               -- _obj
+    -> T.Text                               -- fieldname
+    -> m (Bool,Word32,Word32)               -- result
+structureGetFlagset _obj fieldname = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    fieldname' <- textToCString fieldname
+    valueFlags <- allocMem :: IO (Ptr Word32)
+    valueMask <- allocMem :: IO (Ptr Word32)
+    result <- gst_structure_get_flagset _obj' fieldname' valueFlags valueMask
+    let result' = (/= 0) result
+    valueFlags' <- peek valueFlags
+    valueMask' <- peek valueMask
+    touchManagedPtr _obj
+    freeMem fieldname'
+    freeMem valueFlags
+    freeMem valueMask
+    return (result', valueFlags', valueMask')
+
+data StructureGetFlagsetMethodInfo
+instance (signature ~ (T.Text -> m (Bool,Word32,Word32)), MonadIO m) => MethodInfo StructureGetFlagsetMethodInfo Structure signature where
+    overloadedMethod _ = structureGetFlagset
+
+-- method Structure::get_fraction
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fieldname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value_numerator", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "value_denominator", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_structure_get_fraction" gst_structure_get_fraction :: 
+    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"
+    CString ->                              -- fieldname : TBasicType TUTF8
+    Ptr Int32 ->                            -- value_numerator : TBasicType TInt32
+    Ptr Int32 ->                            -- value_denominator : TBasicType TInt32
+    IO CInt
+
+
+structureGetFraction ::
+    (MonadIO m) =>
+    Structure                               -- _obj
+    -> T.Text                               -- fieldname
+    -> m (Bool,Int32,Int32)                 -- result
+structureGetFraction _obj fieldname = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    fieldname' <- textToCString fieldname
+    valueNumerator <- allocMem :: IO (Ptr Int32)
+    valueDenominator <- allocMem :: IO (Ptr Int32)
+    result <- gst_structure_get_fraction _obj' fieldname' valueNumerator valueDenominator
+    let result' = (/= 0) result
+    valueNumerator' <- peek valueNumerator
+    valueDenominator' <- peek valueDenominator
+    touchManagedPtr _obj
+    freeMem fieldname'
+    freeMem valueNumerator
+    freeMem valueDenominator
+    return (result', valueNumerator', valueDenominator')
+
+data StructureGetFractionMethodInfo
+instance (signature ~ (T.Text -> m (Bool,Int32,Int32)), MonadIO m) => MethodInfo StructureGetFractionMethodInfo Structure signature where
+    overloadedMethod _ = structureGetFraction
+
+-- method Structure::get_int
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fieldname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_structure_get_int" gst_structure_get_int :: 
+    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"
+    CString ->                              -- fieldname : TBasicType TUTF8
+    Ptr Int32 ->                            -- value : TBasicType TInt32
+    IO CInt
+
+
+structureGetInt ::
+    (MonadIO m) =>
+    Structure                               -- _obj
+    -> T.Text                               -- fieldname
+    -> m (Bool,Int32)                       -- result
+structureGetInt _obj fieldname = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    fieldname' <- textToCString fieldname
+    value <- allocMem :: IO (Ptr Int32)
+    result <- gst_structure_get_int _obj' fieldname' value
+    let result' = (/= 0) result
+    value' <- peek value
+    touchManagedPtr _obj
+    freeMem fieldname'
+    freeMem value
+    return (result', value')
+
+data StructureGetIntMethodInfo
+instance (signature ~ (T.Text -> m (Bool,Int32)), MonadIO m) => MethodInfo StructureGetIntMethodInfo Structure signature where
+    overloadedMethod _ = structureGetInt
+
+-- method Structure::get_int64
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fieldname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_structure_get_int64" gst_structure_get_int64 :: 
+    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"
+    CString ->                              -- fieldname : TBasicType TUTF8
+    Ptr Int64 ->                            -- value : TBasicType TInt64
+    IO CInt
+
+
+structureGetInt64 ::
+    (MonadIO m) =>
+    Structure                               -- _obj
+    -> T.Text                               -- fieldname
+    -> m (Bool,Int64)                       -- result
+structureGetInt64 _obj fieldname = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    fieldname' <- textToCString fieldname
+    value <- allocMem :: IO (Ptr Int64)
+    result <- gst_structure_get_int64 _obj' fieldname' value
+    let result' = (/= 0) result
+    value' <- peek value
+    touchManagedPtr _obj
+    freeMem fieldname'
+    freeMem value
+    return (result', value')
+
+data StructureGetInt64MethodInfo
+instance (signature ~ (T.Text -> m (Bool,Int64)), MonadIO m) => MethodInfo StructureGetInt64MethodInfo Structure signature where
+    overloadedMethod _ = structureGetInt64
+
+-- method Structure::get_name
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUTF8
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_structure_get_name" gst_structure_get_name :: 
+    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"
+    IO CString
+
+
+structureGetName ::
+    (MonadIO m) =>
+    Structure                               -- _obj
+    -> m T.Text                             -- result
+structureGetName _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_structure_get_name _obj'
+    checkUnexpectedReturnNULL "gst_structure_get_name" result
+    result' <- cstringToText result
+    touchManagedPtr _obj
+    return result'
+
+data StructureGetNameMethodInfo
+instance (signature ~ (m T.Text), MonadIO m) => MethodInfo StructureGetNameMethodInfo Structure signature where
+    overloadedMethod _ = structureGetName
+
+-- method Structure::get_name_id
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUInt32
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_structure_get_name_id" gst_structure_get_name_id :: 
+    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"
+    IO Word32
+
+
+structureGetNameId ::
+    (MonadIO m) =>
+    Structure                               -- _obj
+    -> m Word32                             -- result
+structureGetNameId _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_structure_get_name_id _obj'
+    touchManagedPtr _obj
+    return result
+
+data StructureGetNameIdMethodInfo
+instance (signature ~ (m Word32), MonadIO m) => MethodInfo StructureGetNameIdMethodInfo Structure signature where
+    overloadedMethod _ = structureGetNameId
+
+-- method Structure::get_string
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fieldname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUTF8
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_structure_get_string" gst_structure_get_string :: 
+    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"
+    CString ->                              -- fieldname : TBasicType TUTF8
+    IO CString
+
+
+structureGetString ::
+    (MonadIO m) =>
+    Structure                               -- _obj
+    -> T.Text                               -- fieldname
+    -> m T.Text                             -- result
+structureGetString _obj fieldname = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    fieldname' <- textToCString fieldname
+    result <- gst_structure_get_string _obj' fieldname'
+    checkUnexpectedReturnNULL "gst_structure_get_string" result
+    result' <- cstringToText result
+    touchManagedPtr _obj
+    freeMem fieldname'
+    return result'
+
+data StructureGetStringMethodInfo
+instance (signature ~ (T.Text -> m T.Text), MonadIO m) => MethodInfo StructureGetStringMethodInfo Structure signature where
+    overloadedMethod _ = structureGetString
+
+-- method Structure::get_uint
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fieldname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_structure_get_uint" gst_structure_get_uint :: 
+    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"
+    CString ->                              -- fieldname : TBasicType TUTF8
+    Ptr Word32 ->                           -- value : TBasicType TUInt32
+    IO CInt
+
+
+structureGetUint ::
+    (MonadIO m) =>
+    Structure                               -- _obj
+    -> T.Text                               -- fieldname
+    -> m (Bool,Word32)                      -- result
+structureGetUint _obj fieldname = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    fieldname' <- textToCString fieldname
+    value <- allocMem :: IO (Ptr Word32)
+    result <- gst_structure_get_uint _obj' fieldname' value
+    let result' = (/= 0) result
+    value' <- peek value
+    touchManagedPtr _obj
+    freeMem fieldname'
+    freeMem value
+    return (result', value')
+
+data StructureGetUintMethodInfo
+instance (signature ~ (T.Text -> m (Bool,Word32)), MonadIO m) => MethodInfo StructureGetUintMethodInfo Structure signature where
+    overloadedMethod _ = structureGetUint
+
+-- method Structure::get_uint64
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fieldname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_structure_get_uint64" gst_structure_get_uint64 :: 
+    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"
+    CString ->                              -- fieldname : TBasicType TUTF8
+    Ptr Word64 ->                           -- value : TBasicType TUInt64
+    IO CInt
+
+
+structureGetUint64 ::
+    (MonadIO m) =>
+    Structure                               -- _obj
+    -> T.Text                               -- fieldname
+    -> m (Bool,Word64)                      -- result
+structureGetUint64 _obj fieldname = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    fieldname' <- textToCString fieldname
+    value <- allocMem :: IO (Ptr Word64)
+    result <- gst_structure_get_uint64 _obj' fieldname' value
+    let result' = (/= 0) result
+    value' <- peek value
+    touchManagedPtr _obj
+    freeMem fieldname'
+    freeMem value
+    return (result', value')
+
+data StructureGetUint64MethodInfo
+instance (signature ~ (T.Text -> m (Bool,Word64)), MonadIO m) => MethodInfo StructureGetUint64MethodInfo Structure signature where
+    overloadedMethod _ = structureGetUint64
+
+-- method Structure::get_value
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fieldname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "GObject" "Value"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_structure_get_value" gst_structure_get_value :: 
+    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"
+    CString ->                              -- fieldname : TBasicType TUTF8
+    IO (Ptr GValue)
+
+
+structureGetValue ::
+    (MonadIO m) =>
+    Structure                               -- _obj
+    -> T.Text                               -- fieldname
+    -> m GValue                             -- result
+structureGetValue _obj fieldname = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    fieldname' <- textToCString fieldname
+    result <- gst_structure_get_value _obj' fieldname'
+    checkUnexpectedReturnNULL "gst_structure_get_value" result
+    result' <- (newBoxed GValue) result
+    touchManagedPtr _obj
+    freeMem fieldname'
+    return result'
+
+data StructureGetValueMethodInfo
+instance (signature ~ (T.Text -> m GValue), MonadIO m) => MethodInfo StructureGetValueMethodInfo Structure signature where
+    overloadedMethod _ = structureGetValue
+
+-- method Structure::has_field
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fieldname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_structure_has_field" gst_structure_has_field :: 
+    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"
+    CString ->                              -- fieldname : TBasicType TUTF8
+    IO CInt
+
+
+structureHasField ::
+    (MonadIO m) =>
+    Structure                               -- _obj
+    -> T.Text                               -- fieldname
+    -> m Bool                               -- result
+structureHasField _obj fieldname = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    fieldname' <- textToCString fieldname
+    result <- gst_structure_has_field _obj' fieldname'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    freeMem fieldname'
+    return result'
+
+data StructureHasFieldMethodInfo
+instance (signature ~ (T.Text -> m Bool), MonadIO m) => MethodInfo StructureHasFieldMethodInfo Structure signature where
+    overloadedMethod _ = structureHasField
+
+-- method Structure::has_field_typed
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fieldname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "type", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_structure_has_field_typed" gst_structure_has_field_typed :: 
+    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"
+    CString ->                              -- fieldname : TBasicType TUTF8
+    CGType ->                               -- type : TBasicType TGType
+    IO CInt
+
+
+structureHasFieldTyped ::
+    (MonadIO m) =>
+    Structure                               -- _obj
+    -> T.Text                               -- fieldname
+    -> GType                                -- type_
+    -> m Bool                               -- result
+structureHasFieldTyped _obj fieldname type_ = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    fieldname' <- textToCString fieldname
+    let type_' = gtypeToCGType type_
+    result <- gst_structure_has_field_typed _obj' fieldname' type_'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    freeMem fieldname'
+    return result'
+
+data StructureHasFieldTypedMethodInfo
+instance (signature ~ (T.Text -> GType -> m Bool), MonadIO m) => MethodInfo StructureHasFieldTypedMethodInfo Structure signature where
+    overloadedMethod _ = structureHasFieldTyped
+
+-- method Structure::has_name
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_structure_has_name" gst_structure_has_name :: 
+    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"
+    CString ->                              -- name : TBasicType TUTF8
+    IO CInt
+
+
+structureHasName ::
+    (MonadIO m) =>
+    Structure                               -- _obj
+    -> T.Text                               -- name
+    -> m Bool                               -- result
+structureHasName _obj name = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    name' <- textToCString name
+    result <- gst_structure_has_name _obj' name'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    freeMem name'
+    return result'
+
+data StructureHasNameMethodInfo
+instance (signature ~ (T.Text -> m Bool), MonadIO m) => MethodInfo StructureHasNameMethodInfo Structure signature where
+    overloadedMethod _ = structureHasName
+
+-- method Structure::id_get_value
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "field", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "GObject" "Value"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_structure_id_get_value" gst_structure_id_get_value :: 
+    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"
+    Word32 ->                               -- field : TBasicType TUInt32
+    IO (Ptr GValue)
+
+
+structureIdGetValue ::
+    (MonadIO m) =>
+    Structure                               -- _obj
+    -> Word32                               -- field
+    -> m GValue                             -- result
+structureIdGetValue _obj field = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_structure_id_get_value _obj' field
+    checkUnexpectedReturnNULL "gst_structure_id_get_value" result
+    result' <- (newBoxed GValue) result
+    touchManagedPtr _obj
+    return result'
+
+data StructureIdGetValueMethodInfo
+instance (signature ~ (Word32 -> m GValue), MonadIO m) => MethodInfo StructureIdGetValueMethodInfo Structure signature where
+    overloadedMethod _ = structureIdGetValue
+
+-- method Structure::id_has_field
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "field", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_structure_id_has_field" gst_structure_id_has_field :: 
+    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"
+    Word32 ->                               -- field : TBasicType TUInt32
+    IO CInt
+
+
+structureIdHasField ::
+    (MonadIO m) =>
+    Structure                               -- _obj
+    -> Word32                               -- field
+    -> m Bool                               -- result
+structureIdHasField _obj field = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_structure_id_has_field _obj' field
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data StructureIdHasFieldMethodInfo
+instance (signature ~ (Word32 -> m Bool), MonadIO m) => MethodInfo StructureIdHasFieldMethodInfo Structure signature where
+    overloadedMethod _ = structureIdHasField
+
+-- method Structure::id_has_field_typed
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "field", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "type", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_structure_id_has_field_typed" gst_structure_id_has_field_typed :: 
+    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"
+    Word32 ->                               -- field : TBasicType TUInt32
+    CGType ->                               -- type : TBasicType TGType
+    IO CInt
+
+
+structureIdHasFieldTyped ::
+    (MonadIO m) =>
+    Structure                               -- _obj
+    -> Word32                               -- field
+    -> GType                                -- type_
+    -> m Bool                               -- result
+structureIdHasFieldTyped _obj field type_ = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let type_' = gtypeToCGType type_
+    result <- gst_structure_id_has_field_typed _obj' field type_'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data StructureIdHasFieldTypedMethodInfo
+instance (signature ~ (Word32 -> GType -> m Bool), MonadIO m) => MethodInfo StructureIdHasFieldTypedMethodInfo Structure signature where
+    overloadedMethod _ = structureIdHasFieldTyped
+
+-- method Structure::id_set_value
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "field", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_structure_id_set_value" gst_structure_id_set_value :: 
+    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"
+    Word32 ->                               -- field : TBasicType TUInt32
+    Ptr GValue ->                           -- value : TInterface "GObject" "Value"
+    IO ()
+
+
+structureIdSetValue ::
+    (MonadIO m) =>
+    Structure                               -- _obj
+    -> Word32                               -- field
+    -> GValue                               -- value
+    -> m ()                                 -- result
+structureIdSetValue _obj field value = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let value' = unsafeManagedPtrGetPtr value
+    gst_structure_id_set_value _obj' field value'
+    touchManagedPtr _obj
+    touchManagedPtr value
+    return ()
+
+data StructureIdSetValueMethodInfo
+instance (signature ~ (Word32 -> GValue -> m ()), MonadIO m) => MethodInfo StructureIdSetValueMethodInfo Structure signature where
+    overloadedMethod _ = structureIdSetValue
+
+-- method Structure::id_take_value
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "field", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_structure_id_take_value" gst_structure_id_take_value :: 
+    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"
+    Word32 ->                               -- field : TBasicType TUInt32
+    Ptr GValue ->                           -- value : TInterface "GObject" "Value"
+    IO ()
+
+
+structureIdTakeValue ::
+    (MonadIO m) =>
+    Structure                               -- _obj
+    -> Word32                               -- field
+    -> GValue                               -- value
+    -> m ()                                 -- result
+structureIdTakeValue _obj field value = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    value' <- copyBoxed value
+    gst_structure_id_take_value _obj' field value'
+    touchManagedPtr _obj
+    touchManagedPtr value
+    return ()
+
+data StructureIdTakeValueMethodInfo
+instance (signature ~ (Word32 -> GValue -> m ()), MonadIO m) => MethodInfo StructureIdTakeValueMethodInfo Structure signature where
+    overloadedMethod _ = structureIdTakeValue
+
+-- method Structure::intersect
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "struct2", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Structure"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_structure_intersect" gst_structure_intersect :: 
+    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"
+    Ptr Structure ->                        -- struct2 : TInterface "Gst" "Structure"
+    IO (Ptr Structure)
+
+
+structureIntersect ::
+    (MonadIO m) =>
+    Structure                               -- _obj
+    -> Structure                            -- struct2
+    -> m Structure                          -- result
+structureIntersect _obj struct2 = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let struct2' = unsafeManagedPtrGetPtr struct2
+    result <- gst_structure_intersect _obj' struct2'
+    checkUnexpectedReturnNULL "gst_structure_intersect" result
+    result' <- (wrapBoxed Structure) result
+    touchManagedPtr _obj
+    touchManagedPtr struct2
+    return result'
+
+data StructureIntersectMethodInfo
+instance (signature ~ (Structure -> m Structure), MonadIO m) => MethodInfo StructureIntersectMethodInfo Structure signature where
+    overloadedMethod _ = structureIntersect
+
+-- method Structure::is_equal
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "structure2", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_structure_is_equal" gst_structure_is_equal :: 
+    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"
+    Ptr Structure ->                        -- structure2 : TInterface "Gst" "Structure"
+    IO CInt
+
+
+structureIsEqual ::
+    (MonadIO m) =>
+    Structure                               -- _obj
+    -> Structure                            -- structure2
+    -> m Bool                               -- result
+structureIsEqual _obj structure2 = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let structure2' = unsafeManagedPtrGetPtr structure2
+    result <- gst_structure_is_equal _obj' structure2'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    touchManagedPtr structure2
+    return result'
+
+data StructureIsEqualMethodInfo
+instance (signature ~ (Structure -> m Bool), MonadIO m) => MethodInfo StructureIsEqualMethodInfo Structure signature where
+    overloadedMethod _ = structureIsEqual
+
+-- method Structure::is_subset
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "superset", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_structure_is_subset" gst_structure_is_subset :: 
+    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"
+    Ptr Structure ->                        -- superset : TInterface "Gst" "Structure"
+    IO CInt
+
+
+structureIsSubset ::
+    (MonadIO m) =>
+    Structure                               -- _obj
+    -> Structure                            -- superset
+    -> m Bool                               -- result
+structureIsSubset _obj superset = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let superset' = unsafeManagedPtrGetPtr superset
+    result <- gst_structure_is_subset _obj' superset'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    touchManagedPtr superset
+    return result'
+
+data StructureIsSubsetMethodInfo
+instance (signature ~ (Structure -> m Bool), MonadIO m) => MethodInfo StructureIsSubsetMethodInfo Structure signature where
+    overloadedMethod _ = structureIsSubset
+
+-- method Structure::map_in_place
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "func", argType = TInterface "Gst" "StructureMapFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_structure_map_in_place" gst_structure_map_in_place :: 
+    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"
+    FunPtr StructureMapFuncC ->             -- func : TInterface "Gst" "StructureMapFunc"
+    Ptr () ->                               -- user_data : TBasicType TVoid
+    IO CInt
+
+
+structureMapInPlace ::
+    (MonadIO m) =>
+    Structure                               -- _obj
+    -> StructureMapFunc                     -- func
+    -> m Bool                               -- result
+structureMapInPlace _obj func = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    func' <- mkStructureMapFunc (structureMapFuncWrapper Nothing func)
+    let userData = nullPtr
+    result <- gst_structure_map_in_place _obj' func' userData
+    let result' = (/= 0) result
+    safeFreeFunPtr $ castFunPtrToPtr func'
+    touchManagedPtr _obj
+    return result'
+
+data StructureMapInPlaceMethodInfo
+instance (signature ~ (StructureMapFunc -> m Bool), MonadIO m) => MethodInfo StructureMapInPlaceMethodInfo Structure signature where
+    overloadedMethod _ = structureMapInPlace
+
+-- method Structure::n_fields
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TInt32
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_structure_n_fields" gst_structure_n_fields :: 
+    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"
+    IO Int32
+
+
+structureNFields ::
+    (MonadIO m) =>
+    Structure                               -- _obj
+    -> m Int32                              -- result
+structureNFields _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_structure_n_fields _obj'
+    touchManagedPtr _obj
+    return result
+
+data StructureNFieldsMethodInfo
+instance (signature ~ (m Int32), MonadIO m) => MethodInfo StructureNFieldsMethodInfo Structure signature where
+    overloadedMethod _ = structureNFields
+
+-- method Structure::nth_field_name
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUTF8
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_structure_nth_field_name" gst_structure_nth_field_name :: 
+    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"
+    Word32 ->                               -- index : TBasicType TUInt32
+    IO CString
+
+
+structureNthFieldName ::
+    (MonadIO m) =>
+    Structure                               -- _obj
+    -> Word32                               -- index
+    -> m T.Text                             -- result
+structureNthFieldName _obj index = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_structure_nth_field_name _obj' index
+    checkUnexpectedReturnNULL "gst_structure_nth_field_name" result
+    result' <- cstringToText result
+    touchManagedPtr _obj
+    return result'
+
+data StructureNthFieldNameMethodInfo
+instance (signature ~ (Word32 -> m T.Text), MonadIO m) => MethodInfo StructureNthFieldNameMethodInfo Structure signature where
+    overloadedMethod _ = structureNthFieldName
+
+-- method Structure::remove_all_fields
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_structure_remove_all_fields" gst_structure_remove_all_fields :: 
+    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"
+    IO ()
+
+
+structureRemoveAllFields ::
+    (MonadIO m) =>
+    Structure                               -- _obj
+    -> m ()                                 -- result
+structureRemoveAllFields _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    gst_structure_remove_all_fields _obj'
+    touchManagedPtr _obj
+    return ()
+
+data StructureRemoveAllFieldsMethodInfo
+instance (signature ~ (m ()), MonadIO m) => MethodInfo StructureRemoveAllFieldsMethodInfo Structure signature where
+    overloadedMethod _ = structureRemoveAllFields
+
+-- method Structure::remove_field
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fieldname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_structure_remove_field" gst_structure_remove_field :: 
+    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"
+    CString ->                              -- fieldname : TBasicType TUTF8
+    IO ()
+
+
+structureRemoveField ::
+    (MonadIO m) =>
+    Structure                               -- _obj
+    -> T.Text                               -- fieldname
+    -> m ()                                 -- result
+structureRemoveField _obj fieldname = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    fieldname' <- textToCString fieldname
+    gst_structure_remove_field _obj' fieldname'
+    touchManagedPtr _obj
+    freeMem fieldname'
+    return ()
+
+data StructureRemoveFieldMethodInfo
+instance (signature ~ (T.Text -> m ()), MonadIO m) => MethodInfo StructureRemoveFieldMethodInfo Structure signature where
+    overloadedMethod _ = structureRemoveField
+
+-- method Structure::set_name
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_structure_set_name" gst_structure_set_name :: 
+    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"
+    CString ->                              -- name : TBasicType TUTF8
+    IO ()
+
+
+structureSetName ::
+    (MonadIO m) =>
+    Structure                               -- _obj
+    -> T.Text                               -- name
+    -> m ()                                 -- result
+structureSetName _obj name = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    name' <- textToCString name
+    gst_structure_set_name _obj' name'
+    touchManagedPtr _obj
+    freeMem name'
+    return ()
+
+data StructureSetNameMethodInfo
+instance (signature ~ (T.Text -> m ()), MonadIO m) => MethodInfo StructureSetNameMethodInfo Structure signature where
+    overloadedMethod _ = structureSetName
+
+-- method Structure::set_parent_refcount
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "refcount", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_structure_set_parent_refcount" gst_structure_set_parent_refcount :: 
+    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"
+    Int32 ->                                -- refcount : TBasicType TInt32
+    IO CInt
+
+
+structureSetParentRefcount ::
+    (MonadIO m) =>
+    Structure                               -- _obj
+    -> Int32                                -- refcount
+    -> m Bool                               -- result
+structureSetParentRefcount _obj refcount = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_structure_set_parent_refcount _obj' refcount
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data StructureSetParentRefcountMethodInfo
+instance (signature ~ (Int32 -> m Bool), MonadIO m) => MethodInfo StructureSetParentRefcountMethodInfo Structure signature where
+    overloadedMethod _ = structureSetParentRefcount
+
+-- method Structure::set_value
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fieldname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_structure_set_value" gst_structure_set_value :: 
+    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"
+    CString ->                              -- fieldname : TBasicType TUTF8
+    Ptr GValue ->                           -- value : TInterface "GObject" "Value"
+    IO ()
+
+
+structureSetValue ::
+    (MonadIO m) =>
+    Structure                               -- _obj
+    -> T.Text                               -- fieldname
+    -> GValue                               -- value
+    -> m ()                                 -- result
+structureSetValue _obj fieldname value = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    fieldname' <- textToCString fieldname
+    let value' = unsafeManagedPtrGetPtr value
+    gst_structure_set_value _obj' fieldname' value'
+    touchManagedPtr _obj
+    touchManagedPtr value
+    freeMem fieldname'
+    return ()
+
+data StructureSetValueMethodInfo
+instance (signature ~ (T.Text -> GValue -> m ()), MonadIO m) => MethodInfo StructureSetValueMethodInfo Structure signature where
+    overloadedMethod _ = structureSetValue
+
+-- method Structure::take_value
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fieldname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_structure_take_value" gst_structure_take_value :: 
+    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"
+    CString ->                              -- fieldname : TBasicType TUTF8
+    Ptr GValue ->                           -- value : TInterface "GObject" "Value"
+    IO ()
+
+
+structureTakeValue ::
+    (MonadIO m) =>
+    Structure                               -- _obj
+    -> T.Text                               -- fieldname
+    -> GValue                               -- value
+    -> m ()                                 -- result
+structureTakeValue _obj fieldname value = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    fieldname' <- textToCString fieldname
+    value' <- copyBoxed value
+    gst_structure_take_value _obj' fieldname' value'
+    touchManagedPtr _obj
+    touchManagedPtr value
+    freeMem fieldname'
+    return ()
+
+data StructureTakeValueMethodInfo
+instance (signature ~ (T.Text -> GValue -> m ()), MonadIO m) => MethodInfo StructureTakeValueMethodInfo Structure signature where
+    overloadedMethod _ = structureTakeValue
+
+-- method Structure::to_string
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Structure", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUTF8
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_structure_to_string" gst_structure_to_string :: 
+    Ptr Structure ->                        -- _obj : TInterface "Gst" "Structure"
+    IO CString
+
+
+structureToString ::
+    (MonadIO m) =>
+    Structure                               -- _obj
+    -> m T.Text                             -- result
+structureToString _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_structure_to_string _obj'
+    checkUnexpectedReturnNULL "gst_structure_to_string" result
+    result' <- cstringToText result
+    freeMem result
+    touchManagedPtr _obj
+    return result'
+
+data StructureToStringMethodInfo
+instance (signature ~ (m T.Text), MonadIO m) => MethodInfo StructureToStringMethodInfo Structure signature where
+    overloadedMethod _ = structureToString
+
+-- method Structure::from_string
+-- method type : MemberFunction
+-- Args : [Arg {argCName = "string", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "end", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Structure"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_structure_from_string" gst_structure_from_string :: 
+    CString ->                              -- string : TBasicType TUTF8
+    Ptr CString ->                          -- end : TBasicType TUTF8
+    IO (Ptr Structure)
+
+
+structureFromString ::
+    (MonadIO m) =>
+    T.Text                                  -- string
+    -> m (Structure,T.Text)                 -- result
+structureFromString string = liftIO $ do
+    string' <- textToCString string
+    end <- allocMem :: IO (Ptr CString)
+    result <- gst_structure_from_string string' end
+    checkUnexpectedReturnNULL "gst_structure_from_string" result
+    result' <- (wrapBoxed Structure) result
+    end' <- peek end
+    end'' <- cstringToText end'
+    freeMem string'
+    freeMem end
+    return (result', end'')
+
+type family ResolveStructureMethod (t :: Symbol) (o :: *) :: * where
+    ResolveStructureMethod "canIntersect" o = StructureCanIntersectMethodInfo
+    ResolveStructureMethod "copy" o = StructureCopyMethodInfo
+    ResolveStructureMethod "filterAndMapInPlace" o = StructureFilterAndMapInPlaceMethodInfo
+    ResolveStructureMethod "fixate" o = StructureFixateMethodInfo
+    ResolveStructureMethod "fixateField" o = StructureFixateFieldMethodInfo
+    ResolveStructureMethod "fixateFieldBoolean" o = StructureFixateFieldBooleanMethodInfo
+    ResolveStructureMethod "fixateFieldNearestDouble" o = StructureFixateFieldNearestDoubleMethodInfo
+    ResolveStructureMethod "fixateFieldNearestFraction" o = StructureFixateFieldNearestFractionMethodInfo
+    ResolveStructureMethod "fixateFieldNearestInt" o = StructureFixateFieldNearestIntMethodInfo
+    ResolveStructureMethod "fixateFieldString" o = StructureFixateFieldStringMethodInfo
+    ResolveStructureMethod "foreach" o = StructureForeachMethodInfo
+    ResolveStructureMethod "free" o = StructureFreeMethodInfo
+    ResolveStructureMethod "hasField" o = StructureHasFieldMethodInfo
+    ResolveStructureMethod "hasFieldTyped" o = StructureHasFieldTypedMethodInfo
+    ResolveStructureMethod "hasName" o = StructureHasNameMethodInfo
+    ResolveStructureMethod "idGetValue" o = StructureIdGetValueMethodInfo
+    ResolveStructureMethod "idHasField" o = StructureIdHasFieldMethodInfo
+    ResolveStructureMethod "idHasFieldTyped" o = StructureIdHasFieldTypedMethodInfo
+    ResolveStructureMethod "idSetValue" o = StructureIdSetValueMethodInfo
+    ResolveStructureMethod "idTakeValue" o = StructureIdTakeValueMethodInfo
+    ResolveStructureMethod "intersect" o = StructureIntersectMethodInfo
+    ResolveStructureMethod "isEqual" o = StructureIsEqualMethodInfo
+    ResolveStructureMethod "isSubset" o = StructureIsSubsetMethodInfo
+    ResolveStructureMethod "mapInPlace" o = StructureMapInPlaceMethodInfo
+    ResolveStructureMethod "nFields" o = StructureNFieldsMethodInfo
+    ResolveStructureMethod "nthFieldName" o = StructureNthFieldNameMethodInfo
+    ResolveStructureMethod "removeAllFields" o = StructureRemoveAllFieldsMethodInfo
+    ResolveStructureMethod "removeField" o = StructureRemoveFieldMethodInfo
+    ResolveStructureMethod "takeValue" o = StructureTakeValueMethodInfo
+    ResolveStructureMethod "toString" o = StructureToStringMethodInfo
+    ResolveStructureMethod "getBoolean" o = StructureGetBooleanMethodInfo
+    ResolveStructureMethod "getClockTime" o = StructureGetClockTimeMethodInfo
+    ResolveStructureMethod "getDate" o = StructureGetDateMethodInfo
+    ResolveStructureMethod "getDateTime" o = StructureGetDateTimeMethodInfo
+    ResolveStructureMethod "getDouble" o = StructureGetDoubleMethodInfo
+    ResolveStructureMethod "getEnum" o = StructureGetEnumMethodInfo
+    ResolveStructureMethod "getFieldType" o = StructureGetFieldTypeMethodInfo
+    ResolveStructureMethod "getFlagset" o = StructureGetFlagsetMethodInfo
+    ResolveStructureMethod "getFraction" o = StructureGetFractionMethodInfo
+    ResolveStructureMethod "getInt" o = StructureGetIntMethodInfo
+    ResolveStructureMethod "getInt64" o = StructureGetInt64MethodInfo
+    ResolveStructureMethod "getName" o = StructureGetNameMethodInfo
+    ResolveStructureMethod "getNameId" o = StructureGetNameIdMethodInfo
+    ResolveStructureMethod "getString" o = StructureGetStringMethodInfo
+    ResolveStructureMethod "getUint" o = StructureGetUintMethodInfo
+    ResolveStructureMethod "getUint64" o = StructureGetUint64MethodInfo
+    ResolveStructureMethod "getValue" o = StructureGetValueMethodInfo
+    ResolveStructureMethod "setName" o = StructureSetNameMethodInfo
+    ResolveStructureMethod "setParentRefcount" o = StructureSetParentRefcountMethodInfo
+    ResolveStructureMethod "setValue" o = StructureSetValueMethodInfo
+    ResolveStructureMethod l o = MethodResolutionFailed l o
+
+instance (info ~ ResolveStructureMethod t Structure, MethodInfo info Structure p) => IsLabelProxy t (Structure -> p) where
+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)
+
+#if MIN_VERSION_base(4,9,0)
+instance (info ~ ResolveStructureMethod t Structure, MethodInfo info Structure p) => IsLabel t (Structure -> p) where
+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)
+#endif
+
+
diff --git a/GI/Gst/Structs/Structure.hs-boot b/GI/Gst/Structs/Structure.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/Structure.hs-boot
@@ -0,0 +1,61 @@
+module GI.Gst.Structs.Structure where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+newtype Structure = Structure (ForeignPtr Structure)
+instance BoxedObject Structure where
+data StructureCanIntersectMethodInfo
+data StructureCopyMethodInfo
+data StructureFilterAndMapInPlaceMethodInfo
+data StructureFixateMethodInfo
+data StructureFixateFieldMethodInfo
+data StructureFixateFieldBooleanMethodInfo
+data StructureFixateFieldNearestDoubleMethodInfo
+data StructureFixateFieldNearestFractionMethodInfo
+data StructureFixateFieldNearestIntMethodInfo
+data StructureFixateFieldStringMethodInfo
+data StructureForeachMethodInfo
+data StructureFreeMethodInfo
+data StructureGetBooleanMethodInfo
+data StructureGetClockTimeMethodInfo
+data StructureGetDateMethodInfo
+data StructureGetDateTimeMethodInfo
+data StructureGetDoubleMethodInfo
+data StructureGetEnumMethodInfo
+data StructureGetFieldTypeMethodInfo
+data StructureGetFlagsetMethodInfo
+data StructureGetFractionMethodInfo
+data StructureGetIntMethodInfo
+data StructureGetInt64MethodInfo
+data StructureGetNameMethodInfo
+data StructureGetNameIdMethodInfo
+data StructureGetStringMethodInfo
+data StructureGetUintMethodInfo
+data StructureGetUint64MethodInfo
+data StructureGetValueMethodInfo
+data StructureHasFieldMethodInfo
+data StructureHasFieldTypedMethodInfo
+data StructureHasNameMethodInfo
+data StructureIdGetValueMethodInfo
+data StructureIdHasFieldMethodInfo
+data StructureIdHasFieldTypedMethodInfo
+data StructureIdSetValueMethodInfo
+data StructureIdTakeValueMethodInfo
+data StructureIntersectMethodInfo
+data StructureIsEqualMethodInfo
+data StructureIsSubsetMethodInfo
+data StructureMapInPlaceMethodInfo
+data StructureNFieldsMethodInfo
+data StructureNthFieldNameMethodInfo
+data StructureRemoveAllFieldsMethodInfo
+data StructureRemoveFieldMethodInfo
+data StructureSetNameMethodInfo
+data StructureSetParentRefcountMethodInfo
+data StructureSetValueMethodInfo
+data StructureTakeValueMethodInfo
+data StructureToStringMethodInfo
diff --git a/GI/Gst/Structs/TagList.hs b/GI/Gst/Structs/TagList.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/TagList.hs
@@ -0,0 +1,1785 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+
+List of tags and values used to describe media metadata.
+
+Strings in structures must be ASCII or UTF-8 encoded. Other encodings are
+not allowed. Strings must not be empty or %NULL.
+-}
+
+module GI.Gst.Structs.TagList
+    ( 
+
+-- * Exported types
+    TagList(..)                             ,
+    newZeroTagList                          ,
+    noTagList                               ,
+
+
+ -- * Methods
+-- ** tagListAddValue
+    TagListAddValueMethodInfo               ,
+    tagListAddValue                         ,
+
+
+-- ** tagListCopyValue
+    tagListCopyValue                        ,
+
+
+-- ** tagListForeach
+    TagListForeachMethodInfo                ,
+    tagListForeach                          ,
+
+
+-- ** tagListGetBoolean
+    TagListGetBooleanMethodInfo             ,
+    tagListGetBoolean                       ,
+
+
+-- ** tagListGetBooleanIndex
+    TagListGetBooleanIndexMethodInfo        ,
+    tagListGetBooleanIndex                  ,
+
+
+-- ** tagListGetDate
+    TagListGetDateMethodInfo                ,
+    tagListGetDate                          ,
+
+
+-- ** tagListGetDateIndex
+    TagListGetDateIndexMethodInfo           ,
+    tagListGetDateIndex                     ,
+
+
+-- ** tagListGetDateTime
+    TagListGetDateTimeMethodInfo            ,
+    tagListGetDateTime                      ,
+
+
+-- ** tagListGetDateTimeIndex
+    TagListGetDateTimeIndexMethodInfo       ,
+    tagListGetDateTimeIndex                 ,
+
+
+-- ** tagListGetDouble
+    TagListGetDoubleMethodInfo              ,
+    tagListGetDouble                        ,
+
+
+-- ** tagListGetDoubleIndex
+    TagListGetDoubleIndexMethodInfo         ,
+    tagListGetDoubleIndex                   ,
+
+
+-- ** tagListGetFloat
+    TagListGetFloatMethodInfo               ,
+    tagListGetFloat                         ,
+
+
+-- ** tagListGetFloatIndex
+    TagListGetFloatIndexMethodInfo          ,
+    tagListGetFloatIndex                    ,
+
+
+-- ** tagListGetInt
+    TagListGetIntMethodInfo                 ,
+    tagListGetInt                           ,
+
+
+-- ** tagListGetInt64
+    TagListGetInt64MethodInfo               ,
+    tagListGetInt64                         ,
+
+
+-- ** tagListGetInt64Index
+    TagListGetInt64IndexMethodInfo          ,
+    tagListGetInt64Index                    ,
+
+
+-- ** tagListGetIntIndex
+    TagListGetIntIndexMethodInfo            ,
+    tagListGetIntIndex                      ,
+
+
+-- ** tagListGetPointer
+    TagListGetPointerMethodInfo             ,
+    tagListGetPointer                       ,
+
+
+-- ** tagListGetPointerIndex
+    TagListGetPointerIndexMethodInfo        ,
+    tagListGetPointerIndex                  ,
+
+
+-- ** tagListGetSample
+    TagListGetSampleMethodInfo              ,
+    tagListGetSample                        ,
+
+
+-- ** tagListGetSampleIndex
+    TagListGetSampleIndexMethodInfo         ,
+    tagListGetSampleIndex                   ,
+
+
+-- ** tagListGetScope
+    TagListGetScopeMethodInfo               ,
+    tagListGetScope                         ,
+
+
+-- ** tagListGetString
+    TagListGetStringMethodInfo              ,
+    tagListGetString                        ,
+
+
+-- ** tagListGetStringIndex
+    TagListGetStringIndexMethodInfo         ,
+    tagListGetStringIndex                   ,
+
+
+-- ** tagListGetTagSize
+    TagListGetTagSizeMethodInfo             ,
+    tagListGetTagSize                       ,
+
+
+-- ** tagListGetUint
+    TagListGetUintMethodInfo                ,
+    tagListGetUint                          ,
+
+
+-- ** tagListGetUint64
+    TagListGetUint64MethodInfo              ,
+    tagListGetUint64                        ,
+
+
+-- ** tagListGetUint64Index
+    TagListGetUint64IndexMethodInfo         ,
+    tagListGetUint64Index                   ,
+
+
+-- ** tagListGetUintIndex
+    TagListGetUintIndexMethodInfo           ,
+    tagListGetUintIndex                     ,
+
+
+-- ** tagListGetValueIndex
+    TagListGetValueIndexMethodInfo          ,
+    tagListGetValueIndex                    ,
+
+
+-- ** tagListInsert
+    TagListInsertMethodInfo                 ,
+    tagListInsert                           ,
+
+
+-- ** tagListIsEmpty
+    TagListIsEmptyMethodInfo                ,
+    tagListIsEmpty                          ,
+
+
+-- ** tagListIsEqual
+    TagListIsEqualMethodInfo                ,
+    tagListIsEqual                          ,
+
+
+-- ** tagListMerge
+    TagListMergeMethodInfo                  ,
+    tagListMerge                            ,
+
+
+-- ** tagListNTags
+    TagListNTagsMethodInfo                  ,
+    tagListNTags                            ,
+
+
+-- ** tagListNewEmpty
+    tagListNewEmpty                         ,
+
+
+-- ** tagListNewFromString
+    tagListNewFromString                    ,
+
+
+-- ** tagListNthTagName
+    TagListNthTagNameMethodInfo             ,
+    tagListNthTagName                       ,
+
+
+-- ** tagListPeekStringIndex
+    TagListPeekStringIndexMethodInfo        ,
+    tagListPeekStringIndex                  ,
+
+
+-- ** tagListRemoveTag
+    TagListRemoveTagMethodInfo              ,
+    tagListRemoveTag                        ,
+
+
+-- ** tagListSetScope
+    TagListSetScopeMethodInfo               ,
+    tagListSetScope                         ,
+
+
+-- ** tagListToString
+    TagListToStringMethodInfo               ,
+    tagListToString                         ,
+
+
+
+
+ -- * Properties
+-- ** MiniObject
+    tagListReadMiniObject                   ,
+
+
+
+
+    ) where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+import GI.Gst.Callbacks
+import qualified GI.GLib as GLib
+
+newtype TagList = TagList (ForeignPtr TagList)
+foreign import ccall "gst_tag_list_get_type" c_gst_tag_list_get_type :: 
+    IO GType
+
+instance BoxedObject TagList where
+    boxedType _ = c_gst_tag_list_get_type
+
+-- | Construct a `TagList` struct initialized to zero.
+newZeroTagList :: MonadIO m => m TagList
+newZeroTagList = liftIO $ callocBoxedBytes 64 >>= wrapBoxed TagList
+
+noTagList :: Maybe TagList
+noTagList = Nothing
+
+tagListReadMiniObject :: TagList -> IO MiniObject
+tagListReadMiniObject s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 0) :: IO (Ptr MiniObject)
+    val' <- (newPtr 64 MiniObject) val
+    return val'
+
+-- method TagList::new_empty
+-- method type : Constructor
+-- Args : []
+-- Lengths : []
+-- returnType : TInterface "Gst" "TagList"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_tag_list_new_empty" gst_tag_list_new_empty :: 
+    IO (Ptr TagList)
+
+
+tagListNewEmpty ::
+    (MonadIO m) =>
+    m TagList                               -- result
+tagListNewEmpty  = liftIO $ do
+    result <- gst_tag_list_new_empty
+    checkUnexpectedReturnNULL "gst_tag_list_new_empty" result
+    result' <- (wrapBoxed TagList) result
+    return result'
+
+-- method TagList::new_from_string
+-- method type : Constructor
+-- Args : [Arg {argCName = "str", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "TagList"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_tag_list_new_from_string" gst_tag_list_new_from_string :: 
+    CString ->                              -- str : TBasicType TUTF8
+    IO (Ptr TagList)
+
+
+tagListNewFromString ::
+    (MonadIO m) =>
+    T.Text                                  -- str
+    -> m TagList                            -- result
+tagListNewFromString str = liftIO $ do
+    str' <- textToCString str
+    result <- gst_tag_list_new_from_string str'
+    checkUnexpectedReturnNULL "gst_tag_list_new_from_string" result
+    result' <- (wrapBoxed TagList) result
+    freeMem str'
+    return result'
+
+-- method TagList::add_value
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mode", argType = TInterface "Gst" "TagMergeMode", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TInterface "GObject" "Value", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_tag_list_add_value" gst_tag_list_add_value :: 
+    Ptr TagList ->                          -- _obj : TInterface "Gst" "TagList"
+    CUInt ->                                -- mode : TInterface "Gst" "TagMergeMode"
+    CString ->                              -- tag : TBasicType TUTF8
+    Ptr GValue ->                           -- value : TInterface "GObject" "Value"
+    IO ()
+
+
+tagListAddValue ::
+    (MonadIO m) =>
+    TagList                                 -- _obj
+    -> TagMergeMode                         -- mode
+    -> T.Text                               -- tag
+    -> GValue                               -- value
+    -> m ()                                 -- result
+tagListAddValue _obj mode tag value = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let mode' = (fromIntegral . fromEnum) mode
+    tag' <- textToCString tag
+    let value' = unsafeManagedPtrGetPtr value
+    gst_tag_list_add_value _obj' mode' tag' value'
+    touchManagedPtr _obj
+    touchManagedPtr value
+    freeMem tag'
+    return ()
+
+data TagListAddValueMethodInfo
+instance (signature ~ (TagMergeMode -> T.Text -> GValue -> m ()), MonadIO m) => MethodInfo TagListAddValueMethodInfo TagList signature where
+    overloadedMethod _ = tagListAddValue
+
+-- method TagList::foreach
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "func", argType = TInterface "Gst" "TagForeachFunc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeCall, argClosure = 2, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_tag_list_foreach" gst_tag_list_foreach :: 
+    Ptr TagList ->                          -- _obj : TInterface "Gst" "TagList"
+    FunPtr TagForeachFuncC ->               -- func : TInterface "Gst" "TagForeachFunc"
+    Ptr () ->                               -- user_data : TBasicType TVoid
+    IO ()
+
+
+tagListForeach ::
+    (MonadIO m) =>
+    TagList                                 -- _obj
+    -> TagForeachFunc                       -- func
+    -> m ()                                 -- result
+tagListForeach _obj func = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    func' <- mkTagForeachFunc (tagForeachFuncWrapper Nothing func)
+    let userData = nullPtr
+    gst_tag_list_foreach _obj' func' userData
+    safeFreeFunPtr $ castFunPtrToPtr func'
+    touchManagedPtr _obj
+    return ()
+
+data TagListForeachMethodInfo
+instance (signature ~ (TagForeachFunc -> m ()), MonadIO m) => MethodInfo TagListForeachMethodInfo TagList signature where
+    overloadedMethod _ = tagListForeach
+
+-- method TagList::get_boolean
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_tag_list_get_boolean" gst_tag_list_get_boolean :: 
+    Ptr TagList ->                          -- _obj : TInterface "Gst" "TagList"
+    CString ->                              -- tag : TBasicType TUTF8
+    Ptr CInt ->                             -- value : TBasicType TBoolean
+    IO CInt
+
+
+tagListGetBoolean ::
+    (MonadIO m) =>
+    TagList                                 -- _obj
+    -> T.Text                               -- tag
+    -> m (Bool,Bool)                        -- result
+tagListGetBoolean _obj tag = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    tag' <- textToCString tag
+    value <- allocMem :: IO (Ptr CInt)
+    result <- gst_tag_list_get_boolean _obj' tag' value
+    let result' = (/= 0) result
+    value' <- peek value
+    let value'' = (/= 0) value'
+    touchManagedPtr _obj
+    freeMem tag'
+    freeMem value
+    return (result', value'')
+
+data TagListGetBooleanMethodInfo
+instance (signature ~ (T.Text -> m (Bool,Bool)), MonadIO m) => MethodInfo TagListGetBooleanMethodInfo TagList signature where
+    overloadedMethod _ = tagListGetBoolean
+
+-- method TagList::get_boolean_index
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TBoolean, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_tag_list_get_boolean_index" gst_tag_list_get_boolean_index :: 
+    Ptr TagList ->                          -- _obj : TInterface "Gst" "TagList"
+    CString ->                              -- tag : TBasicType TUTF8
+    Word32 ->                               -- index : TBasicType TUInt32
+    Ptr CInt ->                             -- value : TBasicType TBoolean
+    IO CInt
+
+
+tagListGetBooleanIndex ::
+    (MonadIO m) =>
+    TagList                                 -- _obj
+    -> T.Text                               -- tag
+    -> Word32                               -- index
+    -> m (Bool,Bool)                        -- result
+tagListGetBooleanIndex _obj tag index = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    tag' <- textToCString tag
+    value <- allocMem :: IO (Ptr CInt)
+    result <- gst_tag_list_get_boolean_index _obj' tag' index value
+    let result' = (/= 0) result
+    value' <- peek value
+    let value'' = (/= 0) value'
+    touchManagedPtr _obj
+    freeMem tag'
+    freeMem value
+    return (result', value'')
+
+data TagListGetBooleanIndexMethodInfo
+instance (signature ~ (T.Text -> Word32 -> m (Bool,Bool)), MonadIO m) => MethodInfo TagListGetBooleanIndexMethodInfo TagList signature where
+    overloadedMethod _ = tagListGetBooleanIndex
+
+-- method TagList::get_date
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TInterface "GLib" "Date", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_tag_list_get_date" gst_tag_list_get_date :: 
+    Ptr TagList ->                          -- _obj : TInterface "Gst" "TagList"
+    CString ->                              -- tag : TBasicType TUTF8
+    Ptr GLib.Date ->                        -- value : TInterface "GLib" "Date"
+    IO CInt
+
+
+tagListGetDate ::
+    (MonadIO m) =>
+    TagList                                 -- _obj
+    -> T.Text                               -- tag
+    -> m (Bool,GLib.Date)                   -- result
+tagListGetDate _obj tag = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    tag' <- textToCString tag
+    value <- callocBoxedBytes 24 :: IO (Ptr GLib.Date)
+    result <- gst_tag_list_get_date _obj' tag' value
+    let result' = (/= 0) result
+    value' <- (wrapBoxed GLib.Date) value
+    touchManagedPtr _obj
+    freeMem tag'
+    return (result', value')
+
+data TagListGetDateMethodInfo
+instance (signature ~ (T.Text -> m (Bool,GLib.Date)), MonadIO m) => MethodInfo TagListGetDateMethodInfo TagList signature where
+    overloadedMethod _ = tagListGetDate
+
+-- method TagList::get_date_index
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TInterface "GLib" "Date", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_tag_list_get_date_index" gst_tag_list_get_date_index :: 
+    Ptr TagList ->                          -- _obj : TInterface "Gst" "TagList"
+    CString ->                              -- tag : TBasicType TUTF8
+    Word32 ->                               -- index : TBasicType TUInt32
+    Ptr GLib.Date ->                        -- value : TInterface "GLib" "Date"
+    IO CInt
+
+
+tagListGetDateIndex ::
+    (MonadIO m) =>
+    TagList                                 -- _obj
+    -> T.Text                               -- tag
+    -> Word32                               -- index
+    -> m (Bool,GLib.Date)                   -- result
+tagListGetDateIndex _obj tag index = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    tag' <- textToCString tag
+    value <- callocBoxedBytes 24 :: IO (Ptr GLib.Date)
+    result <- gst_tag_list_get_date_index _obj' tag' index value
+    let result' = (/= 0) result
+    value' <- (wrapBoxed GLib.Date) value
+    touchManagedPtr _obj
+    freeMem tag'
+    return (result', value')
+
+data TagListGetDateIndexMethodInfo
+instance (signature ~ (T.Text -> Word32 -> m (Bool,GLib.Date)), MonadIO m) => MethodInfo TagListGetDateIndexMethodInfo TagList signature where
+    overloadedMethod _ = tagListGetDateIndex
+
+-- method TagList::get_date_time
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TInterface "Gst" "DateTime", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_tag_list_get_date_time" gst_tag_list_get_date_time :: 
+    Ptr TagList ->                          -- _obj : TInterface "Gst" "TagList"
+    CString ->                              -- tag : TBasicType TUTF8
+    Ptr (Ptr DateTime) ->                   -- value : TInterface "Gst" "DateTime"
+    IO CInt
+
+
+tagListGetDateTime ::
+    (MonadIO m) =>
+    TagList                                 -- _obj
+    -> T.Text                               -- tag
+    -> m (Bool,DateTime)                    -- result
+tagListGetDateTime _obj tag = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    tag' <- textToCString tag
+    value <- allocMem :: IO (Ptr (Ptr DateTime))
+    result <- gst_tag_list_get_date_time _obj' tag' value
+    let result' = (/= 0) result
+    value' <- peek value
+    value'' <- (wrapBoxed DateTime) value'
+    touchManagedPtr _obj
+    freeMem tag'
+    freeMem value
+    return (result', value'')
+
+data TagListGetDateTimeMethodInfo
+instance (signature ~ (T.Text -> m (Bool,DateTime)), MonadIO m) => MethodInfo TagListGetDateTimeMethodInfo TagList signature where
+    overloadedMethod _ = tagListGetDateTime
+
+-- method TagList::get_date_time_index
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TInterface "Gst" "DateTime", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_tag_list_get_date_time_index" gst_tag_list_get_date_time_index :: 
+    Ptr TagList ->                          -- _obj : TInterface "Gst" "TagList"
+    CString ->                              -- tag : TBasicType TUTF8
+    Word32 ->                               -- index : TBasicType TUInt32
+    Ptr (Ptr DateTime) ->                   -- value : TInterface "Gst" "DateTime"
+    IO CInt
+
+
+tagListGetDateTimeIndex ::
+    (MonadIO m) =>
+    TagList                                 -- _obj
+    -> T.Text                               -- tag
+    -> Word32                               -- index
+    -> m (Bool,DateTime)                    -- result
+tagListGetDateTimeIndex _obj tag index = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    tag' <- textToCString tag
+    value <- allocMem :: IO (Ptr (Ptr DateTime))
+    result <- gst_tag_list_get_date_time_index _obj' tag' index value
+    let result' = (/= 0) result
+    value' <- peek value
+    value'' <- (wrapBoxed DateTime) value'
+    touchManagedPtr _obj
+    freeMem tag'
+    freeMem value
+    return (result', value'')
+
+data TagListGetDateTimeIndexMethodInfo
+instance (signature ~ (T.Text -> Word32 -> m (Bool,DateTime)), MonadIO m) => MethodInfo TagListGetDateTimeIndexMethodInfo TagList signature where
+    overloadedMethod _ = tagListGetDateTimeIndex
+
+-- method TagList::get_double
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TDouble, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_tag_list_get_double" gst_tag_list_get_double :: 
+    Ptr TagList ->                          -- _obj : TInterface "Gst" "TagList"
+    CString ->                              -- tag : TBasicType TUTF8
+    Ptr CDouble ->                          -- value : TBasicType TDouble
+    IO CInt
+
+
+tagListGetDouble ::
+    (MonadIO m) =>
+    TagList                                 -- _obj
+    -> T.Text                               -- tag
+    -> m (Bool,Double)                      -- result
+tagListGetDouble _obj tag = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    tag' <- textToCString tag
+    value <- allocMem :: IO (Ptr CDouble)
+    result <- gst_tag_list_get_double _obj' tag' value
+    let result' = (/= 0) result
+    value' <- peek value
+    let value'' = realToFrac value'
+    touchManagedPtr _obj
+    freeMem tag'
+    freeMem value
+    return (result', value'')
+
+data TagListGetDoubleMethodInfo
+instance (signature ~ (T.Text -> m (Bool,Double)), MonadIO m) => MethodInfo TagListGetDoubleMethodInfo TagList signature where
+    overloadedMethod _ = tagListGetDouble
+
+-- method TagList::get_double_index
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TDouble, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_tag_list_get_double_index" gst_tag_list_get_double_index :: 
+    Ptr TagList ->                          -- _obj : TInterface "Gst" "TagList"
+    CString ->                              -- tag : TBasicType TUTF8
+    Word32 ->                               -- index : TBasicType TUInt32
+    Ptr CDouble ->                          -- value : TBasicType TDouble
+    IO CInt
+
+
+tagListGetDoubleIndex ::
+    (MonadIO m) =>
+    TagList                                 -- _obj
+    -> T.Text                               -- tag
+    -> Word32                               -- index
+    -> m (Bool,Double)                      -- result
+tagListGetDoubleIndex _obj tag index = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    tag' <- textToCString tag
+    value <- allocMem :: IO (Ptr CDouble)
+    result <- gst_tag_list_get_double_index _obj' tag' index value
+    let result' = (/= 0) result
+    value' <- peek value
+    let value'' = realToFrac value'
+    touchManagedPtr _obj
+    freeMem tag'
+    freeMem value
+    return (result', value'')
+
+data TagListGetDoubleIndexMethodInfo
+instance (signature ~ (T.Text -> Word32 -> m (Bool,Double)), MonadIO m) => MethodInfo TagListGetDoubleIndexMethodInfo TagList signature where
+    overloadedMethod _ = tagListGetDoubleIndex
+
+-- method TagList::get_float
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TFloat, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_tag_list_get_float" gst_tag_list_get_float :: 
+    Ptr TagList ->                          -- _obj : TInterface "Gst" "TagList"
+    CString ->                              -- tag : TBasicType TUTF8
+    Ptr CFloat ->                           -- value : TBasicType TFloat
+    IO CInt
+
+
+tagListGetFloat ::
+    (MonadIO m) =>
+    TagList                                 -- _obj
+    -> T.Text                               -- tag
+    -> m (Bool,Float)                       -- result
+tagListGetFloat _obj tag = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    tag' <- textToCString tag
+    value <- allocMem :: IO (Ptr CFloat)
+    result <- gst_tag_list_get_float _obj' tag' value
+    let result' = (/= 0) result
+    value' <- peek value
+    let value'' = realToFrac value'
+    touchManagedPtr _obj
+    freeMem tag'
+    freeMem value
+    return (result', value'')
+
+data TagListGetFloatMethodInfo
+instance (signature ~ (T.Text -> m (Bool,Float)), MonadIO m) => MethodInfo TagListGetFloatMethodInfo TagList signature where
+    overloadedMethod _ = tagListGetFloat
+
+-- method TagList::get_float_index
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TFloat, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_tag_list_get_float_index" gst_tag_list_get_float_index :: 
+    Ptr TagList ->                          -- _obj : TInterface "Gst" "TagList"
+    CString ->                              -- tag : TBasicType TUTF8
+    Word32 ->                               -- index : TBasicType TUInt32
+    Ptr CFloat ->                           -- value : TBasicType TFloat
+    IO CInt
+
+
+tagListGetFloatIndex ::
+    (MonadIO m) =>
+    TagList                                 -- _obj
+    -> T.Text                               -- tag
+    -> Word32                               -- index
+    -> m (Bool,Float)                       -- result
+tagListGetFloatIndex _obj tag index = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    tag' <- textToCString tag
+    value <- allocMem :: IO (Ptr CFloat)
+    result <- gst_tag_list_get_float_index _obj' tag' index value
+    let result' = (/= 0) result
+    value' <- peek value
+    let value'' = realToFrac value'
+    touchManagedPtr _obj
+    freeMem tag'
+    freeMem value
+    return (result', value'')
+
+data TagListGetFloatIndexMethodInfo
+instance (signature ~ (T.Text -> Word32 -> m (Bool,Float)), MonadIO m) => MethodInfo TagListGetFloatIndexMethodInfo TagList signature where
+    overloadedMethod _ = tagListGetFloatIndex
+
+-- method TagList::get_int
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_tag_list_get_int" gst_tag_list_get_int :: 
+    Ptr TagList ->                          -- _obj : TInterface "Gst" "TagList"
+    CString ->                              -- tag : TBasicType TUTF8
+    Ptr Int32 ->                            -- value : TBasicType TInt32
+    IO CInt
+
+
+tagListGetInt ::
+    (MonadIO m) =>
+    TagList                                 -- _obj
+    -> T.Text                               -- tag
+    -> m (Bool,Int32)                       -- result
+tagListGetInt _obj tag = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    tag' <- textToCString tag
+    value <- allocMem :: IO (Ptr Int32)
+    result <- gst_tag_list_get_int _obj' tag' value
+    let result' = (/= 0) result
+    value' <- peek value
+    touchManagedPtr _obj
+    freeMem tag'
+    freeMem value
+    return (result', value')
+
+data TagListGetIntMethodInfo
+instance (signature ~ (T.Text -> m (Bool,Int32)), MonadIO m) => MethodInfo TagListGetIntMethodInfo TagList signature where
+    overloadedMethod _ = tagListGetInt
+
+-- method TagList::get_int64
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_tag_list_get_int64" gst_tag_list_get_int64 :: 
+    Ptr TagList ->                          -- _obj : TInterface "Gst" "TagList"
+    CString ->                              -- tag : TBasicType TUTF8
+    Int64 ->                                -- value : TBasicType TInt64
+    IO CInt
+
+
+tagListGetInt64 ::
+    (MonadIO m) =>
+    TagList                                 -- _obj
+    -> T.Text                               -- tag
+    -> Int64                                -- value
+    -> m Bool                               -- result
+tagListGetInt64 _obj tag value = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    tag' <- textToCString tag
+    result <- gst_tag_list_get_int64 _obj' tag' value
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    freeMem tag'
+    return result'
+
+data TagListGetInt64MethodInfo
+instance (signature ~ (T.Text -> Int64 -> m Bool), MonadIO m) => MethodInfo TagListGetInt64MethodInfo TagList signature where
+    overloadedMethod _ = tagListGetInt64
+
+-- method TagList::get_int64_index
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_tag_list_get_int64_index" gst_tag_list_get_int64_index :: 
+    Ptr TagList ->                          -- _obj : TInterface "Gst" "TagList"
+    CString ->                              -- tag : TBasicType TUTF8
+    Word32 ->                               -- index : TBasicType TUInt32
+    Ptr Int64 ->                            -- value : TBasicType TInt64
+    IO CInt
+
+
+tagListGetInt64Index ::
+    (MonadIO m) =>
+    TagList                                 -- _obj
+    -> T.Text                               -- tag
+    -> Word32                               -- index
+    -> m (Bool,Int64)                       -- result
+tagListGetInt64Index _obj tag index = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    tag' <- textToCString tag
+    value <- allocMem :: IO (Ptr Int64)
+    result <- gst_tag_list_get_int64_index _obj' tag' index value
+    let result' = (/= 0) result
+    value' <- peek value
+    touchManagedPtr _obj
+    freeMem tag'
+    freeMem value
+    return (result', value')
+
+data TagListGetInt64IndexMethodInfo
+instance (signature ~ (T.Text -> Word32 -> m (Bool,Int64)), MonadIO m) => MethodInfo TagListGetInt64IndexMethodInfo TagList signature where
+    overloadedMethod _ = tagListGetInt64Index
+
+-- method TagList::get_int_index
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_tag_list_get_int_index" gst_tag_list_get_int_index :: 
+    Ptr TagList ->                          -- _obj : TInterface "Gst" "TagList"
+    CString ->                              -- tag : TBasicType TUTF8
+    Word32 ->                               -- index : TBasicType TUInt32
+    Ptr Int32 ->                            -- value : TBasicType TInt32
+    IO CInt
+
+
+tagListGetIntIndex ::
+    (MonadIO m) =>
+    TagList                                 -- _obj
+    -> T.Text                               -- tag
+    -> Word32                               -- index
+    -> m (Bool,Int32)                       -- result
+tagListGetIntIndex _obj tag index = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    tag' <- textToCString tag
+    value <- allocMem :: IO (Ptr Int32)
+    result <- gst_tag_list_get_int_index _obj' tag' index value
+    let result' = (/= 0) result
+    value' <- peek value
+    touchManagedPtr _obj
+    freeMem tag'
+    freeMem value
+    return (result', value')
+
+data TagListGetIntIndexMethodInfo
+instance (signature ~ (T.Text -> Word32 -> m (Bool,Int32)), MonadIO m) => MethodInfo TagListGetIntIndexMethodInfo TagList signature where
+    overloadedMethod _ = tagListGetIntIndex
+
+-- method TagList::get_pointer
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TVoid, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_tag_list_get_pointer" gst_tag_list_get_pointer :: 
+    Ptr TagList ->                          -- _obj : TInterface "Gst" "TagList"
+    CString ->                              -- tag : TBasicType TUTF8
+    Ptr (Ptr ()) ->                         -- value : TBasicType TVoid
+    IO CInt
+
+
+tagListGetPointer ::
+    (MonadIO m) =>
+    TagList                                 -- _obj
+    -> T.Text                               -- tag
+    -> m (Bool,(Ptr ()))                    -- result
+tagListGetPointer _obj tag = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    tag' <- textToCString tag
+    value <- allocMem :: IO (Ptr (Ptr ()))
+    result <- gst_tag_list_get_pointer _obj' tag' value
+    let result' = (/= 0) result
+    value' <- peek value
+    touchManagedPtr _obj
+    freeMem tag'
+    freeMem value
+    return (result', value')
+
+data TagListGetPointerMethodInfo
+instance (signature ~ (T.Text -> m (Bool,(Ptr ()))), MonadIO m) => MethodInfo TagListGetPointerMethodInfo TagList signature where
+    overloadedMethod _ = tagListGetPointer
+
+-- method TagList::get_pointer_index
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TVoid, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_tag_list_get_pointer_index" gst_tag_list_get_pointer_index :: 
+    Ptr TagList ->                          -- _obj : TInterface "Gst" "TagList"
+    CString ->                              -- tag : TBasicType TUTF8
+    Word32 ->                               -- index : TBasicType TUInt32
+    Ptr (Ptr ()) ->                         -- value : TBasicType TVoid
+    IO CInt
+
+
+tagListGetPointerIndex ::
+    (MonadIO m) =>
+    TagList                                 -- _obj
+    -> T.Text                               -- tag
+    -> Word32                               -- index
+    -> m (Bool,(Ptr ()))                    -- result
+tagListGetPointerIndex _obj tag index = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    tag' <- textToCString tag
+    value <- allocMem :: IO (Ptr (Ptr ()))
+    result <- gst_tag_list_get_pointer_index _obj' tag' index value
+    let result' = (/= 0) result
+    value' <- peek value
+    touchManagedPtr _obj
+    freeMem tag'
+    freeMem value
+    return (result', value')
+
+data TagListGetPointerIndexMethodInfo
+instance (signature ~ (T.Text -> Word32 -> m (Bool,(Ptr ()))), MonadIO m) => MethodInfo TagListGetPointerIndexMethodInfo TagList signature where
+    overloadedMethod _ = tagListGetPointerIndex
+
+-- method TagList::get_sample
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "sample", argType = TInterface "Gst" "Sample", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_tag_list_get_sample" gst_tag_list_get_sample :: 
+    Ptr TagList ->                          -- _obj : TInterface "Gst" "TagList"
+    CString ->                              -- tag : TBasicType TUTF8
+    Ptr (Ptr Sample) ->                     -- sample : TInterface "Gst" "Sample"
+    IO CInt
+
+
+tagListGetSample ::
+    (MonadIO m) =>
+    TagList                                 -- _obj
+    -> T.Text                               -- tag
+    -> m (Bool,Sample)                      -- result
+tagListGetSample _obj tag = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    tag' <- textToCString tag
+    sample <- allocMem :: IO (Ptr (Ptr Sample))
+    result <- gst_tag_list_get_sample _obj' tag' sample
+    let result' = (/= 0) result
+    sample' <- peek sample
+    sample'' <- (wrapBoxed Sample) sample'
+    touchManagedPtr _obj
+    freeMem tag'
+    freeMem sample
+    return (result', sample'')
+
+data TagListGetSampleMethodInfo
+instance (signature ~ (T.Text -> m (Bool,Sample)), MonadIO m) => MethodInfo TagListGetSampleMethodInfo TagList signature where
+    overloadedMethod _ = tagListGetSample
+
+-- method TagList::get_sample_index
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "sample", argType = TInterface "Gst" "Sample", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_tag_list_get_sample_index" gst_tag_list_get_sample_index :: 
+    Ptr TagList ->                          -- _obj : TInterface "Gst" "TagList"
+    CString ->                              -- tag : TBasicType TUTF8
+    Word32 ->                               -- index : TBasicType TUInt32
+    Ptr (Ptr Sample) ->                     -- sample : TInterface "Gst" "Sample"
+    IO CInt
+
+
+tagListGetSampleIndex ::
+    (MonadIO m) =>
+    TagList                                 -- _obj
+    -> T.Text                               -- tag
+    -> Word32                               -- index
+    -> m (Bool,Sample)                      -- result
+tagListGetSampleIndex _obj tag index = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    tag' <- textToCString tag
+    sample <- allocMem :: IO (Ptr (Ptr Sample))
+    result <- gst_tag_list_get_sample_index _obj' tag' index sample
+    let result' = (/= 0) result
+    sample' <- peek sample
+    sample'' <- (wrapBoxed Sample) sample'
+    touchManagedPtr _obj
+    freeMem tag'
+    freeMem sample
+    return (result', sample'')
+
+data TagListGetSampleIndexMethodInfo
+instance (signature ~ (T.Text -> Word32 -> m (Bool,Sample)), MonadIO m) => MethodInfo TagListGetSampleIndexMethodInfo TagList signature where
+    overloadedMethod _ = tagListGetSampleIndex
+
+-- method TagList::get_scope
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "TagScope"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_tag_list_get_scope" gst_tag_list_get_scope :: 
+    Ptr TagList ->                          -- _obj : TInterface "Gst" "TagList"
+    IO CUInt
+
+
+tagListGetScope ::
+    (MonadIO m) =>
+    TagList                                 -- _obj
+    -> m TagScope                           -- result
+tagListGetScope _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_tag_list_get_scope _obj'
+    let result' = (toEnum . fromIntegral) result
+    touchManagedPtr _obj
+    return result'
+
+data TagListGetScopeMethodInfo
+instance (signature ~ (m TagScope), MonadIO m) => MethodInfo TagListGetScopeMethodInfo TagList signature where
+    overloadedMethod _ = tagListGetScope
+
+-- method TagList::get_string
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_tag_list_get_string" gst_tag_list_get_string :: 
+    Ptr TagList ->                          -- _obj : TInterface "Gst" "TagList"
+    CString ->                              -- tag : TBasicType TUTF8
+    Ptr CString ->                          -- value : TBasicType TUTF8
+    IO CInt
+
+
+tagListGetString ::
+    (MonadIO m) =>
+    TagList                                 -- _obj
+    -> T.Text                               -- tag
+    -> m (Bool,T.Text)                      -- result
+tagListGetString _obj tag = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    tag' <- textToCString tag
+    value <- allocMem :: IO (Ptr CString)
+    result <- gst_tag_list_get_string _obj' tag' value
+    let result' = (/= 0) result
+    value' <- peek value
+    value'' <- cstringToText value'
+    freeMem value'
+    touchManagedPtr _obj
+    freeMem tag'
+    freeMem value
+    return (result', value'')
+
+data TagListGetStringMethodInfo
+instance (signature ~ (T.Text -> m (Bool,T.Text)), MonadIO m) => MethodInfo TagListGetStringMethodInfo TagList signature where
+    overloadedMethod _ = tagListGetString
+
+-- method TagList::get_string_index
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_tag_list_get_string_index" gst_tag_list_get_string_index :: 
+    Ptr TagList ->                          -- _obj : TInterface "Gst" "TagList"
+    CString ->                              -- tag : TBasicType TUTF8
+    Word32 ->                               -- index : TBasicType TUInt32
+    Ptr CString ->                          -- value : TBasicType TUTF8
+    IO CInt
+
+
+tagListGetStringIndex ::
+    (MonadIO m) =>
+    TagList                                 -- _obj
+    -> T.Text                               -- tag
+    -> Word32                               -- index
+    -> m (Bool,T.Text)                      -- result
+tagListGetStringIndex _obj tag index = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    tag' <- textToCString tag
+    value <- allocMem :: IO (Ptr CString)
+    result <- gst_tag_list_get_string_index _obj' tag' index value
+    let result' = (/= 0) result
+    value' <- peek value
+    value'' <- cstringToText value'
+    freeMem value'
+    touchManagedPtr _obj
+    freeMem tag'
+    freeMem value
+    return (result', value'')
+
+data TagListGetStringIndexMethodInfo
+instance (signature ~ (T.Text -> Word32 -> m (Bool,T.Text)), MonadIO m) => MethodInfo TagListGetStringIndexMethodInfo TagList signature where
+    overloadedMethod _ = tagListGetStringIndex
+
+-- method TagList::get_tag_size
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUInt32
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_tag_list_get_tag_size" gst_tag_list_get_tag_size :: 
+    Ptr TagList ->                          -- _obj : TInterface "Gst" "TagList"
+    CString ->                              -- tag : TBasicType TUTF8
+    IO Word32
+
+
+tagListGetTagSize ::
+    (MonadIO m) =>
+    TagList                                 -- _obj
+    -> T.Text                               -- tag
+    -> m Word32                             -- result
+tagListGetTagSize _obj tag = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    tag' <- textToCString tag
+    result <- gst_tag_list_get_tag_size _obj' tag'
+    touchManagedPtr _obj
+    freeMem tag'
+    return result
+
+data TagListGetTagSizeMethodInfo
+instance (signature ~ (T.Text -> m Word32), MonadIO m) => MethodInfo TagListGetTagSizeMethodInfo TagList signature where
+    overloadedMethod _ = tagListGetTagSize
+
+-- method TagList::get_uint
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_tag_list_get_uint" gst_tag_list_get_uint :: 
+    Ptr TagList ->                          -- _obj : TInterface "Gst" "TagList"
+    CString ->                              -- tag : TBasicType TUTF8
+    Ptr Word32 ->                           -- value : TBasicType TUInt32
+    IO CInt
+
+
+tagListGetUint ::
+    (MonadIO m) =>
+    TagList                                 -- _obj
+    -> T.Text                               -- tag
+    -> m (Bool,Word32)                      -- result
+tagListGetUint _obj tag = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    tag' <- textToCString tag
+    value <- allocMem :: IO (Ptr Word32)
+    result <- gst_tag_list_get_uint _obj' tag' value
+    let result' = (/= 0) result
+    value' <- peek value
+    touchManagedPtr _obj
+    freeMem tag'
+    freeMem value
+    return (result', value')
+
+data TagListGetUintMethodInfo
+instance (signature ~ (T.Text -> m (Bool,Word32)), MonadIO m) => MethodInfo TagListGetUintMethodInfo TagList signature where
+    overloadedMethod _ = tagListGetUint
+
+-- method TagList::get_uint64
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_tag_list_get_uint64" gst_tag_list_get_uint64 :: 
+    Ptr TagList ->                          -- _obj : TInterface "Gst" "TagList"
+    CString ->                              -- tag : TBasicType TUTF8
+    Ptr Word64 ->                           -- value : TBasicType TUInt64
+    IO CInt
+
+
+tagListGetUint64 ::
+    (MonadIO m) =>
+    TagList                                 -- _obj
+    -> T.Text                               -- tag
+    -> m (Bool,Word64)                      -- result
+tagListGetUint64 _obj tag = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    tag' <- textToCString tag
+    value <- allocMem :: IO (Ptr Word64)
+    result <- gst_tag_list_get_uint64 _obj' tag' value
+    let result' = (/= 0) result
+    value' <- peek value
+    touchManagedPtr _obj
+    freeMem tag'
+    freeMem value
+    return (result', value')
+
+data TagListGetUint64MethodInfo
+instance (signature ~ (T.Text -> m (Bool,Word64)), MonadIO m) => MethodInfo TagListGetUint64MethodInfo TagList signature where
+    overloadedMethod _ = tagListGetUint64
+
+-- method TagList::get_uint64_index
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_tag_list_get_uint64_index" gst_tag_list_get_uint64_index :: 
+    Ptr TagList ->                          -- _obj : TInterface "Gst" "TagList"
+    CString ->                              -- tag : TBasicType TUTF8
+    Word32 ->                               -- index : TBasicType TUInt32
+    Ptr Word64 ->                           -- value : TBasicType TUInt64
+    IO CInt
+
+
+tagListGetUint64Index ::
+    (MonadIO m) =>
+    TagList                                 -- _obj
+    -> T.Text                               -- tag
+    -> Word32                               -- index
+    -> m (Bool,Word64)                      -- result
+tagListGetUint64Index _obj tag index = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    tag' <- textToCString tag
+    value <- allocMem :: IO (Ptr Word64)
+    result <- gst_tag_list_get_uint64_index _obj' tag' index value
+    let result' = (/= 0) result
+    value' <- peek value
+    touchManagedPtr _obj
+    freeMem tag'
+    freeMem value
+    return (result', value')
+
+data TagListGetUint64IndexMethodInfo
+instance (signature ~ (T.Text -> Word32 -> m (Bool,Word64)), MonadIO m) => MethodInfo TagListGetUint64IndexMethodInfo TagList signature where
+    overloadedMethod _ = tagListGetUint64Index
+
+-- method TagList::get_uint_index
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_tag_list_get_uint_index" gst_tag_list_get_uint_index :: 
+    Ptr TagList ->                          -- _obj : TInterface "Gst" "TagList"
+    CString ->                              -- tag : TBasicType TUTF8
+    Word32 ->                               -- index : TBasicType TUInt32
+    Ptr Word32 ->                           -- value : TBasicType TUInt32
+    IO CInt
+
+
+tagListGetUintIndex ::
+    (MonadIO m) =>
+    TagList                                 -- _obj
+    -> T.Text                               -- tag
+    -> Word32                               -- index
+    -> m (Bool,Word32)                      -- result
+tagListGetUintIndex _obj tag index = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    tag' <- textToCString tag
+    value <- allocMem :: IO (Ptr Word32)
+    result <- gst_tag_list_get_uint_index _obj' tag' index value
+    let result' = (/= 0) result
+    value' <- peek value
+    touchManagedPtr _obj
+    freeMem tag'
+    freeMem value
+    return (result', value')
+
+data TagListGetUintIndexMethodInfo
+instance (signature ~ (T.Text -> Word32 -> m (Bool,Word32)), MonadIO m) => MethodInfo TagListGetUintIndexMethodInfo TagList signature where
+    overloadedMethod _ = tagListGetUintIndex
+
+-- method TagList::get_value_index
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "GObject" "Value"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_tag_list_get_value_index" gst_tag_list_get_value_index :: 
+    Ptr TagList ->                          -- _obj : TInterface "Gst" "TagList"
+    CString ->                              -- tag : TBasicType TUTF8
+    Word32 ->                               -- index : TBasicType TUInt32
+    IO (Ptr GValue)
+
+
+tagListGetValueIndex ::
+    (MonadIO m) =>
+    TagList                                 -- _obj
+    -> T.Text                               -- tag
+    -> Word32                               -- index
+    -> m GValue                             -- result
+tagListGetValueIndex _obj tag index = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    tag' <- textToCString tag
+    result <- gst_tag_list_get_value_index _obj' tag' index
+    checkUnexpectedReturnNULL "gst_tag_list_get_value_index" result
+    result' <- (newBoxed GValue) result
+    touchManagedPtr _obj
+    freeMem tag'
+    return result'
+
+data TagListGetValueIndexMethodInfo
+instance (signature ~ (T.Text -> Word32 -> m GValue), MonadIO m) => MethodInfo TagListGetValueIndexMethodInfo TagList signature where
+    overloadedMethod _ = tagListGetValueIndex
+
+-- method TagList::insert
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "from", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mode", argType = TInterface "Gst" "TagMergeMode", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_tag_list_insert" gst_tag_list_insert :: 
+    Ptr TagList ->                          -- _obj : TInterface "Gst" "TagList"
+    Ptr TagList ->                          -- from : TInterface "Gst" "TagList"
+    CUInt ->                                -- mode : TInterface "Gst" "TagMergeMode"
+    IO ()
+
+
+tagListInsert ::
+    (MonadIO m) =>
+    TagList                                 -- _obj
+    -> TagList                              -- from
+    -> TagMergeMode                         -- mode
+    -> m ()                                 -- result
+tagListInsert _obj from mode = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let from' = unsafeManagedPtrGetPtr from
+    let mode' = (fromIntegral . fromEnum) mode
+    gst_tag_list_insert _obj' from' mode'
+    touchManagedPtr _obj
+    touchManagedPtr from
+    return ()
+
+data TagListInsertMethodInfo
+instance (signature ~ (TagList -> TagMergeMode -> m ()), MonadIO m) => MethodInfo TagListInsertMethodInfo TagList signature where
+    overloadedMethod _ = tagListInsert
+
+-- method TagList::is_empty
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_tag_list_is_empty" gst_tag_list_is_empty :: 
+    Ptr TagList ->                          -- _obj : TInterface "Gst" "TagList"
+    IO CInt
+
+
+tagListIsEmpty ::
+    (MonadIO m) =>
+    TagList                                 -- _obj
+    -> m Bool                               -- result
+tagListIsEmpty _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_tag_list_is_empty _obj'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data TagListIsEmptyMethodInfo
+instance (signature ~ (m Bool), MonadIO m) => MethodInfo TagListIsEmptyMethodInfo TagList signature where
+    overloadedMethod _ = tagListIsEmpty
+
+-- method TagList::is_equal
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "list2", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_tag_list_is_equal" gst_tag_list_is_equal :: 
+    Ptr TagList ->                          -- _obj : TInterface "Gst" "TagList"
+    Ptr TagList ->                          -- list2 : TInterface "Gst" "TagList"
+    IO CInt
+
+
+tagListIsEqual ::
+    (MonadIO m) =>
+    TagList                                 -- _obj
+    -> TagList                              -- list2
+    -> m Bool                               -- result
+tagListIsEqual _obj list2 = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let list2' = unsafeManagedPtrGetPtr list2
+    result <- gst_tag_list_is_equal _obj' list2'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    touchManagedPtr list2
+    return result'
+
+data TagListIsEqualMethodInfo
+instance (signature ~ (TagList -> m Bool), MonadIO m) => MethodInfo TagListIsEqualMethodInfo TagList signature where
+    overloadedMethod _ = tagListIsEqual
+
+-- method TagList::merge
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "list2", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mode", argType = TInterface "Gst" "TagMergeMode", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "TagList"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_tag_list_merge" gst_tag_list_merge :: 
+    Ptr TagList ->                          -- _obj : TInterface "Gst" "TagList"
+    Ptr TagList ->                          -- list2 : TInterface "Gst" "TagList"
+    CUInt ->                                -- mode : TInterface "Gst" "TagMergeMode"
+    IO (Ptr TagList)
+
+
+tagListMerge ::
+    (MonadIO m) =>
+    TagList                                 -- _obj
+    -> Maybe (TagList)                      -- list2
+    -> TagMergeMode                         -- mode
+    -> m TagList                            -- result
+tagListMerge _obj list2 mode = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    maybeList2 <- case list2 of
+        Nothing -> return nullPtr
+        Just jList2 -> do
+            let jList2' = unsafeManagedPtrGetPtr jList2
+            return jList2'
+    let mode' = (fromIntegral . fromEnum) mode
+    result <- gst_tag_list_merge _obj' maybeList2 mode'
+    checkUnexpectedReturnNULL "gst_tag_list_merge" result
+    result' <- (wrapBoxed TagList) result
+    touchManagedPtr _obj
+    whenJust list2 touchManagedPtr
+    return result'
+
+data TagListMergeMethodInfo
+instance (signature ~ (Maybe (TagList) -> TagMergeMode -> m TagList), MonadIO m) => MethodInfo TagListMergeMethodInfo TagList signature where
+    overloadedMethod _ = tagListMerge
+
+-- method TagList::n_tags
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TInt32
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_tag_list_n_tags" gst_tag_list_n_tags :: 
+    Ptr TagList ->                          -- _obj : TInterface "Gst" "TagList"
+    IO Int32
+
+
+tagListNTags ::
+    (MonadIO m) =>
+    TagList                                 -- _obj
+    -> m Int32                              -- result
+tagListNTags _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_tag_list_n_tags _obj'
+    touchManagedPtr _obj
+    return result
+
+data TagListNTagsMethodInfo
+instance (signature ~ (m Int32), MonadIO m) => MethodInfo TagListNTagsMethodInfo TagList signature where
+    overloadedMethod _ = tagListNTags
+
+-- method TagList::nth_tag_name
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUTF8
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_tag_list_nth_tag_name" gst_tag_list_nth_tag_name :: 
+    Ptr TagList ->                          -- _obj : TInterface "Gst" "TagList"
+    Word32 ->                               -- index : TBasicType TUInt32
+    IO CString
+
+
+tagListNthTagName ::
+    (MonadIO m) =>
+    TagList                                 -- _obj
+    -> Word32                               -- index
+    -> m T.Text                             -- result
+tagListNthTagName _obj index = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_tag_list_nth_tag_name _obj' index
+    checkUnexpectedReturnNULL "gst_tag_list_nth_tag_name" result
+    result' <- cstringToText result
+    touchManagedPtr _obj
+    return result'
+
+data TagListNthTagNameMethodInfo
+instance (signature ~ (Word32 -> m T.Text), MonadIO m) => MethodInfo TagListNthTagNameMethodInfo TagList signature where
+    overloadedMethod _ = tagListNthTagName
+
+-- method TagList::peek_string_index
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "index", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_tag_list_peek_string_index" gst_tag_list_peek_string_index :: 
+    Ptr TagList ->                          -- _obj : TInterface "Gst" "TagList"
+    CString ->                              -- tag : TBasicType TUTF8
+    Word32 ->                               -- index : TBasicType TUInt32
+    Ptr CString ->                          -- value : TBasicType TUTF8
+    IO CInt
+
+
+tagListPeekStringIndex ::
+    (MonadIO m) =>
+    TagList                                 -- _obj
+    -> T.Text                               -- tag
+    -> Word32                               -- index
+    -> m (Bool,T.Text)                      -- result
+tagListPeekStringIndex _obj tag index = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    tag' <- textToCString tag
+    value <- allocMem :: IO (Ptr CString)
+    result <- gst_tag_list_peek_string_index _obj' tag' index value
+    let result' = (/= 0) result
+    value' <- peek value
+    value'' <- cstringToText value'
+    touchManagedPtr _obj
+    freeMem tag'
+    freeMem value
+    return (result', value'')
+
+data TagListPeekStringIndexMethodInfo
+instance (signature ~ (T.Text -> Word32 -> m (Bool,T.Text)), MonadIO m) => MethodInfo TagListPeekStringIndexMethodInfo TagList signature where
+    overloadedMethod _ = tagListPeekStringIndex
+
+-- method TagList::remove_tag
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_tag_list_remove_tag" gst_tag_list_remove_tag :: 
+    Ptr TagList ->                          -- _obj : TInterface "Gst" "TagList"
+    CString ->                              -- tag : TBasicType TUTF8
+    IO ()
+
+
+tagListRemoveTag ::
+    (MonadIO m) =>
+    TagList                                 -- _obj
+    -> T.Text                               -- tag
+    -> m ()                                 -- result
+tagListRemoveTag _obj tag = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    tag' <- textToCString tag
+    gst_tag_list_remove_tag _obj' tag'
+    touchManagedPtr _obj
+    freeMem tag'
+    return ()
+
+data TagListRemoveTagMethodInfo
+instance (signature ~ (T.Text -> m ()), MonadIO m) => MethodInfo TagListRemoveTagMethodInfo TagList signature where
+    overloadedMethod _ = tagListRemoveTag
+
+-- method TagList::set_scope
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "scope", argType = TInterface "Gst" "TagScope", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_tag_list_set_scope" gst_tag_list_set_scope :: 
+    Ptr TagList ->                          -- _obj : TInterface "Gst" "TagList"
+    CUInt ->                                -- scope : TInterface "Gst" "TagScope"
+    IO ()
+
+
+tagListSetScope ::
+    (MonadIO m) =>
+    TagList                                 -- _obj
+    -> TagScope                             -- scope
+    -> m ()                                 -- result
+tagListSetScope _obj scope = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let scope' = (fromIntegral . fromEnum) scope
+    gst_tag_list_set_scope _obj' scope'
+    touchManagedPtr _obj
+    return ()
+
+data TagListSetScopeMethodInfo
+instance (signature ~ (TagScope -> m ()), MonadIO m) => MethodInfo TagListSetScopeMethodInfo TagList signature where
+    overloadedMethod _ = tagListSetScope
+
+-- method TagList::to_string
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUTF8
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_tag_list_to_string" gst_tag_list_to_string :: 
+    Ptr TagList ->                          -- _obj : TInterface "Gst" "TagList"
+    IO CString
+
+
+tagListToString ::
+    (MonadIO m) =>
+    TagList                                 -- _obj
+    -> m T.Text                             -- result
+tagListToString _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_tag_list_to_string _obj'
+    checkUnexpectedReturnNULL "gst_tag_list_to_string" result
+    result' <- cstringToText result
+    freeMem result
+    touchManagedPtr _obj
+    return result'
+
+data TagListToStringMethodInfo
+instance (signature ~ (m T.Text), MonadIO m) => MethodInfo TagListToStringMethodInfo TagList signature where
+    overloadedMethod _ = tagListToString
+
+-- method TagList::copy_value
+-- method type : MemberFunction
+-- Args : [Arg {argCName = "dest", argType = TInterface "GObject" "Value", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing},Arg {argCName = "list", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tag", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_tag_list_copy_value" gst_tag_list_copy_value :: 
+    Ptr GValue ->                           -- dest : TInterface "GObject" "Value"
+    Ptr TagList ->                          -- list : TInterface "Gst" "TagList"
+    CString ->                              -- tag : TBasicType TUTF8
+    IO CInt
+
+
+tagListCopyValue ::
+    (MonadIO m) =>
+    TagList                                 -- list
+    -> T.Text                               -- tag
+    -> m (Bool,GValue)                      -- result
+tagListCopyValue list tag = liftIO $ do
+    dest <- callocBoxedBytes 24 :: IO (Ptr GValue)
+    let list' = unsafeManagedPtrGetPtr list
+    tag' <- textToCString tag
+    result <- gst_tag_list_copy_value dest list' tag'
+    let result' = (/= 0) result
+    dest' <- (wrapBoxed GValue) dest
+    touchManagedPtr list
+    freeMem tag'
+    return (result', dest')
+
+type family ResolveTagListMethod (t :: Symbol) (o :: *) :: * where
+    ResolveTagListMethod "addValue" o = TagListAddValueMethodInfo
+    ResolveTagListMethod "foreach" o = TagListForeachMethodInfo
+    ResolveTagListMethod "insert" o = TagListInsertMethodInfo
+    ResolveTagListMethod "isEmpty" o = TagListIsEmptyMethodInfo
+    ResolveTagListMethod "isEqual" o = TagListIsEqualMethodInfo
+    ResolveTagListMethod "merge" o = TagListMergeMethodInfo
+    ResolveTagListMethod "nTags" o = TagListNTagsMethodInfo
+    ResolveTagListMethod "nthTagName" o = TagListNthTagNameMethodInfo
+    ResolveTagListMethod "peekStringIndex" o = TagListPeekStringIndexMethodInfo
+    ResolveTagListMethod "removeTag" o = TagListRemoveTagMethodInfo
+    ResolveTagListMethod "toString" o = TagListToStringMethodInfo
+    ResolveTagListMethod "getBoolean" o = TagListGetBooleanMethodInfo
+    ResolveTagListMethod "getBooleanIndex" o = TagListGetBooleanIndexMethodInfo
+    ResolveTagListMethod "getDate" o = TagListGetDateMethodInfo
+    ResolveTagListMethod "getDateIndex" o = TagListGetDateIndexMethodInfo
+    ResolveTagListMethod "getDateTime" o = TagListGetDateTimeMethodInfo
+    ResolveTagListMethod "getDateTimeIndex" o = TagListGetDateTimeIndexMethodInfo
+    ResolveTagListMethod "getDouble" o = TagListGetDoubleMethodInfo
+    ResolveTagListMethod "getDoubleIndex" o = TagListGetDoubleIndexMethodInfo
+    ResolveTagListMethod "getFloat" o = TagListGetFloatMethodInfo
+    ResolveTagListMethod "getFloatIndex" o = TagListGetFloatIndexMethodInfo
+    ResolveTagListMethod "getInt" o = TagListGetIntMethodInfo
+    ResolveTagListMethod "getInt64" o = TagListGetInt64MethodInfo
+    ResolveTagListMethod "getInt64Index" o = TagListGetInt64IndexMethodInfo
+    ResolveTagListMethod "getIntIndex" o = TagListGetIntIndexMethodInfo
+    ResolveTagListMethod "getPointer" o = TagListGetPointerMethodInfo
+    ResolveTagListMethod "getPointerIndex" o = TagListGetPointerIndexMethodInfo
+    ResolveTagListMethod "getSample" o = TagListGetSampleMethodInfo
+    ResolveTagListMethod "getSampleIndex" o = TagListGetSampleIndexMethodInfo
+    ResolveTagListMethod "getScope" o = TagListGetScopeMethodInfo
+    ResolveTagListMethod "getString" o = TagListGetStringMethodInfo
+    ResolveTagListMethod "getStringIndex" o = TagListGetStringIndexMethodInfo
+    ResolveTagListMethod "getTagSize" o = TagListGetTagSizeMethodInfo
+    ResolveTagListMethod "getUint" o = TagListGetUintMethodInfo
+    ResolveTagListMethod "getUint64" o = TagListGetUint64MethodInfo
+    ResolveTagListMethod "getUint64Index" o = TagListGetUint64IndexMethodInfo
+    ResolveTagListMethod "getUintIndex" o = TagListGetUintIndexMethodInfo
+    ResolveTagListMethod "getValueIndex" o = TagListGetValueIndexMethodInfo
+    ResolveTagListMethod "setScope" o = TagListSetScopeMethodInfo
+    ResolveTagListMethod l o = MethodResolutionFailed l o
+
+instance (info ~ ResolveTagListMethod t TagList, MethodInfo info TagList p) => IsLabelProxy t (TagList -> p) where
+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)
+
+#if MIN_VERSION_base(4,9,0)
+instance (info ~ ResolveTagListMethod t TagList, MethodInfo info TagList p) => IsLabel t (TagList -> p) where
+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)
+#endif
+
+
diff --git a/GI/Gst/Structs/TagList.hs-boot b/GI/Gst/Structs/TagList.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/TagList.hs-boot
@@ -0,0 +1,50 @@
+module GI.Gst.Structs.TagList where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+newtype TagList = TagList (ForeignPtr TagList)
+instance BoxedObject TagList where
+data TagListAddValueMethodInfo
+data TagListForeachMethodInfo
+data TagListGetBooleanMethodInfo
+data TagListGetBooleanIndexMethodInfo
+data TagListGetDateMethodInfo
+data TagListGetDateIndexMethodInfo
+data TagListGetDateTimeMethodInfo
+data TagListGetDateTimeIndexMethodInfo
+data TagListGetDoubleMethodInfo
+data TagListGetDoubleIndexMethodInfo
+data TagListGetFloatMethodInfo
+data TagListGetFloatIndexMethodInfo
+data TagListGetIntMethodInfo
+data TagListGetInt64MethodInfo
+data TagListGetInt64IndexMethodInfo
+data TagListGetIntIndexMethodInfo
+data TagListGetPointerMethodInfo
+data TagListGetPointerIndexMethodInfo
+data TagListGetSampleMethodInfo
+data TagListGetSampleIndexMethodInfo
+data TagListGetScopeMethodInfo
+data TagListGetStringMethodInfo
+data TagListGetStringIndexMethodInfo
+data TagListGetTagSizeMethodInfo
+data TagListGetUintMethodInfo
+data TagListGetUint64MethodInfo
+data TagListGetUint64IndexMethodInfo
+data TagListGetUintIndexMethodInfo
+data TagListGetValueIndexMethodInfo
+data TagListInsertMethodInfo
+data TagListIsEmptyMethodInfo
+data TagListIsEqualMethodInfo
+data TagListMergeMethodInfo
+data TagListNTagsMethodInfo
+data TagListNthTagNameMethodInfo
+data TagListPeekStringIndexMethodInfo
+data TagListRemoveTagMethodInfo
+data TagListSetScopeMethodInfo
+data TagListToStringMethodInfo
diff --git a/GI/Gst/Structs/TimedValue.hs b/GI/Gst/Structs/TimedValue.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/TimedValue.hs
@@ -0,0 +1,73 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+
+Structure for saving a timestamp and a value.
+-}
+
+module GI.Gst.Structs.TimedValue
+    ( 
+
+-- * Exported types
+    TimedValue(..)                          ,
+    newZeroTimedValue                       ,
+    noTimedValue                            ,
+
+
+ -- * Properties
+-- ** Timestamp
+    timedValueReadTimestamp                 ,
+
+
+-- ** Value
+    timedValueReadValue                     ,
+
+
+
+
+    ) where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+import GI.Gst.Callbacks
+
+newtype TimedValue = TimedValue (ForeignPtr TimedValue)
+-- | Construct a `TimedValue` struct initialized to zero.
+newZeroTimedValue :: MonadIO m => m TimedValue
+newZeroTimedValue = liftIO $ callocBytes 16 >>= wrapPtr TimedValue
+
+noTimedValue :: Maybe TimedValue
+noTimedValue = Nothing
+
+timedValueReadTimestamp :: TimedValue -> IO Word64
+timedValueReadTimestamp s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 0) :: IO Word64
+    return val
+
+timedValueReadValue :: TimedValue -> IO Double
+timedValueReadValue s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 8) :: IO CDouble
+    let val' = realToFrac val
+    return val'
+
+type family ResolveTimedValueMethod (t :: Symbol) (o :: *) :: * where
+    ResolveTimedValueMethod l o = MethodResolutionFailed l o
+
+instance (info ~ ResolveTimedValueMethod t TimedValue, MethodInfo info TimedValue p) => IsLabelProxy t (TimedValue -> p) where
+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)
+
+#if MIN_VERSION_base(4,9,0)
+instance (info ~ ResolveTimedValueMethod t TimedValue, MethodInfo info TimedValue p) => IsLabel t (TimedValue -> p) where
+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)
+#endif
+
+
diff --git a/GI/Gst/Structs/TimedValue.hs-boot b/GI/Gst/Structs/TimedValue.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/TimedValue.hs-boot
@@ -0,0 +1,10 @@
+module GI.Gst.Structs.TimedValue where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+newtype TimedValue = TimedValue (ForeignPtr TimedValue)
diff --git a/GI/Gst/Structs/Toc.hs b/GI/Gst/Structs/Toc.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/Toc.hs
@@ -0,0 +1,426 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+
+#GstToc functions are used to create/free #GstToc and #GstTocEntry structures.
+Also they are used to convert #GstToc into #GstStructure and vice versa.
+
+#GstToc lets you to inform other elements in pipeline or application that playing
+source has some kind of table of contents (TOC). These may be chapters, editions,
+angles or other types. For example: DVD chapters, Matroska chapters or cue sheet
+TOC. Such TOC will be useful for applications to display instead of just a
+playlist.
+
+Using TOC is very easy. Firstly, create #GstToc structure which represents root
+contents of the source. You can also attach TOC-specific tags to it. Then fill
+it with #GstTocEntry entries by appending them to the #GstToc using
+gst_toc_append_entry(), and appending subentries to a #GstTocEntry using
+gst_toc_entry_append_sub_entry().
+
+Note that root level of the TOC can contain only either editions or chapters. You
+should not mix them together at the same level. Otherwise you will get serialization
+/deserialization errors. Make sure that no one of the entries has negative start and
+ stop values.
+
+Use gst_event_new_toc() to create a new TOC #GstEvent, and gst_event_parse_toc() to
+parse received TOC event. Use gst_event_new_toc_select() to create a new TOC select #GstEvent,
+and gst_event_parse_toc_select() to parse received TOC select event. The same rule for
+the #GstMessage: gst_message_new_toc() to create new TOC #GstMessage, and
+gst_message_parse_toc() to parse received TOC message.
+
+TOCs can have global scope or current scope. Global scope TOCs contain
+all entries that can possibly be selected using a toc select event, and
+are what an application is usually interested in. TOCs with current scope
+only contain the parts of the TOC relevant to the currently selected/playing
+stream; the current scope TOC is used by downstream elements such as muxers
+to write correct TOC entries when transcoding files, for example. When
+playing a DVD, the global TOC would contain a hierarchy of all titles,
+chapters and angles, for example, while the current TOC would only contain
+the chapters for the currently playing title if playback of a specific
+title was requested.
+
+Applications and plugins should not rely on TOCs having a certain kind of
+structure, but should allow for different alternatives. For example, a
+simple CUE sheet embedded in a file may be presented as a flat list of
+track entries, or could have a top-level edition node (or some other
+alternative type entry) with track entries underneath that node; or even
+multiple top-level edition nodes (or some other alternative type entries)
+each with track entries underneath, in case the source file has extracted
+a track listing from different sources).
+-}
+
+module GI.Gst.Structs.Toc
+    ( 
+
+-- * Exported types
+    Toc(..)                                 ,
+    noToc                                   ,
+
+
+ -- * Methods
+-- ** tocAppendEntry
+    TocAppendEntryMethodInfo                ,
+    tocAppendEntry                          ,
+
+
+-- ** tocDump
+    TocDumpMethodInfo                       ,
+    tocDump                                 ,
+
+
+-- ** tocFindEntry
+    TocFindEntryMethodInfo                  ,
+    tocFindEntry                            ,
+
+
+-- ** tocGetEntries
+    TocGetEntriesMethodInfo                 ,
+    tocGetEntries                           ,
+
+
+-- ** tocGetScope
+    TocGetScopeMethodInfo                   ,
+    tocGetScope                             ,
+
+
+-- ** tocGetTags
+    TocGetTagsMethodInfo                    ,
+    tocGetTags                              ,
+
+
+-- ** tocMergeTags
+    TocMergeTagsMethodInfo                  ,
+    tocMergeTags                            ,
+
+
+-- ** tocNew
+    tocNew                                  ,
+
+
+-- ** tocSetTags
+    TocSetTagsMethodInfo                    ,
+    tocSetTags                              ,
+
+
+
+
+    ) where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+import GI.Gst.Callbacks
+
+newtype Toc = Toc (ForeignPtr Toc)
+foreign import ccall "gst_toc_get_type" c_gst_toc_get_type :: 
+    IO GType
+
+instance BoxedObject Toc where
+    boxedType _ = c_gst_toc_get_type
+
+noToc :: Maybe Toc
+noToc = Nothing
+
+-- method Toc::new
+-- method type : Constructor
+-- Args : [Arg {argCName = "scope", argType = TInterface "Gst" "TocScope", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Toc"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_toc_new" gst_toc_new :: 
+    CUInt ->                                -- scope : TInterface "Gst" "TocScope"
+    IO (Ptr Toc)
+
+
+tocNew ::
+    (MonadIO m) =>
+    TocScope                                -- scope
+    -> m Toc                                -- result
+tocNew scope = liftIO $ do
+    let scope' = (fromIntegral . fromEnum) scope
+    result <- gst_toc_new scope'
+    checkUnexpectedReturnNULL "gst_toc_new" result
+    result' <- (wrapBoxed Toc) result
+    return result'
+
+-- method Toc::append_entry
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Toc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "entry", argType = TInterface "Gst" "TocEntry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_toc_append_entry" gst_toc_append_entry :: 
+    Ptr Toc ->                              -- _obj : TInterface "Gst" "Toc"
+    Ptr TocEntry ->                         -- entry : TInterface "Gst" "TocEntry"
+    IO ()
+
+
+tocAppendEntry ::
+    (MonadIO m) =>
+    Toc                                     -- _obj
+    -> TocEntry                             -- entry
+    -> m ()                                 -- result
+tocAppendEntry _obj entry = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    entry' <- copyBoxed entry
+    gst_toc_append_entry _obj' entry'
+    touchManagedPtr _obj
+    touchManagedPtr entry
+    return ()
+
+data TocAppendEntryMethodInfo
+instance (signature ~ (TocEntry -> m ()), MonadIO m) => MethodInfo TocAppendEntryMethodInfo Toc signature where
+    overloadedMethod _ = tocAppendEntry
+
+-- method Toc::dump
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Toc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_toc_dump" gst_toc_dump :: 
+    Ptr Toc ->                              -- _obj : TInterface "Gst" "Toc"
+    IO ()
+
+
+tocDump ::
+    (MonadIO m) =>
+    Toc                                     -- _obj
+    -> m ()                                 -- result
+tocDump _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    gst_toc_dump _obj'
+    touchManagedPtr _obj
+    return ()
+
+data TocDumpMethodInfo
+instance (signature ~ (m ()), MonadIO m) => MethodInfo TocDumpMethodInfo Toc signature where
+    overloadedMethod _ = tocDump
+
+-- method Toc::find_entry
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Toc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "uid", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "TocEntry"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_toc_find_entry" gst_toc_find_entry :: 
+    Ptr Toc ->                              -- _obj : TInterface "Gst" "Toc"
+    CString ->                              -- uid : TBasicType TUTF8
+    IO (Ptr TocEntry)
+
+
+tocFindEntry ::
+    (MonadIO m) =>
+    Toc                                     -- _obj
+    -> T.Text                               -- uid
+    -> m TocEntry                           -- result
+tocFindEntry _obj uid = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    uid' <- textToCString uid
+    result <- gst_toc_find_entry _obj' uid'
+    checkUnexpectedReturnNULL "gst_toc_find_entry" result
+    result' <- (newBoxed TocEntry) result
+    touchManagedPtr _obj
+    freeMem uid'
+    return result'
+
+data TocFindEntryMethodInfo
+instance (signature ~ (T.Text -> m TocEntry), MonadIO m) => MethodInfo TocFindEntryMethodInfo Toc signature where
+    overloadedMethod _ = tocFindEntry
+
+-- method Toc::get_entries
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Toc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TGList (TInterface "Gst" "TocEntry")
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_toc_get_entries" gst_toc_get_entries :: 
+    Ptr Toc ->                              -- _obj : TInterface "Gst" "Toc"
+    IO (Ptr (GList (Ptr TocEntry)))
+
+
+tocGetEntries ::
+    (MonadIO m) =>
+    Toc                                     -- _obj
+    -> m [TocEntry]                         -- result
+tocGetEntries _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_toc_get_entries _obj'
+    checkUnexpectedReturnNULL "gst_toc_get_entries" result
+    result' <- unpackGList result
+    result'' <- mapM (newBoxed TocEntry) result'
+    touchManagedPtr _obj
+    return result''
+
+data TocGetEntriesMethodInfo
+instance (signature ~ (m [TocEntry]), MonadIO m) => MethodInfo TocGetEntriesMethodInfo Toc signature where
+    overloadedMethod _ = tocGetEntries
+
+-- method Toc::get_scope
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Toc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "TocScope"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_toc_get_scope" gst_toc_get_scope :: 
+    Ptr Toc ->                              -- _obj : TInterface "Gst" "Toc"
+    IO CUInt
+
+
+tocGetScope ::
+    (MonadIO m) =>
+    Toc                                     -- _obj
+    -> m TocScope                           -- result
+tocGetScope _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_toc_get_scope _obj'
+    let result' = (toEnum . fromIntegral) result
+    touchManagedPtr _obj
+    return result'
+
+data TocGetScopeMethodInfo
+instance (signature ~ (m TocScope), MonadIO m) => MethodInfo TocGetScopeMethodInfo Toc signature where
+    overloadedMethod _ = tocGetScope
+
+-- method Toc::get_tags
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Toc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "TagList"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_toc_get_tags" gst_toc_get_tags :: 
+    Ptr Toc ->                              -- _obj : TInterface "Gst" "Toc"
+    IO (Ptr TagList)
+
+
+tocGetTags ::
+    (MonadIO m) =>
+    Toc                                     -- _obj
+    -> m TagList                            -- result
+tocGetTags _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_toc_get_tags _obj'
+    checkUnexpectedReturnNULL "gst_toc_get_tags" result
+    result' <- (newBoxed TagList) result
+    touchManagedPtr _obj
+    return result'
+
+data TocGetTagsMethodInfo
+instance (signature ~ (m TagList), MonadIO m) => MethodInfo TocGetTagsMethodInfo Toc signature where
+    overloadedMethod _ = tocGetTags
+
+-- method Toc::merge_tags
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Toc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tags", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mode", argType = TInterface "Gst" "TagMergeMode", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_toc_merge_tags" gst_toc_merge_tags :: 
+    Ptr Toc ->                              -- _obj : TInterface "Gst" "Toc"
+    Ptr TagList ->                          -- tags : TInterface "Gst" "TagList"
+    CUInt ->                                -- mode : TInterface "Gst" "TagMergeMode"
+    IO ()
+
+
+tocMergeTags ::
+    (MonadIO m) =>
+    Toc                                     -- _obj
+    -> Maybe (TagList)                      -- tags
+    -> TagMergeMode                         -- mode
+    -> m ()                                 -- result
+tocMergeTags _obj tags mode = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    maybeTags <- case tags of
+        Nothing -> return nullPtr
+        Just jTags -> do
+            let jTags' = unsafeManagedPtrGetPtr jTags
+            return jTags'
+    let mode' = (fromIntegral . fromEnum) mode
+    gst_toc_merge_tags _obj' maybeTags mode'
+    touchManagedPtr _obj
+    whenJust tags touchManagedPtr
+    return ()
+
+data TocMergeTagsMethodInfo
+instance (signature ~ (Maybe (TagList) -> TagMergeMode -> m ()), MonadIO m) => MethodInfo TocMergeTagsMethodInfo Toc signature where
+    overloadedMethod _ = tocMergeTags
+
+-- method Toc::set_tags
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Toc", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tags", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_toc_set_tags" gst_toc_set_tags :: 
+    Ptr Toc ->                              -- _obj : TInterface "Gst" "Toc"
+    Ptr TagList ->                          -- tags : TInterface "Gst" "TagList"
+    IO ()
+
+
+tocSetTags ::
+    (MonadIO m) =>
+    Toc                                     -- _obj
+    -> Maybe (TagList)                      -- tags
+    -> m ()                                 -- result
+tocSetTags _obj tags = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    maybeTags <- case tags of
+        Nothing -> return nullPtr
+        Just jTags -> do
+            jTags' <- copyBoxed jTags
+            return jTags'
+    gst_toc_set_tags _obj' maybeTags
+    touchManagedPtr _obj
+    whenJust tags touchManagedPtr
+    return ()
+
+data TocSetTagsMethodInfo
+instance (signature ~ (Maybe (TagList) -> m ()), MonadIO m) => MethodInfo TocSetTagsMethodInfo Toc signature where
+    overloadedMethod _ = tocSetTags
+
+type family ResolveTocMethod (t :: Symbol) (o :: *) :: * where
+    ResolveTocMethod "appendEntry" o = TocAppendEntryMethodInfo
+    ResolveTocMethod "dump" o = TocDumpMethodInfo
+    ResolveTocMethod "findEntry" o = TocFindEntryMethodInfo
+    ResolveTocMethod "mergeTags" o = TocMergeTagsMethodInfo
+    ResolveTocMethod "getEntries" o = TocGetEntriesMethodInfo
+    ResolveTocMethod "getScope" o = TocGetScopeMethodInfo
+    ResolveTocMethod "getTags" o = TocGetTagsMethodInfo
+    ResolveTocMethod "setTags" o = TocSetTagsMethodInfo
+    ResolveTocMethod l o = MethodResolutionFailed l o
+
+instance (info ~ ResolveTocMethod t Toc, MethodInfo info Toc p) => IsLabelProxy t (Toc -> p) where
+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)
+
+#if MIN_VERSION_base(4,9,0)
+instance (info ~ ResolveTocMethod t Toc, MethodInfo info Toc p) => IsLabel t (Toc -> p) where
+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)
+#endif
+
+
diff --git a/GI/Gst/Structs/Toc.hs-boot b/GI/Gst/Structs/Toc.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/Toc.hs-boot
@@ -0,0 +1,19 @@
+module GI.Gst.Structs.Toc where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+newtype Toc = Toc (ForeignPtr Toc)
+instance BoxedObject Toc where
+data TocAppendEntryMethodInfo
+data TocDumpMethodInfo
+data TocFindEntryMethodInfo
+data TocGetEntriesMethodInfo
+data TocGetScopeMethodInfo
+data TocGetTagsMethodInfo
+data TocMergeTagsMethodInfo
+data TocSetTagsMethodInfo
diff --git a/GI/Gst/Structs/TocEntry.hs b/GI/Gst/Structs/TocEntry.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/TocEntry.hs
@@ -0,0 +1,645 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+-}
+
+module GI.Gst.Structs.TocEntry
+    ( 
+
+-- * Exported types
+    TocEntry(..)                            ,
+    noTocEntry                              ,
+
+
+ -- * Methods
+-- ** tocEntryAppendSubEntry
+    TocEntryAppendSubEntryMethodInfo        ,
+    tocEntryAppendSubEntry                  ,
+
+
+-- ** tocEntryGetEntryType
+    TocEntryGetEntryTypeMethodInfo          ,
+    tocEntryGetEntryType                    ,
+
+
+-- ** tocEntryGetLoop
+    TocEntryGetLoopMethodInfo               ,
+    tocEntryGetLoop                         ,
+
+
+-- ** tocEntryGetParent
+    TocEntryGetParentMethodInfo             ,
+    tocEntryGetParent                       ,
+
+
+-- ** tocEntryGetStartStopTimes
+    TocEntryGetStartStopTimesMethodInfo     ,
+    tocEntryGetStartStopTimes               ,
+
+
+-- ** tocEntryGetSubEntries
+    TocEntryGetSubEntriesMethodInfo         ,
+    tocEntryGetSubEntries                   ,
+
+
+-- ** tocEntryGetTags
+    TocEntryGetTagsMethodInfo               ,
+    tocEntryGetTags                         ,
+
+
+-- ** tocEntryGetToc
+    TocEntryGetTocMethodInfo                ,
+    tocEntryGetToc                          ,
+
+
+-- ** tocEntryGetUid
+    TocEntryGetUidMethodInfo                ,
+    tocEntryGetUid                          ,
+
+
+-- ** tocEntryIsAlternative
+    TocEntryIsAlternativeMethodInfo         ,
+    tocEntryIsAlternative                   ,
+
+
+-- ** tocEntryIsSequence
+    TocEntryIsSequenceMethodInfo            ,
+    tocEntryIsSequence                      ,
+
+
+-- ** tocEntryMergeTags
+    TocEntryMergeTagsMethodInfo             ,
+    tocEntryMergeTags                       ,
+
+
+-- ** tocEntryNew
+    tocEntryNew                             ,
+
+
+-- ** tocEntrySetLoop
+    TocEntrySetLoopMethodInfo               ,
+    tocEntrySetLoop                         ,
+
+
+-- ** tocEntrySetStartStopTimes
+    TocEntrySetStartStopTimesMethodInfo     ,
+    tocEntrySetStartStopTimes               ,
+
+
+-- ** tocEntrySetTags
+    TocEntrySetTagsMethodInfo               ,
+    tocEntrySetTags                         ,
+
+
+
+
+    ) where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+import GI.Gst.Callbacks
+
+newtype TocEntry = TocEntry (ForeignPtr TocEntry)
+foreign import ccall "gst_toc_entry_get_type" c_gst_toc_entry_get_type :: 
+    IO GType
+
+instance BoxedObject TocEntry where
+    boxedType _ = c_gst_toc_entry_get_type
+
+noTocEntry :: Maybe TocEntry
+noTocEntry = Nothing
+
+-- method TocEntry::new
+-- method type : Constructor
+-- Args : [Arg {argCName = "type", argType = TInterface "Gst" "TocEntryType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "uid", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "TocEntry"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_toc_entry_new" gst_toc_entry_new :: 
+    CUInt ->                                -- type : TInterface "Gst" "TocEntryType"
+    CString ->                              -- uid : TBasicType TUTF8
+    IO (Ptr TocEntry)
+
+
+tocEntryNew ::
+    (MonadIO m) =>
+    TocEntryType                            -- type_
+    -> T.Text                               -- uid
+    -> m TocEntry                           -- result
+tocEntryNew type_ uid = liftIO $ do
+    let type_' = (fromIntegral . fromEnum) type_
+    uid' <- textToCString uid
+    result <- gst_toc_entry_new type_' uid'
+    checkUnexpectedReturnNULL "gst_toc_entry_new" result
+    result' <- (wrapBoxed TocEntry) result
+    freeMem uid'
+    return result'
+
+-- method TocEntry::append_sub_entry
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TocEntry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "subentry", argType = TInterface "Gst" "TocEntry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_toc_entry_append_sub_entry" gst_toc_entry_append_sub_entry :: 
+    Ptr TocEntry ->                         -- _obj : TInterface "Gst" "TocEntry"
+    Ptr TocEntry ->                         -- subentry : TInterface "Gst" "TocEntry"
+    IO ()
+
+
+tocEntryAppendSubEntry ::
+    (MonadIO m) =>
+    TocEntry                                -- _obj
+    -> TocEntry                             -- subentry
+    -> m ()                                 -- result
+tocEntryAppendSubEntry _obj subentry = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    subentry' <- copyBoxed subentry
+    gst_toc_entry_append_sub_entry _obj' subentry'
+    touchManagedPtr _obj
+    touchManagedPtr subentry
+    return ()
+
+data TocEntryAppendSubEntryMethodInfo
+instance (signature ~ (TocEntry -> m ()), MonadIO m) => MethodInfo TocEntryAppendSubEntryMethodInfo TocEntry signature where
+    overloadedMethod _ = tocEntryAppendSubEntry
+
+-- method TocEntry::get_entry_type
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TocEntry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "TocEntryType"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_toc_entry_get_entry_type" gst_toc_entry_get_entry_type :: 
+    Ptr TocEntry ->                         -- _obj : TInterface "Gst" "TocEntry"
+    IO CUInt
+
+
+tocEntryGetEntryType ::
+    (MonadIO m) =>
+    TocEntry                                -- _obj
+    -> m TocEntryType                       -- result
+tocEntryGetEntryType _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_toc_entry_get_entry_type _obj'
+    let result' = (toEnum . fromIntegral) result
+    touchManagedPtr _obj
+    return result'
+
+data TocEntryGetEntryTypeMethodInfo
+instance (signature ~ (m TocEntryType), MonadIO m) => MethodInfo TocEntryGetEntryTypeMethodInfo TocEntry signature where
+    overloadedMethod _ = tocEntryGetEntryType
+
+-- method TocEntry::get_loop
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TocEntry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "loop_type", argType = TInterface "Gst" "TocLoopType", direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "repeat_count", argType = TBasicType TInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_toc_entry_get_loop" gst_toc_entry_get_loop :: 
+    Ptr TocEntry ->                         -- _obj : TInterface "Gst" "TocEntry"
+    Ptr CUInt ->                            -- loop_type : TInterface "Gst" "TocLoopType"
+    Ptr Int32 ->                            -- repeat_count : TBasicType TInt32
+    IO CInt
+
+
+tocEntryGetLoop ::
+    (MonadIO m) =>
+    TocEntry                                -- _obj
+    -> m (Bool,TocLoopType,Int32)           -- result
+tocEntryGetLoop _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    loopType <- allocMem :: IO (Ptr CUInt)
+    repeatCount <- allocMem :: IO (Ptr Int32)
+    result <- gst_toc_entry_get_loop _obj' loopType repeatCount
+    let result' = (/= 0) result
+    loopType' <- peek loopType
+    let loopType'' = (toEnum . fromIntegral) loopType'
+    repeatCount' <- peek repeatCount
+    touchManagedPtr _obj
+    freeMem loopType
+    freeMem repeatCount
+    return (result', loopType'', repeatCount')
+
+data TocEntryGetLoopMethodInfo
+instance (signature ~ (m (Bool,TocLoopType,Int32)), MonadIO m) => MethodInfo TocEntryGetLoopMethodInfo TocEntry signature where
+    overloadedMethod _ = tocEntryGetLoop
+
+-- method TocEntry::get_parent
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TocEntry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "TocEntry"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_toc_entry_get_parent" gst_toc_entry_get_parent :: 
+    Ptr TocEntry ->                         -- _obj : TInterface "Gst" "TocEntry"
+    IO (Ptr TocEntry)
+
+
+tocEntryGetParent ::
+    (MonadIO m) =>
+    TocEntry                                -- _obj
+    -> m TocEntry                           -- result
+tocEntryGetParent _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_toc_entry_get_parent _obj'
+    checkUnexpectedReturnNULL "gst_toc_entry_get_parent" result
+    result' <- (newBoxed TocEntry) result
+    touchManagedPtr _obj
+    return result'
+
+data TocEntryGetParentMethodInfo
+instance (signature ~ (m TocEntry), MonadIO m) => MethodInfo TocEntryGetParentMethodInfo TocEntry signature where
+    overloadedMethod _ = tocEntryGetParent
+
+-- method TocEntry::get_start_stop_times
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TocEntry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "stop", argType = TBasicType TInt64, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_toc_entry_get_start_stop_times" gst_toc_entry_get_start_stop_times :: 
+    Ptr TocEntry ->                         -- _obj : TInterface "Gst" "TocEntry"
+    Ptr Int64 ->                            -- start : TBasicType TInt64
+    Ptr Int64 ->                            -- stop : TBasicType TInt64
+    IO CInt
+
+
+tocEntryGetStartStopTimes ::
+    (MonadIO m) =>
+    TocEntry                                -- _obj
+    -> m (Bool,Int64,Int64)                 -- result
+tocEntryGetStartStopTimes _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    start <- allocMem :: IO (Ptr Int64)
+    stop <- allocMem :: IO (Ptr Int64)
+    result <- gst_toc_entry_get_start_stop_times _obj' start stop
+    let result' = (/= 0) result
+    start' <- peek start
+    stop' <- peek stop
+    touchManagedPtr _obj
+    freeMem start
+    freeMem stop
+    return (result', start', stop')
+
+data TocEntryGetStartStopTimesMethodInfo
+instance (signature ~ (m (Bool,Int64,Int64)), MonadIO m) => MethodInfo TocEntryGetStartStopTimesMethodInfo TocEntry signature where
+    overloadedMethod _ = tocEntryGetStartStopTimes
+
+-- method TocEntry::get_sub_entries
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TocEntry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TGList (TInterface "Gst" "TocEntry")
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_toc_entry_get_sub_entries" gst_toc_entry_get_sub_entries :: 
+    Ptr TocEntry ->                         -- _obj : TInterface "Gst" "TocEntry"
+    IO (Ptr (GList (Ptr TocEntry)))
+
+
+tocEntryGetSubEntries ::
+    (MonadIO m) =>
+    TocEntry                                -- _obj
+    -> m [TocEntry]                         -- result
+tocEntryGetSubEntries _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_toc_entry_get_sub_entries _obj'
+    checkUnexpectedReturnNULL "gst_toc_entry_get_sub_entries" result
+    result' <- unpackGList result
+    result'' <- mapM (newBoxed TocEntry) result'
+    touchManagedPtr _obj
+    return result''
+
+data TocEntryGetSubEntriesMethodInfo
+instance (signature ~ (m [TocEntry]), MonadIO m) => MethodInfo TocEntryGetSubEntriesMethodInfo TocEntry signature where
+    overloadedMethod _ = tocEntryGetSubEntries
+
+-- method TocEntry::get_tags
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TocEntry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "TagList"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_toc_entry_get_tags" gst_toc_entry_get_tags :: 
+    Ptr TocEntry ->                         -- _obj : TInterface "Gst" "TocEntry"
+    IO (Ptr TagList)
+
+
+tocEntryGetTags ::
+    (MonadIO m) =>
+    TocEntry                                -- _obj
+    -> m TagList                            -- result
+tocEntryGetTags _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_toc_entry_get_tags _obj'
+    checkUnexpectedReturnNULL "gst_toc_entry_get_tags" result
+    result' <- (newBoxed TagList) result
+    touchManagedPtr _obj
+    return result'
+
+data TocEntryGetTagsMethodInfo
+instance (signature ~ (m TagList), MonadIO m) => MethodInfo TocEntryGetTagsMethodInfo TocEntry signature where
+    overloadedMethod _ = tocEntryGetTags
+
+-- method TocEntry::get_toc
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TocEntry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Toc"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_toc_entry_get_toc" gst_toc_entry_get_toc :: 
+    Ptr TocEntry ->                         -- _obj : TInterface "Gst" "TocEntry"
+    IO (Ptr Toc)
+
+
+tocEntryGetToc ::
+    (MonadIO m) =>
+    TocEntry                                -- _obj
+    -> m Toc                                -- result
+tocEntryGetToc _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_toc_entry_get_toc _obj'
+    checkUnexpectedReturnNULL "gst_toc_entry_get_toc" result
+    result' <- (newBoxed Toc) result
+    touchManagedPtr _obj
+    return result'
+
+data TocEntryGetTocMethodInfo
+instance (signature ~ (m Toc), MonadIO m) => MethodInfo TocEntryGetTocMethodInfo TocEntry signature where
+    overloadedMethod _ = tocEntryGetToc
+
+-- method TocEntry::get_uid
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TocEntry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUTF8
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_toc_entry_get_uid" gst_toc_entry_get_uid :: 
+    Ptr TocEntry ->                         -- _obj : TInterface "Gst" "TocEntry"
+    IO CString
+
+
+tocEntryGetUid ::
+    (MonadIO m) =>
+    TocEntry                                -- _obj
+    -> m T.Text                             -- result
+tocEntryGetUid _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_toc_entry_get_uid _obj'
+    checkUnexpectedReturnNULL "gst_toc_entry_get_uid" result
+    result' <- cstringToText result
+    touchManagedPtr _obj
+    return result'
+
+data TocEntryGetUidMethodInfo
+instance (signature ~ (m T.Text), MonadIO m) => MethodInfo TocEntryGetUidMethodInfo TocEntry signature where
+    overloadedMethod _ = tocEntryGetUid
+
+-- method TocEntry::is_alternative
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TocEntry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_toc_entry_is_alternative" gst_toc_entry_is_alternative :: 
+    Ptr TocEntry ->                         -- _obj : TInterface "Gst" "TocEntry"
+    IO CInt
+
+
+tocEntryIsAlternative ::
+    (MonadIO m) =>
+    TocEntry                                -- _obj
+    -> m Bool                               -- result
+tocEntryIsAlternative _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_toc_entry_is_alternative _obj'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data TocEntryIsAlternativeMethodInfo
+instance (signature ~ (m Bool), MonadIO m) => MethodInfo TocEntryIsAlternativeMethodInfo TocEntry signature where
+    overloadedMethod _ = tocEntryIsAlternative
+
+-- method TocEntry::is_sequence
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TocEntry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_toc_entry_is_sequence" gst_toc_entry_is_sequence :: 
+    Ptr TocEntry ->                         -- _obj : TInterface "Gst" "TocEntry"
+    IO CInt
+
+
+tocEntryIsSequence ::
+    (MonadIO m) =>
+    TocEntry                                -- _obj
+    -> m Bool                               -- result
+tocEntryIsSequence _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_toc_entry_is_sequence _obj'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data TocEntryIsSequenceMethodInfo
+instance (signature ~ (m Bool), MonadIO m) => MethodInfo TocEntryIsSequenceMethodInfo TocEntry signature where
+    overloadedMethod _ = tocEntryIsSequence
+
+-- method TocEntry::merge_tags
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TocEntry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tags", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mode", argType = TInterface "Gst" "TagMergeMode", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_toc_entry_merge_tags" gst_toc_entry_merge_tags :: 
+    Ptr TocEntry ->                         -- _obj : TInterface "Gst" "TocEntry"
+    Ptr TagList ->                          -- tags : TInterface "Gst" "TagList"
+    CUInt ->                                -- mode : TInterface "Gst" "TagMergeMode"
+    IO ()
+
+
+tocEntryMergeTags ::
+    (MonadIO m) =>
+    TocEntry                                -- _obj
+    -> Maybe (TagList)                      -- tags
+    -> TagMergeMode                         -- mode
+    -> m ()                                 -- result
+tocEntryMergeTags _obj tags mode = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    maybeTags <- case tags of
+        Nothing -> return nullPtr
+        Just jTags -> do
+            let jTags' = unsafeManagedPtrGetPtr jTags
+            return jTags'
+    let mode' = (fromIntegral . fromEnum) mode
+    gst_toc_entry_merge_tags _obj' maybeTags mode'
+    touchManagedPtr _obj
+    whenJust tags touchManagedPtr
+    return ()
+
+data TocEntryMergeTagsMethodInfo
+instance (signature ~ (Maybe (TagList) -> TagMergeMode -> m ()), MonadIO m) => MethodInfo TocEntryMergeTagsMethodInfo TocEntry signature where
+    overloadedMethod _ = tocEntryMergeTags
+
+-- method TocEntry::set_loop
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TocEntry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "loop_type", argType = TInterface "Gst" "TocLoopType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "repeat_count", argType = TBasicType TInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_toc_entry_set_loop" gst_toc_entry_set_loop :: 
+    Ptr TocEntry ->                         -- _obj : TInterface "Gst" "TocEntry"
+    CUInt ->                                -- loop_type : TInterface "Gst" "TocLoopType"
+    Int32 ->                                -- repeat_count : TBasicType TInt32
+    IO ()
+
+
+tocEntrySetLoop ::
+    (MonadIO m) =>
+    TocEntry                                -- _obj
+    -> TocLoopType                          -- loopType
+    -> Int32                                -- repeatCount
+    -> m ()                                 -- result
+tocEntrySetLoop _obj loopType repeatCount = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let loopType' = (fromIntegral . fromEnum) loopType
+    gst_toc_entry_set_loop _obj' loopType' repeatCount
+    touchManagedPtr _obj
+    return ()
+
+data TocEntrySetLoopMethodInfo
+instance (signature ~ (TocLoopType -> Int32 -> m ()), MonadIO m) => MethodInfo TocEntrySetLoopMethodInfo TocEntry signature where
+    overloadedMethod _ = tocEntrySetLoop
+
+-- method TocEntry::set_start_stop_times
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TocEntry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "start", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "stop", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_toc_entry_set_start_stop_times" gst_toc_entry_set_start_stop_times :: 
+    Ptr TocEntry ->                         -- _obj : TInterface "Gst" "TocEntry"
+    Int64 ->                                -- start : TBasicType TInt64
+    Int64 ->                                -- stop : TBasicType TInt64
+    IO ()
+
+
+tocEntrySetStartStopTimes ::
+    (MonadIO m) =>
+    TocEntry                                -- _obj
+    -> Int64                                -- start
+    -> Int64                                -- stop
+    -> m ()                                 -- result
+tocEntrySetStartStopTimes _obj start stop = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    gst_toc_entry_set_start_stop_times _obj' start stop
+    touchManagedPtr _obj
+    return ()
+
+data TocEntrySetStartStopTimesMethodInfo
+instance (signature ~ (Int64 -> Int64 -> m ()), MonadIO m) => MethodInfo TocEntrySetStartStopTimesMethodInfo TocEntry signature where
+    overloadedMethod _ = tocEntrySetStartStopTimes
+
+-- method TocEntry::set_tags
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TocEntry", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "tags", argType = TInterface "Gst" "TagList", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_toc_entry_set_tags" gst_toc_entry_set_tags :: 
+    Ptr TocEntry ->                         -- _obj : TInterface "Gst" "TocEntry"
+    Ptr TagList ->                          -- tags : TInterface "Gst" "TagList"
+    IO ()
+
+
+tocEntrySetTags ::
+    (MonadIO m) =>
+    TocEntry                                -- _obj
+    -> Maybe (TagList)                      -- tags
+    -> m ()                                 -- result
+tocEntrySetTags _obj tags = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    maybeTags <- case tags of
+        Nothing -> return nullPtr
+        Just jTags -> do
+            jTags' <- copyBoxed jTags
+            return jTags'
+    gst_toc_entry_set_tags _obj' maybeTags
+    touchManagedPtr _obj
+    whenJust tags touchManagedPtr
+    return ()
+
+data TocEntrySetTagsMethodInfo
+instance (signature ~ (Maybe (TagList) -> m ()), MonadIO m) => MethodInfo TocEntrySetTagsMethodInfo TocEntry signature where
+    overloadedMethod _ = tocEntrySetTags
+
+type family ResolveTocEntryMethod (t :: Symbol) (o :: *) :: * where
+    ResolveTocEntryMethod "appendSubEntry" o = TocEntryAppendSubEntryMethodInfo
+    ResolveTocEntryMethod "isAlternative" o = TocEntryIsAlternativeMethodInfo
+    ResolveTocEntryMethod "isSequence" o = TocEntryIsSequenceMethodInfo
+    ResolveTocEntryMethod "mergeTags" o = TocEntryMergeTagsMethodInfo
+    ResolveTocEntryMethod "getEntryType" o = TocEntryGetEntryTypeMethodInfo
+    ResolveTocEntryMethod "getLoop" o = TocEntryGetLoopMethodInfo
+    ResolveTocEntryMethod "getParent" o = TocEntryGetParentMethodInfo
+    ResolveTocEntryMethod "getStartStopTimes" o = TocEntryGetStartStopTimesMethodInfo
+    ResolveTocEntryMethod "getSubEntries" o = TocEntryGetSubEntriesMethodInfo
+    ResolveTocEntryMethod "getTags" o = TocEntryGetTagsMethodInfo
+    ResolveTocEntryMethod "getToc" o = TocEntryGetTocMethodInfo
+    ResolveTocEntryMethod "getUid" o = TocEntryGetUidMethodInfo
+    ResolveTocEntryMethod "setLoop" o = TocEntrySetLoopMethodInfo
+    ResolveTocEntryMethod "setStartStopTimes" o = TocEntrySetStartStopTimesMethodInfo
+    ResolveTocEntryMethod "setTags" o = TocEntrySetTagsMethodInfo
+    ResolveTocEntryMethod l o = MethodResolutionFailed l o
+
+instance (info ~ ResolveTocEntryMethod t TocEntry, MethodInfo info TocEntry p) => IsLabelProxy t (TocEntry -> p) where
+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)
+
+#if MIN_VERSION_base(4,9,0)
+instance (info ~ ResolveTocEntryMethod t TocEntry, MethodInfo info TocEntry p) => IsLabel t (TocEntry -> p) where
+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)
+#endif
+
+
diff --git a/GI/Gst/Structs/TocEntry.hs-boot b/GI/Gst/Structs/TocEntry.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/TocEntry.hs-boot
@@ -0,0 +1,26 @@
+module GI.Gst.Structs.TocEntry where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+newtype TocEntry = TocEntry (ForeignPtr TocEntry)
+instance BoxedObject TocEntry where
+data TocEntryAppendSubEntryMethodInfo
+data TocEntryGetEntryTypeMethodInfo
+data TocEntryGetLoopMethodInfo
+data TocEntryGetParentMethodInfo
+data TocEntryGetStartStopTimesMethodInfo
+data TocEntryGetSubEntriesMethodInfo
+data TocEntryGetTagsMethodInfo
+data TocEntryGetTocMethodInfo
+data TocEntryGetUidMethodInfo
+data TocEntryIsAlternativeMethodInfo
+data TocEntryIsSequenceMethodInfo
+data TocEntryMergeTagsMethodInfo
+data TocEntrySetLoopMethodInfo
+data TocEntrySetStartStopTimesMethodInfo
+data TocEntrySetTagsMethodInfo
diff --git a/GI/Gst/Structs/TypeFind.hs b/GI/Gst/Structs/TypeFind.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/TypeFind.hs
@@ -0,0 +1,244 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+
+The following functions allow you to detect the media type of an unknown
+stream.
+-}
+
+module GI.Gst.Structs.TypeFind
+    ( 
+
+-- * Exported types
+    TypeFind(..)                            ,
+    newZeroTypeFind                         ,
+    noTypeFind                              ,
+
+
+ -- * Methods
+-- ** typeFindGetLength
+    TypeFindGetLengthMethodInfo             ,
+    typeFindGetLength                       ,
+
+
+-- ** typeFindPeek
+    TypeFindPeekMethodInfo                  ,
+    typeFindPeek                            ,
+
+
+-- ** typeFindRegister
+    typeFindRegister                        ,
+
+
+-- ** typeFindSuggest
+    TypeFindSuggestMethodInfo               ,
+    typeFindSuggest                         ,
+
+
+
+
+ -- * Properties
+-- ** Data
+    typeFindReadData                        ,
+
+
+
+
+    ) where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+import GI.Gst.Callbacks
+import qualified GI.GLib as GLib
+
+newtype TypeFind = TypeFind (ForeignPtr TypeFind)
+-- | Construct a `TypeFind` struct initialized to zero.
+newZeroTypeFind :: MonadIO m => m TypeFind
+newZeroTypeFind = liftIO $ callocBytes 64 >>= wrapPtr TypeFind
+
+noTypeFind :: Maybe TypeFind
+noTypeFind = Nothing
+
+-- XXX Skipped getter for "TypeFind:peek" :: Not implemented: "Wrapping foreign callbacks is not supported yet"
+
+-- XXX Skipped getter for "TypeFind:suggest" :: Not implemented: "Wrapping foreign callbacks is not supported yet"
+
+typeFindReadData :: TypeFind -> IO (Ptr ())
+typeFindReadData s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 16) :: IO (Ptr ())
+    return val
+
+-- XXX Skipped getter for "TypeFind:get_length" :: Not implemented: "Wrapping foreign callbacks is not supported yet"
+
+-- method TypeFind::get_length
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TypeFind", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUInt64
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_type_find_get_length" gst_type_find_get_length :: 
+    Ptr TypeFind ->                         -- _obj : TInterface "Gst" "TypeFind"
+    IO Word64
+
+
+typeFindGetLength ::
+    (MonadIO m) =>
+    TypeFind                                -- _obj
+    -> m Word64                             -- result
+typeFindGetLength _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_type_find_get_length _obj'
+    touchManagedPtr _obj
+    return result
+
+data TypeFindGetLengthMethodInfo
+instance (signature ~ (m Word64), MonadIO m) => MethodInfo TypeFindGetLengthMethodInfo TypeFind signature where
+    overloadedMethod _ = typeFindGetLength
+
+-- method TypeFind::peek
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TypeFind", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : [Arg {argCName = "size", argType = TBasicType TUInt32, direction = DirectionOut, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- returnType : TCArray False (-1) 2 (TBasicType TUInt8)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_type_find_peek" gst_type_find_peek :: 
+    Ptr TypeFind ->                         -- _obj : TInterface "Gst" "TypeFind"
+    Int64 ->                                -- offset : TBasicType TInt64
+    Ptr Word32 ->                           -- size : TBasicType TUInt32
+    IO (Ptr Word8)
+
+
+typeFindPeek ::
+    (MonadIO m) =>
+    TypeFind                                -- _obj
+    -> Int64                                -- offset
+    -> m ByteString                         -- result
+typeFindPeek _obj offset = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    size <- allocMem :: IO (Ptr Word32)
+    result <- gst_type_find_peek _obj' offset size
+    size' <- peek size
+    checkUnexpectedReturnNULL "gst_type_find_peek" result
+    result' <- (unpackByteStringWithLength size') result
+    touchManagedPtr _obj
+    freeMem size
+    return result'
+
+data TypeFindPeekMethodInfo
+instance (signature ~ (Int64 -> m ByteString), MonadIO m) => MethodInfo TypeFindPeekMethodInfo TypeFind signature where
+    overloadedMethod _ = typeFindPeek
+
+-- method TypeFind::suggest
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "TypeFind", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "probability", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "caps", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TVoid
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_type_find_suggest" gst_type_find_suggest :: 
+    Ptr TypeFind ->                         -- _obj : TInterface "Gst" "TypeFind"
+    Word32 ->                               -- probability : TBasicType TUInt32
+    Ptr Caps ->                             -- caps : TInterface "Gst" "Caps"
+    IO ()
+
+
+typeFindSuggest ::
+    (MonadIO m) =>
+    TypeFind                                -- _obj
+    -> Word32                               -- probability
+    -> Caps                                 -- caps
+    -> m ()                                 -- result
+typeFindSuggest _obj probability caps = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let caps' = unsafeManagedPtrGetPtr caps
+    gst_type_find_suggest _obj' probability caps'
+    touchManagedPtr _obj
+    touchManagedPtr caps
+    return ()
+
+data TypeFindSuggestMethodInfo
+instance (signature ~ (Word32 -> Caps -> m ()), MonadIO m) => MethodInfo TypeFindSuggestMethodInfo TypeFind signature where
+    overloadedMethod _ = typeFindSuggest
+
+-- method TypeFind::register
+-- method type : MemberFunction
+-- Args : [Arg {argCName = "plugin", argType = TInterface "Gst" "Plugin", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "name", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "rank", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "func", argType = TInterface "Gst" "TypeFindFunction", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeNotified, argClosure = 6, argDestroy = 7, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "extensions", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "possible_caps", argType = TInterface "Gst" "Caps", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TBasicType TVoid, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data_notify", argType = TInterface "GLib" "DestroyNotify", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_type_find_register" gst_type_find_register :: 
+    Ptr Plugin ->                           -- plugin : TInterface "Gst" "Plugin"
+    CString ->                              -- name : TBasicType TUTF8
+    Word32 ->                               -- rank : TBasicType TUInt32
+    FunPtr TypeFindFunctionC ->             -- func : TInterface "Gst" "TypeFindFunction"
+    CString ->                              -- extensions : TBasicType TUTF8
+    Ptr Caps ->                             -- possible_caps : TInterface "Gst" "Caps"
+    Ptr () ->                               -- data : TBasicType TVoid
+    FunPtr GLib.DestroyNotifyC ->           -- data_notify : TInterface "GLib" "DestroyNotify"
+    IO CInt
+
+
+typeFindRegister ::
+    (MonadIO m, PluginK a) =>
+    Maybe (a)                               -- plugin
+    -> T.Text                               -- name
+    -> Word32                               -- rank
+    -> TypeFindFunction                     -- func
+    -> Maybe (T.Text)                       -- extensions
+    -> Caps                                 -- possibleCaps
+    -> m Bool                               -- result
+typeFindRegister plugin name rank func extensions possibleCaps = liftIO $ do
+    maybePlugin <- case plugin of
+        Nothing -> return nullPtr
+        Just jPlugin -> do
+            let jPlugin' = unsafeManagedPtrCastPtr jPlugin
+            return jPlugin'
+    name' <- textToCString name
+    func' <- mkTypeFindFunction (typeFindFunctionWrapper Nothing func)
+    maybeExtensions <- case extensions of
+        Nothing -> return nullPtr
+        Just jExtensions -> do
+            jExtensions' <- textToCString jExtensions
+            return jExtensions'
+    let possibleCaps' = unsafeManagedPtrGetPtr possibleCaps
+    let data_ = castFunPtrToPtr func'
+    let dataNotify = safeFreeFunPtrPtr
+    result <- gst_type_find_register maybePlugin name' rank func' maybeExtensions possibleCaps' data_ dataNotify
+    let result' = (/= 0) result
+    whenJust plugin touchManagedPtr
+    touchManagedPtr possibleCaps
+    freeMem name'
+    freeMem maybeExtensions
+    return result'
+
+type family ResolveTypeFindMethod (t :: Symbol) (o :: *) :: * where
+    ResolveTypeFindMethod "peek" o = TypeFindPeekMethodInfo
+    ResolveTypeFindMethod "suggest" o = TypeFindSuggestMethodInfo
+    ResolveTypeFindMethod "getLength" o = TypeFindGetLengthMethodInfo
+    ResolveTypeFindMethod l o = MethodResolutionFailed l o
+
+instance (info ~ ResolveTypeFindMethod t TypeFind, MethodInfo info TypeFind p) => IsLabelProxy t (TypeFind -> p) where
+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)
+
+#if MIN_VERSION_base(4,9,0)
+instance (info ~ ResolveTypeFindMethod t TypeFind, MethodInfo info TypeFind p) => IsLabel t (TypeFind -> p) where
+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)
+#endif
+
+
diff --git a/GI/Gst/Structs/TypeFind.hs-boot b/GI/Gst/Structs/TypeFind.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/TypeFind.hs-boot
@@ -0,0 +1,13 @@
+module GI.Gst.Structs.TypeFind where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+newtype TypeFind = TypeFind (ForeignPtr TypeFind)
+data TypeFindGetLengthMethodInfo
+data TypeFindPeekMethodInfo
+data TypeFindSuggestMethodInfo
diff --git a/GI/Gst/Structs/Uri.hs b/GI/Gst/Structs/Uri.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/Uri.hs
@@ -0,0 +1,1811 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+
+A #GstUri object can be used to parse and split a URI string into its
+constituant parts. Two #GstUri objects can be joined to make a new #GstUri
+using the algorithm described in RFC3986.
+-}
+
+module GI.Gst.Structs.Uri
+    ( 
+
+-- * Exported types
+    Uri(..)                                 ,
+    noUri                                   ,
+
+
+ -- * Methods
+-- ** uriAppendPath
+    UriAppendPathMethodInfo                 ,
+    uriAppendPath                           ,
+
+
+-- ** uriAppendPathSegment
+    UriAppendPathSegmentMethodInfo          ,
+    uriAppendPathSegment                    ,
+
+
+-- ** uriConstruct
+    uriConstruct                            ,
+
+
+-- ** uriEqual
+    UriEqualMethodInfo                      ,
+    uriEqual                                ,
+
+
+-- ** uriFromString
+    uriFromString                           ,
+
+
+-- ** uriFromStringWithBase
+    UriFromStringWithBaseMethodInfo         ,
+    uriFromStringWithBase                   ,
+
+
+-- ** uriGetFragment
+    UriGetFragmentMethodInfo                ,
+    uriGetFragment                          ,
+
+
+-- ** uriGetHost
+    UriGetHostMethodInfo                    ,
+    uriGetHost                              ,
+
+
+-- ** uriGetLocation
+    uriGetLocation                          ,
+
+
+-- ** uriGetPath
+    UriGetPathMethodInfo                    ,
+    uriGetPath                              ,
+
+
+-- ** uriGetPathSegments
+    UriGetPathSegmentsMethodInfo            ,
+    uriGetPathSegments                      ,
+
+
+-- ** uriGetPathString
+    UriGetPathStringMethodInfo              ,
+    uriGetPathString                        ,
+
+
+-- ** uriGetPort
+    UriGetPortMethodInfo                    ,
+    uriGetPort                              ,
+
+
+-- ** uriGetProtocol
+    uriGetProtocol                          ,
+
+
+-- ** uriGetQueryKeys
+    UriGetQueryKeysMethodInfo               ,
+    uriGetQueryKeys                         ,
+
+
+-- ** uriGetQueryString
+    UriGetQueryStringMethodInfo             ,
+    uriGetQueryString                       ,
+
+
+-- ** uriGetQueryTable
+    UriGetQueryTableMethodInfo              ,
+    uriGetQueryTable                        ,
+
+
+-- ** uriGetQueryValue
+    UriGetQueryValueMethodInfo              ,
+    uriGetQueryValue                        ,
+
+
+-- ** uriGetScheme
+    UriGetSchemeMethodInfo                  ,
+    uriGetScheme                            ,
+
+
+-- ** uriGetUserinfo
+    UriGetUserinfoMethodInfo                ,
+    uriGetUserinfo                          ,
+
+
+-- ** uriHasProtocol
+    uriHasProtocol                          ,
+
+
+-- ** uriIsNormalized
+    UriIsNormalizedMethodInfo               ,
+    uriIsNormalized                         ,
+
+
+-- ** uriIsValid
+    uriIsValid                              ,
+
+
+-- ** uriIsWritable
+    UriIsWritableMethodInfo                 ,
+    uriIsWritable                           ,
+
+
+-- ** uriJoin
+    UriJoinMethodInfo                       ,
+    uriJoin                                 ,
+
+
+-- ** uriJoinStrings
+    uriJoinStrings                          ,
+
+
+-- ** uriMakeWritable
+    UriMakeWritableMethodInfo               ,
+    uriMakeWritable                         ,
+
+
+-- ** uriNew
+    uriNew                                  ,
+
+
+-- ** uriNewWithBase
+    UriNewWithBaseMethodInfo                ,
+    uriNewWithBase                          ,
+
+
+-- ** uriNormalize
+    UriNormalizeMethodInfo                  ,
+    uriNormalize                            ,
+
+
+-- ** uriProtocolIsSupported
+    uriProtocolIsSupported                  ,
+
+
+-- ** uriProtocolIsValid
+    uriProtocolIsValid                      ,
+
+
+-- ** uriQueryHasKey
+    UriQueryHasKeyMethodInfo                ,
+    uriQueryHasKey                          ,
+
+
+-- ** uriRemoveQueryKey
+    UriRemoveQueryKeyMethodInfo             ,
+    uriRemoveQueryKey                       ,
+
+
+-- ** uriSetFragment
+    UriSetFragmentMethodInfo                ,
+    uriSetFragment                          ,
+
+
+-- ** uriSetHost
+    UriSetHostMethodInfo                    ,
+    uriSetHost                              ,
+
+
+-- ** uriSetPath
+    UriSetPathMethodInfo                    ,
+    uriSetPath                              ,
+
+
+-- ** uriSetPathSegments
+    UriSetPathSegmentsMethodInfo            ,
+    uriSetPathSegments                      ,
+
+
+-- ** uriSetPathString
+    UriSetPathStringMethodInfo              ,
+    uriSetPathString                        ,
+
+
+-- ** uriSetPort
+    UriSetPortMethodInfo                    ,
+    uriSetPort                              ,
+
+
+-- ** uriSetQueryString
+    UriSetQueryStringMethodInfo             ,
+    uriSetQueryString                       ,
+
+
+-- ** uriSetQueryTable
+    UriSetQueryTableMethodInfo              ,
+    uriSetQueryTable                        ,
+
+
+-- ** uriSetQueryValue
+    UriSetQueryValueMethodInfo              ,
+    uriSetQueryValue                        ,
+
+
+-- ** uriSetScheme
+    UriSetSchemeMethodInfo                  ,
+    uriSetScheme                            ,
+
+
+-- ** uriSetUserinfo
+    UriSetUserinfoMethodInfo                ,
+    uriSetUserinfo                          ,
+
+
+-- ** uriToString
+    UriToStringMethodInfo                   ,
+    uriToString                             ,
+
+
+
+
+    ) where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+import GI.Gst.Callbacks
+
+newtype Uri = Uri (ForeignPtr Uri)
+foreign import ccall "gst_uri_get_type" c_gst_uri_get_type :: 
+    IO GType
+
+instance BoxedObject Uri where
+    boxedType _ = c_gst_uri_get_type
+
+noUri :: Maybe Uri
+noUri = Nothing
+
+-- method Uri::new
+-- method type : Constructor
+-- Args : [Arg {argCName = "scheme", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "userinfo", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "host", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "port", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "query", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fragment", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Uri"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_uri_new" gst_uri_new :: 
+    CString ->                              -- scheme : TBasicType TUTF8
+    CString ->                              -- userinfo : TBasicType TUTF8
+    CString ->                              -- host : TBasicType TUTF8
+    Word32 ->                               -- port : TBasicType TUInt32
+    CString ->                              -- path : TBasicType TUTF8
+    CString ->                              -- query : TBasicType TUTF8
+    CString ->                              -- fragment : TBasicType TUTF8
+    IO (Ptr Uri)
+
+
+uriNew ::
+    (MonadIO m) =>
+    Maybe (T.Text)                          -- scheme
+    -> Maybe (T.Text)                       -- userinfo
+    -> Maybe (T.Text)                       -- host
+    -> Word32                               -- port
+    -> Maybe (T.Text)                       -- path
+    -> Maybe (T.Text)                       -- query
+    -> Maybe (T.Text)                       -- fragment
+    -> m Uri                                -- result
+uriNew scheme userinfo host port path query fragment = liftIO $ do
+    maybeScheme <- case scheme of
+        Nothing -> return nullPtr
+        Just jScheme -> do
+            jScheme' <- textToCString jScheme
+            return jScheme'
+    maybeUserinfo <- case userinfo of
+        Nothing -> return nullPtr
+        Just jUserinfo -> do
+            jUserinfo' <- textToCString jUserinfo
+            return jUserinfo'
+    maybeHost <- case host of
+        Nothing -> return nullPtr
+        Just jHost -> do
+            jHost' <- textToCString jHost
+            return jHost'
+    maybePath <- case path of
+        Nothing -> return nullPtr
+        Just jPath -> do
+            jPath' <- textToCString jPath
+            return jPath'
+    maybeQuery <- case query of
+        Nothing -> return nullPtr
+        Just jQuery -> do
+            jQuery' <- textToCString jQuery
+            return jQuery'
+    maybeFragment <- case fragment of
+        Nothing -> return nullPtr
+        Just jFragment -> do
+            jFragment' <- textToCString jFragment
+            return jFragment'
+    result <- gst_uri_new maybeScheme maybeUserinfo maybeHost port maybePath maybeQuery maybeFragment
+    checkUnexpectedReturnNULL "gst_uri_new" result
+    result' <- (wrapBoxed Uri) result
+    freeMem maybeScheme
+    freeMem maybeUserinfo
+    freeMem maybeHost
+    freeMem maybePath
+    freeMem maybeQuery
+    freeMem maybeFragment
+    return result'
+
+-- method Uri::append_path
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Uri", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "relative_path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_uri_append_path" gst_uri_append_path :: 
+    Ptr Uri ->                              -- _obj : TInterface "Gst" "Uri"
+    CString ->                              -- relative_path : TBasicType TUTF8
+    IO CInt
+
+
+uriAppendPath ::
+    (MonadIO m) =>
+    Uri                                     -- _obj
+    -> T.Text                               -- relativePath
+    -> m Bool                               -- result
+uriAppendPath _obj relativePath = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    relativePath' <- textToCString relativePath
+    result <- gst_uri_append_path _obj' relativePath'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    freeMem relativePath'
+    return result'
+
+data UriAppendPathMethodInfo
+instance (signature ~ (T.Text -> m Bool), MonadIO m) => MethodInfo UriAppendPathMethodInfo Uri signature where
+    overloadedMethod _ = uriAppendPath
+
+-- method Uri::append_path_segment
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Uri", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path_segment", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_uri_append_path_segment" gst_uri_append_path_segment :: 
+    Ptr Uri ->                              -- _obj : TInterface "Gst" "Uri"
+    CString ->                              -- path_segment : TBasicType TUTF8
+    IO CInt
+
+
+uriAppendPathSegment ::
+    (MonadIO m) =>
+    Uri                                     -- _obj
+    -> T.Text                               -- pathSegment
+    -> m Bool                               -- result
+uriAppendPathSegment _obj pathSegment = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    pathSegment' <- textToCString pathSegment
+    result <- gst_uri_append_path_segment _obj' pathSegment'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    freeMem pathSegment'
+    return result'
+
+data UriAppendPathSegmentMethodInfo
+instance (signature ~ (T.Text -> m Bool), MonadIO m) => MethodInfo UriAppendPathSegmentMethodInfo Uri signature where
+    overloadedMethod _ = uriAppendPathSegment
+
+-- method Uri::equal
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Uri", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "second", argType = TInterface "Gst" "Uri", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_uri_equal" gst_uri_equal :: 
+    Ptr Uri ->                              -- _obj : TInterface "Gst" "Uri"
+    Ptr Uri ->                              -- second : TInterface "Gst" "Uri"
+    IO CInt
+
+
+uriEqual ::
+    (MonadIO m) =>
+    Uri                                     -- _obj
+    -> Uri                                  -- second
+    -> m Bool                               -- result
+uriEqual _obj second = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    let second' = unsafeManagedPtrGetPtr second
+    result <- gst_uri_equal _obj' second'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    touchManagedPtr second
+    return result'
+
+data UriEqualMethodInfo
+instance (signature ~ (Uri -> m Bool), MonadIO m) => MethodInfo UriEqualMethodInfo Uri signature where
+    overloadedMethod _ = uriEqual
+
+-- method Uri::from_string_with_base
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Uri", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Uri"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_uri_from_string_with_base" gst_uri_from_string_with_base :: 
+    Ptr Uri ->                              -- _obj : TInterface "Gst" "Uri"
+    CString ->                              -- uri : TBasicType TUTF8
+    IO (Ptr Uri)
+
+
+uriFromStringWithBase ::
+    (MonadIO m) =>
+    Uri                                     -- _obj
+    -> T.Text                               -- uri
+    -> m Uri                                -- result
+uriFromStringWithBase _obj uri = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    uri' <- textToCString uri
+    result <- gst_uri_from_string_with_base _obj' uri'
+    checkUnexpectedReturnNULL "gst_uri_from_string_with_base" result
+    result' <- (wrapBoxed Uri) result
+    touchManagedPtr _obj
+    freeMem uri'
+    return result'
+
+data UriFromStringWithBaseMethodInfo
+instance (signature ~ (T.Text -> m Uri), MonadIO m) => MethodInfo UriFromStringWithBaseMethodInfo Uri signature where
+    overloadedMethod _ = uriFromStringWithBase
+
+-- method Uri::get_fragment
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Uri", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUTF8
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_uri_get_fragment" gst_uri_get_fragment :: 
+    Ptr Uri ->                              -- _obj : TInterface "Gst" "Uri"
+    IO CString
+
+
+uriGetFragment ::
+    (MonadIO m) =>
+    Uri                                     -- _obj
+    -> m T.Text                             -- result
+uriGetFragment _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_uri_get_fragment _obj'
+    checkUnexpectedReturnNULL "gst_uri_get_fragment" result
+    result' <- cstringToText result
+    touchManagedPtr _obj
+    return result'
+
+data UriGetFragmentMethodInfo
+instance (signature ~ (m T.Text), MonadIO m) => MethodInfo UriGetFragmentMethodInfo Uri signature where
+    overloadedMethod _ = uriGetFragment
+
+-- method Uri::get_host
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Uri", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUTF8
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_uri_get_host" gst_uri_get_host :: 
+    Ptr Uri ->                              -- _obj : TInterface "Gst" "Uri"
+    IO CString
+
+
+uriGetHost ::
+    (MonadIO m) =>
+    Uri                                     -- _obj
+    -> m T.Text                             -- result
+uriGetHost _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_uri_get_host _obj'
+    checkUnexpectedReturnNULL "gst_uri_get_host" result
+    result' <- cstringToText result
+    touchManagedPtr _obj
+    return result'
+
+data UriGetHostMethodInfo
+instance (signature ~ (m T.Text), MonadIO m) => MethodInfo UriGetHostMethodInfo Uri signature where
+    overloadedMethod _ = uriGetHost
+
+-- method Uri::get_path
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Uri", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUTF8
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_uri_get_path" gst_uri_get_path :: 
+    Ptr Uri ->                              -- _obj : TInterface "Gst" "Uri"
+    IO CString
+
+
+uriGetPath ::
+    (MonadIO m) =>
+    Uri                                     -- _obj
+    -> m T.Text                             -- result
+uriGetPath _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_uri_get_path _obj'
+    checkUnexpectedReturnNULL "gst_uri_get_path" result
+    result' <- cstringToText result
+    freeMem result
+    touchManagedPtr _obj
+    return result'
+
+data UriGetPathMethodInfo
+instance (signature ~ (m T.Text), MonadIO m) => MethodInfo UriGetPathMethodInfo Uri signature where
+    overloadedMethod _ = uriGetPath
+
+-- method Uri::get_path_segments
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Uri", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TGList (TBasicType TUTF8)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_uri_get_path_segments" gst_uri_get_path_segments :: 
+    Ptr Uri ->                              -- _obj : TInterface "Gst" "Uri"
+    IO (Ptr (GList CString))
+
+
+uriGetPathSegments ::
+    (MonadIO m) =>
+    Uri                                     -- _obj
+    -> m [T.Text]                           -- result
+uriGetPathSegments _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_uri_get_path_segments _obj'
+    checkUnexpectedReturnNULL "gst_uri_get_path_segments" result
+    result' <- unpackGList result
+    result'' <- mapM cstringToText result'
+    mapGList freeMem result
+    g_list_free result
+    touchManagedPtr _obj
+    return result''
+
+data UriGetPathSegmentsMethodInfo
+instance (signature ~ (m [T.Text]), MonadIO m) => MethodInfo UriGetPathSegmentsMethodInfo Uri signature where
+    overloadedMethod _ = uriGetPathSegments
+
+-- method Uri::get_path_string
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Uri", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUTF8
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_uri_get_path_string" gst_uri_get_path_string :: 
+    Ptr Uri ->                              -- _obj : TInterface "Gst" "Uri"
+    IO CString
+
+
+uriGetPathString ::
+    (MonadIO m) =>
+    Uri                                     -- _obj
+    -> m T.Text                             -- result
+uriGetPathString _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_uri_get_path_string _obj'
+    checkUnexpectedReturnNULL "gst_uri_get_path_string" result
+    result' <- cstringToText result
+    freeMem result
+    touchManagedPtr _obj
+    return result'
+
+data UriGetPathStringMethodInfo
+instance (signature ~ (m T.Text), MonadIO m) => MethodInfo UriGetPathStringMethodInfo Uri signature where
+    overloadedMethod _ = uriGetPathString
+
+-- method Uri::get_port
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Uri", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUInt32
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_uri_get_port" gst_uri_get_port :: 
+    Ptr Uri ->                              -- _obj : TInterface "Gst" "Uri"
+    IO Word32
+
+
+uriGetPort ::
+    (MonadIO m) =>
+    Uri                                     -- _obj
+    -> m Word32                             -- result
+uriGetPort _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_uri_get_port _obj'
+    touchManagedPtr _obj
+    return result
+
+data UriGetPortMethodInfo
+instance (signature ~ (m Word32), MonadIO m) => MethodInfo UriGetPortMethodInfo Uri signature where
+    overloadedMethod _ = uriGetPort
+
+-- method Uri::get_query_keys
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Uri", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TGList (TBasicType TUTF8)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_uri_get_query_keys" gst_uri_get_query_keys :: 
+    Ptr Uri ->                              -- _obj : TInterface "Gst" "Uri"
+    IO (Ptr (GList CString))
+
+
+uriGetQueryKeys ::
+    (MonadIO m) =>
+    Uri                                     -- _obj
+    -> m [T.Text]                           -- result
+uriGetQueryKeys _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_uri_get_query_keys _obj'
+    checkUnexpectedReturnNULL "gst_uri_get_query_keys" result
+    result' <- unpackGList result
+    result'' <- mapM cstringToText result'
+    g_list_free result
+    touchManagedPtr _obj
+    return result''
+
+data UriGetQueryKeysMethodInfo
+instance (signature ~ (m [T.Text]), MonadIO m) => MethodInfo UriGetQueryKeysMethodInfo Uri signature where
+    overloadedMethod _ = uriGetQueryKeys
+
+-- method Uri::get_query_string
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Uri", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUTF8
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_uri_get_query_string" gst_uri_get_query_string :: 
+    Ptr Uri ->                              -- _obj : TInterface "Gst" "Uri"
+    IO CString
+
+
+uriGetQueryString ::
+    (MonadIO m) =>
+    Uri                                     -- _obj
+    -> m T.Text                             -- result
+uriGetQueryString _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_uri_get_query_string _obj'
+    checkUnexpectedReturnNULL "gst_uri_get_query_string" result
+    result' <- cstringToText result
+    freeMem result
+    touchManagedPtr _obj
+    return result'
+
+data UriGetQueryStringMethodInfo
+instance (signature ~ (m T.Text), MonadIO m) => MethodInfo UriGetQueryStringMethodInfo Uri signature where
+    overloadedMethod _ = uriGetQueryString
+
+-- method Uri::get_query_table
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Uri", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TGHash (TBasicType TUTF8) (TBasicType TUTF8)
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_uri_get_query_table" gst_uri_get_query_table :: 
+    Ptr Uri ->                              -- _obj : TInterface "Gst" "Uri"
+    IO (Ptr (GHashTable CString CString))
+
+
+uriGetQueryTable ::
+    (MonadIO m) =>
+    Uri                                     -- _obj
+    -> m (Map.Map T.Text T.Text)            -- result
+uriGetQueryTable _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_uri_get_query_table _obj'
+    checkUnexpectedReturnNULL "gst_uri_get_query_table" result
+    result' <- unpackGHashTable result
+    let result'' = mapFirst cstringUnpackPtr result'
+    result''' <- mapFirstA cstringToText result''
+    let result'''' = mapSecond cstringUnpackPtr result'''
+    result''''' <- mapSecondA cstringToText result''''
+    let result'''''' = Map.fromList result'''''
+    unrefGHashTable result
+    touchManagedPtr _obj
+    return result''''''
+
+data UriGetQueryTableMethodInfo
+instance (signature ~ (m (Map.Map T.Text T.Text)), MonadIO m) => MethodInfo UriGetQueryTableMethodInfo Uri signature where
+    overloadedMethod _ = uriGetQueryTable
+
+-- method Uri::get_query_value
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Uri", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "query_key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUTF8
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_uri_get_query_value" gst_uri_get_query_value :: 
+    Ptr Uri ->                              -- _obj : TInterface "Gst" "Uri"
+    CString ->                              -- query_key : TBasicType TUTF8
+    IO CString
+
+
+uriGetQueryValue ::
+    (MonadIO m) =>
+    Uri                                     -- _obj
+    -> T.Text                               -- queryKey
+    -> m T.Text                             -- result
+uriGetQueryValue _obj queryKey = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    queryKey' <- textToCString queryKey
+    result <- gst_uri_get_query_value _obj' queryKey'
+    checkUnexpectedReturnNULL "gst_uri_get_query_value" result
+    result' <- cstringToText result
+    touchManagedPtr _obj
+    freeMem queryKey'
+    return result'
+
+data UriGetQueryValueMethodInfo
+instance (signature ~ (T.Text -> m T.Text), MonadIO m) => MethodInfo UriGetQueryValueMethodInfo Uri signature where
+    overloadedMethod _ = uriGetQueryValue
+
+-- method Uri::get_scheme
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Uri", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUTF8
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_uri_get_scheme" gst_uri_get_scheme :: 
+    Ptr Uri ->                              -- _obj : TInterface "Gst" "Uri"
+    IO CString
+
+
+uriGetScheme ::
+    (MonadIO m) =>
+    Uri                                     -- _obj
+    -> m T.Text                             -- result
+uriGetScheme _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_uri_get_scheme _obj'
+    checkUnexpectedReturnNULL "gst_uri_get_scheme" result
+    result' <- cstringToText result
+    touchManagedPtr _obj
+    return result'
+
+data UriGetSchemeMethodInfo
+instance (signature ~ (m T.Text), MonadIO m) => MethodInfo UriGetSchemeMethodInfo Uri signature where
+    overloadedMethod _ = uriGetScheme
+
+-- method Uri::get_userinfo
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Uri", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUTF8
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_uri_get_userinfo" gst_uri_get_userinfo :: 
+    Ptr Uri ->                              -- _obj : TInterface "Gst" "Uri"
+    IO CString
+
+
+uriGetUserinfo ::
+    (MonadIO m) =>
+    Uri                                     -- _obj
+    -> m T.Text                             -- result
+uriGetUserinfo _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_uri_get_userinfo _obj'
+    checkUnexpectedReturnNULL "gst_uri_get_userinfo" result
+    result' <- cstringToText result
+    touchManagedPtr _obj
+    return result'
+
+data UriGetUserinfoMethodInfo
+instance (signature ~ (m T.Text), MonadIO m) => MethodInfo UriGetUserinfoMethodInfo Uri signature where
+    overloadedMethod _ = uriGetUserinfo
+
+-- method Uri::is_normalized
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Uri", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_uri_is_normalized" gst_uri_is_normalized :: 
+    Ptr Uri ->                              -- _obj : TInterface "Gst" "Uri"
+    IO CInt
+
+
+uriIsNormalized ::
+    (MonadIO m) =>
+    Uri                                     -- _obj
+    -> m Bool                               -- result
+uriIsNormalized _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_uri_is_normalized _obj'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data UriIsNormalizedMethodInfo
+instance (signature ~ (m Bool), MonadIO m) => MethodInfo UriIsNormalizedMethodInfo Uri signature where
+    overloadedMethod _ = uriIsNormalized
+
+-- method Uri::is_writable
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Uri", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_uri_is_writable" gst_uri_is_writable :: 
+    Ptr Uri ->                              -- _obj : TInterface "Gst" "Uri"
+    IO CInt
+
+
+uriIsWritable ::
+    (MonadIO m) =>
+    Uri                                     -- _obj
+    -> m Bool                               -- result
+uriIsWritable _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_uri_is_writable _obj'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data UriIsWritableMethodInfo
+instance (signature ~ (m Bool), MonadIO m) => MethodInfo UriIsWritableMethodInfo Uri signature where
+    overloadedMethod _ = uriIsWritable
+
+-- method Uri::join
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Uri", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "ref_uri", argType = TInterface "Gst" "Uri", direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Uri"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_uri_join" gst_uri_join :: 
+    Ptr Uri ->                              -- _obj : TInterface "Gst" "Uri"
+    Ptr Uri ->                              -- ref_uri : TInterface "Gst" "Uri"
+    IO (Ptr Uri)
+
+
+uriJoin ::
+    (MonadIO m) =>
+    Uri                                     -- _obj
+    -> Maybe (Uri)                          -- refUri
+    -> m Uri                                -- result
+uriJoin _obj refUri = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    maybeRefUri <- case refUri of
+        Nothing -> return nullPtr
+        Just jRefUri -> do
+            let jRefUri' = unsafeManagedPtrGetPtr jRefUri
+            return jRefUri'
+    result <- gst_uri_join _obj' maybeRefUri
+    checkUnexpectedReturnNULL "gst_uri_join" result
+    result' <- (wrapBoxed Uri) result
+    touchManagedPtr _obj
+    whenJust refUri touchManagedPtr
+    return result'
+
+data UriJoinMethodInfo
+instance (signature ~ (Maybe (Uri) -> m Uri), MonadIO m) => MethodInfo UriJoinMethodInfo Uri signature where
+    overloadedMethod _ = uriJoin
+
+-- method Uri::make_writable
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Uri", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Uri"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_uri_make_writable" gst_uri_make_writable :: 
+    Ptr Uri ->                              -- _obj : TInterface "Gst" "Uri"
+    IO (Ptr Uri)
+
+
+uriMakeWritable ::
+    (MonadIO m) =>
+    Uri                                     -- _obj
+    -> m Uri                                -- result
+uriMakeWritable _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_uri_make_writable _obj'
+    checkUnexpectedReturnNULL "gst_uri_make_writable" result
+    result' <- (wrapBoxed Uri) result
+    touchManagedPtr _obj
+    return result'
+
+data UriMakeWritableMethodInfo
+instance (signature ~ (m Uri), MonadIO m) => MethodInfo UriMakeWritableMethodInfo Uri signature where
+    overloadedMethod _ = uriMakeWritable
+
+-- method Uri::new_with_base
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Uri", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "scheme", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "userinfo", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "host", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "port", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "query", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fragment", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Uri"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_uri_new_with_base" gst_uri_new_with_base :: 
+    Ptr Uri ->                              -- _obj : TInterface "Gst" "Uri"
+    CString ->                              -- scheme : TBasicType TUTF8
+    CString ->                              -- userinfo : TBasicType TUTF8
+    CString ->                              -- host : TBasicType TUTF8
+    Word32 ->                               -- port : TBasicType TUInt32
+    CString ->                              -- path : TBasicType TUTF8
+    CString ->                              -- query : TBasicType TUTF8
+    CString ->                              -- fragment : TBasicType TUTF8
+    IO (Ptr Uri)
+
+
+uriNewWithBase ::
+    (MonadIO m) =>
+    Uri                                     -- _obj
+    -> Maybe (T.Text)                       -- scheme
+    -> Maybe (T.Text)                       -- userinfo
+    -> Maybe (T.Text)                       -- host
+    -> Word32                               -- port
+    -> Maybe (T.Text)                       -- path
+    -> Maybe (T.Text)                       -- query
+    -> Maybe (T.Text)                       -- fragment
+    -> m Uri                                -- result
+uriNewWithBase _obj scheme userinfo host port path query fragment = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    maybeScheme <- case scheme of
+        Nothing -> return nullPtr
+        Just jScheme -> do
+            jScheme' <- textToCString jScheme
+            return jScheme'
+    maybeUserinfo <- case userinfo of
+        Nothing -> return nullPtr
+        Just jUserinfo -> do
+            jUserinfo' <- textToCString jUserinfo
+            return jUserinfo'
+    maybeHost <- case host of
+        Nothing -> return nullPtr
+        Just jHost -> do
+            jHost' <- textToCString jHost
+            return jHost'
+    maybePath <- case path of
+        Nothing -> return nullPtr
+        Just jPath -> do
+            jPath' <- textToCString jPath
+            return jPath'
+    maybeQuery <- case query of
+        Nothing -> return nullPtr
+        Just jQuery -> do
+            jQuery' <- textToCString jQuery
+            return jQuery'
+    maybeFragment <- case fragment of
+        Nothing -> return nullPtr
+        Just jFragment -> do
+            jFragment' <- textToCString jFragment
+            return jFragment'
+    result <- gst_uri_new_with_base _obj' maybeScheme maybeUserinfo maybeHost port maybePath maybeQuery maybeFragment
+    checkUnexpectedReturnNULL "gst_uri_new_with_base" result
+    result' <- (wrapBoxed Uri) result
+    touchManagedPtr _obj
+    freeMem maybeScheme
+    freeMem maybeUserinfo
+    freeMem maybeHost
+    freeMem maybePath
+    freeMem maybeQuery
+    freeMem maybeFragment
+    return result'
+
+data UriNewWithBaseMethodInfo
+instance (signature ~ (Maybe (T.Text) -> Maybe (T.Text) -> Maybe (T.Text) -> Word32 -> Maybe (T.Text) -> Maybe (T.Text) -> Maybe (T.Text) -> m Uri), MonadIO m) => MethodInfo UriNewWithBaseMethodInfo Uri signature where
+    overloadedMethod _ = uriNewWithBase
+
+-- method Uri::normalize
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Uri", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_uri_normalize" gst_uri_normalize :: 
+    Ptr Uri ->                              -- _obj : TInterface "Gst" "Uri"
+    IO CInt
+
+
+uriNormalize ::
+    (MonadIO m) =>
+    Uri                                     -- _obj
+    -> m Bool                               -- result
+uriNormalize _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_uri_normalize _obj'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data UriNormalizeMethodInfo
+instance (signature ~ (m Bool), MonadIO m) => MethodInfo UriNormalizeMethodInfo Uri signature where
+    overloadedMethod _ = uriNormalize
+
+-- method Uri::query_has_key
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Uri", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "query_key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_uri_query_has_key" gst_uri_query_has_key :: 
+    Ptr Uri ->                              -- _obj : TInterface "Gst" "Uri"
+    CString ->                              -- query_key : TBasicType TUTF8
+    IO CInt
+
+
+uriQueryHasKey ::
+    (MonadIO m) =>
+    Uri                                     -- _obj
+    -> T.Text                               -- queryKey
+    -> m Bool                               -- result
+uriQueryHasKey _obj queryKey = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    queryKey' <- textToCString queryKey
+    result <- gst_uri_query_has_key _obj' queryKey'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    freeMem queryKey'
+    return result'
+
+data UriQueryHasKeyMethodInfo
+instance (signature ~ (T.Text -> m Bool), MonadIO m) => MethodInfo UriQueryHasKeyMethodInfo Uri signature where
+    overloadedMethod _ = uriQueryHasKey
+
+-- method Uri::remove_query_key
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Uri", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "query_key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_uri_remove_query_key" gst_uri_remove_query_key :: 
+    Ptr Uri ->                              -- _obj : TInterface "Gst" "Uri"
+    CString ->                              -- query_key : TBasicType TUTF8
+    IO CInt
+
+
+uriRemoveQueryKey ::
+    (MonadIO m) =>
+    Uri                                     -- _obj
+    -> T.Text                               -- queryKey
+    -> m Bool                               -- result
+uriRemoveQueryKey _obj queryKey = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    queryKey' <- textToCString queryKey
+    result <- gst_uri_remove_query_key _obj' queryKey'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    freeMem queryKey'
+    return result'
+
+data UriRemoveQueryKeyMethodInfo
+instance (signature ~ (T.Text -> m Bool), MonadIO m) => MethodInfo UriRemoveQueryKeyMethodInfo Uri signature where
+    overloadedMethod _ = uriRemoveQueryKey
+
+-- method Uri::set_fragment
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Uri", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "fragment", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_uri_set_fragment" gst_uri_set_fragment :: 
+    Ptr Uri ->                              -- _obj : TInterface "Gst" "Uri"
+    CString ->                              -- fragment : TBasicType TUTF8
+    IO CInt
+
+
+uriSetFragment ::
+    (MonadIO m) =>
+    Uri                                     -- _obj
+    -> Maybe (T.Text)                       -- fragment
+    -> m Bool                               -- result
+uriSetFragment _obj fragment = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    maybeFragment <- case fragment of
+        Nothing -> return nullPtr
+        Just jFragment -> do
+            jFragment' <- textToCString jFragment
+            return jFragment'
+    result <- gst_uri_set_fragment _obj' maybeFragment
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    freeMem maybeFragment
+    return result'
+
+data UriSetFragmentMethodInfo
+instance (signature ~ (Maybe (T.Text) -> m Bool), MonadIO m) => MethodInfo UriSetFragmentMethodInfo Uri signature where
+    overloadedMethod _ = uriSetFragment
+
+-- method Uri::set_host
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Uri", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "host", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_uri_set_host" gst_uri_set_host :: 
+    Ptr Uri ->                              -- _obj : TInterface "Gst" "Uri"
+    CString ->                              -- host : TBasicType TUTF8
+    IO CInt
+
+
+uriSetHost ::
+    (MonadIO m) =>
+    Uri                                     -- _obj
+    -> T.Text                               -- host
+    -> m Bool                               -- result
+uriSetHost _obj host = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    host' <- textToCString host
+    result <- gst_uri_set_host _obj' host'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    freeMem host'
+    return result'
+
+data UriSetHostMethodInfo
+instance (signature ~ (T.Text -> m Bool), MonadIO m) => MethodInfo UriSetHostMethodInfo Uri signature where
+    overloadedMethod _ = uriSetHost
+
+-- method Uri::set_path
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Uri", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_uri_set_path" gst_uri_set_path :: 
+    Ptr Uri ->                              -- _obj : TInterface "Gst" "Uri"
+    CString ->                              -- path : TBasicType TUTF8
+    IO CInt
+
+
+uriSetPath ::
+    (MonadIO m) =>
+    Uri                                     -- _obj
+    -> T.Text                               -- path
+    -> m Bool                               -- result
+uriSetPath _obj path = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    path' <- textToCString path
+    result <- gst_uri_set_path _obj' path'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    freeMem path'
+    return result'
+
+data UriSetPathMethodInfo
+instance (signature ~ (T.Text -> m Bool), MonadIO m) => MethodInfo UriSetPathMethodInfo Uri signature where
+    overloadedMethod _ = uriSetPath
+
+-- method Uri::set_path_segments
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Uri", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path_segments", argType = TGList (TBasicType TUTF8), direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_uri_set_path_segments" gst_uri_set_path_segments :: 
+    Ptr Uri ->                              -- _obj : TInterface "Gst" "Uri"
+    Ptr (GList CString) ->                  -- path_segments : TGList (TBasicType TUTF8)
+    IO CInt
+
+
+uriSetPathSegments ::
+    (MonadIO m) =>
+    Uri                                     -- _obj
+    -> [T.Text]                             -- pathSegments
+    -> m Bool                               -- result
+uriSetPathSegments _obj pathSegments = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    pathSegments' <- mapM textToCString pathSegments
+    pathSegments'' <- packGList pathSegments'
+    result <- gst_uri_set_path_segments _obj' pathSegments''
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data UriSetPathSegmentsMethodInfo
+instance (signature ~ ([T.Text] -> m Bool), MonadIO m) => MethodInfo UriSetPathSegmentsMethodInfo Uri signature where
+    overloadedMethod _ = uriSetPathSegments
+
+-- method Uri::set_path_string
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Uri", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "path", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_uri_set_path_string" gst_uri_set_path_string :: 
+    Ptr Uri ->                              -- _obj : TInterface "Gst" "Uri"
+    CString ->                              -- path : TBasicType TUTF8
+    IO CInt
+
+
+uriSetPathString ::
+    (MonadIO m) =>
+    Uri                                     -- _obj
+    -> T.Text                               -- path
+    -> m Bool                               -- result
+uriSetPathString _obj path = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    path' <- textToCString path
+    result <- gst_uri_set_path_string _obj' path'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    freeMem path'
+    return result'
+
+data UriSetPathStringMethodInfo
+instance (signature ~ (T.Text -> m Bool), MonadIO m) => MethodInfo UriSetPathStringMethodInfo Uri signature where
+    overloadedMethod _ = uriSetPathString
+
+-- method Uri::set_port
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Uri", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "port", argType = TBasicType TUInt32, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_uri_set_port" gst_uri_set_port :: 
+    Ptr Uri ->                              -- _obj : TInterface "Gst" "Uri"
+    Word32 ->                               -- port : TBasicType TUInt32
+    IO CInt
+
+
+uriSetPort ::
+    (MonadIO m) =>
+    Uri                                     -- _obj
+    -> Word32                               -- port
+    -> m Bool                               -- result
+uriSetPort _obj port = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_uri_set_port _obj' port
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    return result'
+
+data UriSetPortMethodInfo
+instance (signature ~ (Word32 -> m Bool), MonadIO m) => MethodInfo UriSetPortMethodInfo Uri signature where
+    overloadedMethod _ = uriSetPort
+
+-- method Uri::set_query_string
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Uri", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "query", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_uri_set_query_string" gst_uri_set_query_string :: 
+    Ptr Uri ->                              -- _obj : TInterface "Gst" "Uri"
+    CString ->                              -- query : TBasicType TUTF8
+    IO CInt
+
+
+uriSetQueryString ::
+    (MonadIO m) =>
+    Uri                                     -- _obj
+    -> T.Text                               -- query
+    -> m Bool                               -- result
+uriSetQueryString _obj query = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    query' <- textToCString query
+    result <- gst_uri_set_query_string _obj' query'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    freeMem query'
+    return result'
+
+data UriSetQueryStringMethodInfo
+instance (signature ~ (T.Text -> m Bool), MonadIO m) => MethodInfo UriSetQueryStringMethodInfo Uri signature where
+    overloadedMethod _ = uriSetQueryString
+
+-- method Uri::set_query_table
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Uri", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "query_table", argType = TGHash (TBasicType TUTF8) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_uri_set_query_table" gst_uri_set_query_table :: 
+    Ptr Uri ->                              -- _obj : TInterface "Gst" "Uri"
+    Ptr (GHashTable CString CString) ->     -- query_table : TGHash (TBasicType TUTF8) (TBasicType TUTF8)
+    IO CInt
+
+
+uriSetQueryTable ::
+    (MonadIO m) =>
+    Uri                                     -- _obj
+    -> Maybe (Map.Map T.Text T.Text)        -- queryTable
+    -> m Bool                               -- result
+uriSetQueryTable _obj queryTable = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    maybeQueryTable <- case queryTable of
+        Nothing -> return nullPtr
+        Just jQueryTable -> do
+            let jQueryTable' = Map.toList jQueryTable
+            jQueryTable'' <- mapFirstA textToCString jQueryTable'
+            jQueryTable''' <- mapSecondA textToCString jQueryTable''
+            let jQueryTable'''' = mapFirst cstringPackPtr jQueryTable'''
+            let jQueryTable''''' = mapSecond cstringPackPtr jQueryTable''''
+            jQueryTable'''''' <- packGHashTable gStrHash gStrEqual (Just ptr_to_g_free) (Just ptr_to_g_free) jQueryTable'''''
+            return jQueryTable''''''
+    result <- gst_uri_set_query_table _obj' maybeQueryTable
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    unrefGHashTable maybeQueryTable
+    return result'
+
+data UriSetQueryTableMethodInfo
+instance (signature ~ (Maybe (Map.Map T.Text T.Text) -> m Bool), MonadIO m) => MethodInfo UriSetQueryTableMethodInfo Uri signature where
+    overloadedMethod _ = uriSetQueryTable
+
+-- method Uri::set_query_value
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Uri", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "query_key", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "query_value", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_uri_set_query_value" gst_uri_set_query_value :: 
+    Ptr Uri ->                              -- _obj : TInterface "Gst" "Uri"
+    CString ->                              -- query_key : TBasicType TUTF8
+    CString ->                              -- query_value : TBasicType TUTF8
+    IO CInt
+
+
+uriSetQueryValue ::
+    (MonadIO m) =>
+    Uri                                     -- _obj
+    -> T.Text                               -- queryKey
+    -> Maybe (T.Text)                       -- queryValue
+    -> m Bool                               -- result
+uriSetQueryValue _obj queryKey queryValue = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    queryKey' <- textToCString queryKey
+    maybeQueryValue <- case queryValue of
+        Nothing -> return nullPtr
+        Just jQueryValue -> do
+            jQueryValue' <- textToCString jQueryValue
+            return jQueryValue'
+    result <- gst_uri_set_query_value _obj' queryKey' maybeQueryValue
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    freeMem queryKey'
+    freeMem maybeQueryValue
+    return result'
+
+data UriSetQueryValueMethodInfo
+instance (signature ~ (T.Text -> Maybe (T.Text) -> m Bool), MonadIO m) => MethodInfo UriSetQueryValueMethodInfo Uri signature where
+    overloadedMethod _ = uriSetQueryValue
+
+-- method Uri::set_scheme
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Uri", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "scheme", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_uri_set_scheme" gst_uri_set_scheme :: 
+    Ptr Uri ->                              -- _obj : TInterface "Gst" "Uri"
+    CString ->                              -- scheme : TBasicType TUTF8
+    IO CInt
+
+
+uriSetScheme ::
+    (MonadIO m) =>
+    Uri                                     -- _obj
+    -> T.Text                               -- scheme
+    -> m Bool                               -- result
+uriSetScheme _obj scheme = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    scheme' <- textToCString scheme
+    result <- gst_uri_set_scheme _obj' scheme'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    freeMem scheme'
+    return result'
+
+data UriSetSchemeMethodInfo
+instance (signature ~ (T.Text -> m Bool), MonadIO m) => MethodInfo UriSetSchemeMethodInfo Uri signature where
+    overloadedMethod _ = uriSetScheme
+
+-- method Uri::set_userinfo
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Uri", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "userinfo", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_uri_set_userinfo" gst_uri_set_userinfo :: 
+    Ptr Uri ->                              -- _obj : TInterface "Gst" "Uri"
+    CString ->                              -- userinfo : TBasicType TUTF8
+    IO CInt
+
+
+uriSetUserinfo ::
+    (MonadIO m) =>
+    Uri                                     -- _obj
+    -> T.Text                               -- userinfo
+    -> m Bool                               -- result
+uriSetUserinfo _obj userinfo = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    userinfo' <- textToCString userinfo
+    result <- gst_uri_set_userinfo _obj' userinfo'
+    let result' = (/= 0) result
+    touchManagedPtr _obj
+    freeMem userinfo'
+    return result'
+
+data UriSetUserinfoMethodInfo
+instance (signature ~ (T.Text -> m Bool), MonadIO m) => MethodInfo UriSetUserinfoMethodInfo Uri signature where
+    overloadedMethod _ = uriSetUserinfo
+
+-- method Uri::to_string
+-- method type : OrdinaryMethod
+-- Args : [Arg {argCName = "_obj", argType = TInterface "Gst" "Uri", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUTF8
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_uri_to_string" gst_uri_to_string :: 
+    Ptr Uri ->                              -- _obj : TInterface "Gst" "Uri"
+    IO CString
+
+
+uriToString ::
+    (MonadIO m) =>
+    Uri                                     -- _obj
+    -> m T.Text                             -- result
+uriToString _obj = liftIO $ do
+    let _obj' = unsafeManagedPtrGetPtr _obj
+    result <- gst_uri_to_string _obj'
+    checkUnexpectedReturnNULL "gst_uri_to_string" result
+    result' <- cstringToText result
+    freeMem result
+    touchManagedPtr _obj
+    return result'
+
+data UriToStringMethodInfo
+instance (signature ~ (m T.Text), MonadIO m) => MethodInfo UriToStringMethodInfo Uri signature where
+    overloadedMethod _ = uriToString
+
+-- method Uri::construct
+-- method type : MemberFunction
+-- Args : [Arg {argCName = "protocol", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "location", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUTF8
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_uri_construct" gst_uri_construct :: 
+    CString ->                              -- protocol : TBasicType TUTF8
+    CString ->                              -- location : TBasicType TUTF8
+    IO CString
+
+
+uriConstruct ::
+    (MonadIO m) =>
+    T.Text                                  -- protocol
+    -> T.Text                               -- location
+    -> m T.Text                             -- result
+uriConstruct protocol location = liftIO $ do
+    protocol' <- textToCString protocol
+    location' <- textToCString location
+    result <- gst_uri_construct protocol' location'
+    checkUnexpectedReturnNULL "gst_uri_construct" result
+    result' <- cstringToText result
+    freeMem result
+    freeMem protocol'
+    freeMem location'
+    return result'
+
+-- method Uri::from_string
+-- method type : MemberFunction
+-- Args : [Arg {argCName = "uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TInterface "Gst" "Uri"
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_uri_from_string" gst_uri_from_string :: 
+    CString ->                              -- uri : TBasicType TUTF8
+    IO (Ptr Uri)
+
+
+uriFromString ::
+    (MonadIO m) =>
+    T.Text                                  -- uri
+    -> m Uri                                -- result
+uriFromString uri = liftIO $ do
+    uri' <- textToCString uri
+    result <- gst_uri_from_string uri'
+    checkUnexpectedReturnNULL "gst_uri_from_string" result
+    result' <- (wrapBoxed Uri) result
+    freeMem uri'
+    return result'
+
+-- method Uri::get_location
+-- method type : MemberFunction
+-- Args : [Arg {argCName = "uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUTF8
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_uri_get_location" gst_uri_get_location :: 
+    CString ->                              -- uri : TBasicType TUTF8
+    IO CString
+
+
+uriGetLocation ::
+    (MonadIO m) =>
+    T.Text                                  -- uri
+    -> m T.Text                             -- result
+uriGetLocation uri = liftIO $ do
+    uri' <- textToCString uri
+    result <- gst_uri_get_location uri'
+    checkUnexpectedReturnNULL "gst_uri_get_location" result
+    result' <- cstringToText result
+    freeMem result
+    freeMem uri'
+    return result'
+
+-- method Uri::get_protocol
+-- method type : MemberFunction
+-- Args : [Arg {argCName = "uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUTF8
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_uri_get_protocol" gst_uri_get_protocol :: 
+    CString ->                              -- uri : TBasicType TUTF8
+    IO CString
+
+
+uriGetProtocol ::
+    (MonadIO m) =>
+    T.Text                                  -- uri
+    -> m T.Text                             -- result
+uriGetProtocol uri = liftIO $ do
+    uri' <- textToCString uri
+    result <- gst_uri_get_protocol uri'
+    checkUnexpectedReturnNULL "gst_uri_get_protocol" result
+    result' <- cstringToText result
+    freeMem result
+    freeMem uri'
+    return result'
+
+-- method Uri::has_protocol
+-- method type : MemberFunction
+-- Args : [Arg {argCName = "uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "protocol", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_uri_has_protocol" gst_uri_has_protocol :: 
+    CString ->                              -- uri : TBasicType TUTF8
+    CString ->                              -- protocol : TBasicType TUTF8
+    IO CInt
+
+
+uriHasProtocol ::
+    (MonadIO m) =>
+    T.Text                                  -- uri
+    -> T.Text                               -- protocol
+    -> m Bool                               -- result
+uriHasProtocol uri protocol = liftIO $ do
+    uri' <- textToCString uri
+    protocol' <- textToCString protocol
+    result <- gst_uri_has_protocol uri' protocol'
+    let result' = (/= 0) result
+    freeMem uri'
+    freeMem protocol'
+    return result'
+
+-- method Uri::is_valid
+-- method type : MemberFunction
+-- Args : [Arg {argCName = "uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_uri_is_valid" gst_uri_is_valid :: 
+    CString ->                              -- uri : TBasicType TUTF8
+    IO CInt
+
+
+uriIsValid ::
+    (MonadIO m) =>
+    T.Text                                  -- uri
+    -> m Bool                               -- result
+uriIsValid uri = liftIO $ do
+    uri' <- textToCString uri
+    result <- gst_uri_is_valid uri'
+    let result' = (/= 0) result
+    freeMem uri'
+    return result'
+
+-- method Uri::join_strings
+-- method type : MemberFunction
+-- Args : [Arg {argCName = "base_uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "ref_uri", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TUTF8
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_uri_join_strings" gst_uri_join_strings :: 
+    CString ->                              -- base_uri : TBasicType TUTF8
+    CString ->                              -- ref_uri : TBasicType TUTF8
+    IO CString
+
+
+uriJoinStrings ::
+    (MonadIO m) =>
+    T.Text                                  -- baseUri
+    -> T.Text                               -- refUri
+    -> m T.Text                             -- result
+uriJoinStrings baseUri refUri = liftIO $ do
+    baseUri' <- textToCString baseUri
+    refUri' <- textToCString refUri
+    result <- gst_uri_join_strings baseUri' refUri'
+    checkUnexpectedReturnNULL "gst_uri_join_strings" result
+    result' <- cstringToText result
+    freeMem result
+    freeMem baseUri'
+    freeMem refUri'
+    return result'
+
+-- method Uri::protocol_is_supported
+-- method type : MemberFunction
+-- Args : [Arg {argCName = "type", argType = TInterface "Gst" "URIType", direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "protocol", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_uri_protocol_is_supported" gst_uri_protocol_is_supported :: 
+    CUInt ->                                -- type : TInterface "Gst" "URIType"
+    CString ->                              -- protocol : TBasicType TUTF8
+    IO CInt
+
+
+uriProtocolIsSupported ::
+    (MonadIO m) =>
+    URIType                                 -- type_
+    -> T.Text                               -- protocol
+    -> m Bool                               -- result
+uriProtocolIsSupported type_ protocol = liftIO $ do
+    let type_' = (fromIntegral . fromEnum) type_
+    protocol' <- textToCString protocol
+    result <- gst_uri_protocol_is_supported type_' protocol'
+    let result' = (/= 0) result
+    freeMem protocol'
+    return result'
+
+-- method Uri::protocol_is_valid
+-- method type : MemberFunction
+-- Args : [Arg {argCName = "protocol", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
+-- Lengths : []
+-- returnType : TBasicType TBoolean
+-- throws : False
+-- Skip return : False
+
+foreign import ccall "gst_uri_protocol_is_valid" gst_uri_protocol_is_valid :: 
+    CString ->                              -- protocol : TBasicType TUTF8
+    IO CInt
+
+
+uriProtocolIsValid ::
+    (MonadIO m) =>
+    T.Text                                  -- protocol
+    -> m Bool                               -- result
+uriProtocolIsValid protocol = liftIO $ do
+    protocol' <- textToCString protocol
+    result <- gst_uri_protocol_is_valid protocol'
+    let result' = (/= 0) result
+    freeMem protocol'
+    return result'
+
+type family ResolveUriMethod (t :: Symbol) (o :: *) :: * where
+    ResolveUriMethod "appendPath" o = UriAppendPathMethodInfo
+    ResolveUriMethod "appendPathSegment" o = UriAppendPathSegmentMethodInfo
+    ResolveUriMethod "equal" o = UriEqualMethodInfo
+    ResolveUriMethod "fromStringWithBase" o = UriFromStringWithBaseMethodInfo
+    ResolveUriMethod "isNormalized" o = UriIsNormalizedMethodInfo
+    ResolveUriMethod "isWritable" o = UriIsWritableMethodInfo
+    ResolveUriMethod "join" o = UriJoinMethodInfo
+    ResolveUriMethod "makeWritable" o = UriMakeWritableMethodInfo
+    ResolveUriMethod "newWithBase" o = UriNewWithBaseMethodInfo
+    ResolveUriMethod "normalize" o = UriNormalizeMethodInfo
+    ResolveUriMethod "queryHasKey" o = UriQueryHasKeyMethodInfo
+    ResolveUriMethod "removeQueryKey" o = UriRemoveQueryKeyMethodInfo
+    ResolveUriMethod "toString" o = UriToStringMethodInfo
+    ResolveUriMethod "getFragment" o = UriGetFragmentMethodInfo
+    ResolveUriMethod "getHost" o = UriGetHostMethodInfo
+    ResolveUriMethod "getPath" o = UriGetPathMethodInfo
+    ResolveUriMethod "getPathSegments" o = UriGetPathSegmentsMethodInfo
+    ResolveUriMethod "getPathString" o = UriGetPathStringMethodInfo
+    ResolveUriMethod "getPort" o = UriGetPortMethodInfo
+    ResolveUriMethod "getQueryKeys" o = UriGetQueryKeysMethodInfo
+    ResolveUriMethod "getQueryString" o = UriGetQueryStringMethodInfo
+    ResolveUriMethod "getQueryTable" o = UriGetQueryTableMethodInfo
+    ResolveUriMethod "getQueryValue" o = UriGetQueryValueMethodInfo
+    ResolveUriMethod "getScheme" o = UriGetSchemeMethodInfo
+    ResolveUriMethod "getUserinfo" o = UriGetUserinfoMethodInfo
+    ResolveUriMethod "setFragment" o = UriSetFragmentMethodInfo
+    ResolveUriMethod "setHost" o = UriSetHostMethodInfo
+    ResolveUriMethod "setPath" o = UriSetPathMethodInfo
+    ResolveUriMethod "setPathSegments" o = UriSetPathSegmentsMethodInfo
+    ResolveUriMethod "setPathString" o = UriSetPathStringMethodInfo
+    ResolveUriMethod "setPort" o = UriSetPortMethodInfo
+    ResolveUriMethod "setQueryString" o = UriSetQueryStringMethodInfo
+    ResolveUriMethod "setQueryTable" o = UriSetQueryTableMethodInfo
+    ResolveUriMethod "setQueryValue" o = UriSetQueryValueMethodInfo
+    ResolveUriMethod "setScheme" o = UriSetSchemeMethodInfo
+    ResolveUriMethod "setUserinfo" o = UriSetUserinfoMethodInfo
+    ResolveUriMethod l o = MethodResolutionFailed l o
+
+instance (info ~ ResolveUriMethod t Uri, MethodInfo info Uri p) => IsLabelProxy t (Uri -> p) where
+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)
+
+#if MIN_VERSION_base(4,9,0)
+instance (info ~ ResolveUriMethod t Uri, MethodInfo info Uri p) => IsLabel t (Uri -> p) where
+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)
+#endif
+
+
diff --git a/GI/Gst/Structs/Uri.hs-boot b/GI/Gst/Structs/Uri.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/Uri.hs-boot
@@ -0,0 +1,47 @@
+module GI.Gst.Structs.Uri where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+newtype Uri = Uri (ForeignPtr Uri)
+instance BoxedObject Uri where
+data UriAppendPathMethodInfo
+data UriAppendPathSegmentMethodInfo
+data UriEqualMethodInfo
+data UriFromStringWithBaseMethodInfo
+data UriGetFragmentMethodInfo
+data UriGetHostMethodInfo
+data UriGetPathMethodInfo
+data UriGetPathSegmentsMethodInfo
+data UriGetPathStringMethodInfo
+data UriGetPortMethodInfo
+data UriGetQueryKeysMethodInfo
+data UriGetQueryStringMethodInfo
+data UriGetQueryTableMethodInfo
+data UriGetQueryValueMethodInfo
+data UriGetSchemeMethodInfo
+data UriGetUserinfoMethodInfo
+data UriIsNormalizedMethodInfo
+data UriIsWritableMethodInfo
+data UriJoinMethodInfo
+data UriMakeWritableMethodInfo
+data UriNewWithBaseMethodInfo
+data UriNormalizeMethodInfo
+data UriQueryHasKeyMethodInfo
+data UriRemoveQueryKeyMethodInfo
+data UriSetFragmentMethodInfo
+data UriSetHostMethodInfo
+data UriSetPathMethodInfo
+data UriSetPathSegmentsMethodInfo
+data UriSetPathStringMethodInfo
+data UriSetPortMethodInfo
+data UriSetQueryStringMethodInfo
+data UriSetQueryTableMethodInfo
+data UriSetQueryValueMethodInfo
+data UriSetSchemeMethodInfo
+data UriSetUserinfoMethodInfo
+data UriToStringMethodInfo
diff --git a/GI/Gst/Structs/ValueTable.hs b/GI/Gst/Structs/ValueTable.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/ValueTable.hs
@@ -0,0 +1,70 @@
+
+
+{- |
+Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
+License    : LGPL-2.1
+Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
+
+VTable for the #GValue @type.
+-}
+
+module GI.Gst.Structs.ValueTable
+    ( 
+
+-- * Exported types
+    ValueTable(..)                          ,
+    newZeroValueTable                       ,
+    noValueTable                            ,
+
+
+ -- * Properties
+-- ** Type
+    valueTableReadType                      ,
+
+
+
+
+    ) where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+import GI.Gst.Types
+import GI.Gst.Callbacks
+
+newtype ValueTable = ValueTable (ForeignPtr ValueTable)
+-- | Construct a `ValueTable` struct initialized to zero.
+newZeroValueTable :: MonadIO m => m ValueTable
+newZeroValueTable = liftIO $ callocBytes 64 >>= wrapPtr ValueTable
+
+noValueTable :: Maybe ValueTable
+noValueTable = Nothing
+
+valueTableReadType :: ValueTable -> IO GType
+valueTableReadType s = withManagedPtr s $ \ptr -> do
+    val <- peek (ptr `plusPtr` 0) :: IO CGType
+    let val' = GType val
+    return val'
+
+-- XXX Skipped getter for "ValueTable:compare" :: Not implemented: "Wrapping foreign callbacks is not supported yet"
+
+-- XXX Skipped getter for "ValueTable:serialize" :: Not implemented: "Wrapping foreign callbacks is not supported yet"
+
+-- XXX Skipped getter for "ValueTable:deserialize" :: Not implemented: "Wrapping foreign callbacks is not supported yet"
+
+type family ResolveValueTableMethod (t :: Symbol) (o :: *) :: * where
+    ResolveValueTableMethod l o = MethodResolutionFailed l o
+
+instance (info ~ ResolveValueTableMethod t ValueTable, MethodInfo info ValueTable p) => IsLabelProxy t (ValueTable -> p) where
+    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)
+
+#if MIN_VERSION_base(4,9,0)
+instance (info ~ ResolveValueTableMethod t ValueTable, MethodInfo info ValueTable p) => IsLabel t (ValueTable -> p) where
+    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)
+#endif
+
+
diff --git a/GI/Gst/Structs/ValueTable.hs-boot b/GI/Gst/Structs/ValueTable.hs-boot
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Structs/ValueTable.hs-boot
@@ -0,0 +1,10 @@
+module GI.Gst.Structs.ValueTable where
+
+import Prelude ()
+import Data.GI.Base.ShortPrelude
+
+import qualified Data.Text as T
+import qualified Data.ByteString.Char8 as B
+import qualified Data.Map as Map
+
+newtype ValueTable = ValueTable (ForeignPtr ValueTable)
diff --git a/GI/Gst/Types.hs b/GI/Gst/Types.hs
new file mode 100644
--- /dev/null
+++ b/GI/Gst/Types.hs
@@ -0,0 +1,160 @@
+module GI.Gst.Types
+    (     module GI.Gst.Interfaces.ChildProxy     ,
+    module GI.Gst.Interfaces.Preset         ,
+    module GI.Gst.Interfaces.TagSetter      ,
+    module GI.Gst.Interfaces.TocSetter      ,
+    module GI.Gst.Interfaces.URIHandler     ,
+    module GI.Gst.Objects.Allocator         ,
+    module GI.Gst.Objects.Bin               ,
+    module GI.Gst.Objects.BufferPool        ,
+    module GI.Gst.Objects.Bus               ,
+    module GI.Gst.Objects.Clock             ,
+    module GI.Gst.Objects.ControlBinding    ,
+    module GI.Gst.Objects.ControlSource     ,
+    module GI.Gst.Objects.Device            ,
+    module GI.Gst.Objects.DeviceMonitor     ,
+    module GI.Gst.Objects.DeviceProvider    ,
+    module GI.Gst.Objects.DeviceProviderFactory,
+    module GI.Gst.Objects.Element           ,
+    module GI.Gst.Objects.ElementFactory    ,
+    module GI.Gst.Objects.GhostPad          ,
+    module GI.Gst.Objects.Object            ,
+    module GI.Gst.Objects.Pad               ,
+    module GI.Gst.Objects.PadTemplate       ,
+    module GI.Gst.Objects.Pipeline          ,
+    module GI.Gst.Objects.Plugin            ,
+    module GI.Gst.Objects.PluginFeature     ,
+    module GI.Gst.Objects.ProxyPad          ,
+    module GI.Gst.Objects.Registry          ,
+    module GI.Gst.Objects.SystemClock       ,
+    module GI.Gst.Objects.Task              ,
+    module GI.Gst.Objects.TaskPool          ,
+    module GI.Gst.Objects.TypeFindFactory   ,
+    module GI.Gst.Structs.AllocationParams  ,
+    module GI.Gst.Structs.AtomicQueue       ,
+    module GI.Gst.Structs.Buffer            ,
+    module GI.Gst.Structs.BufferList        ,
+    module GI.Gst.Structs.BufferPoolAcquireParams,
+    module GI.Gst.Structs.Caps              ,
+    module GI.Gst.Structs.CapsFeatures      ,
+    module GI.Gst.Structs.ClockEntry        ,
+    module GI.Gst.Structs.Context           ,
+    module GI.Gst.Structs.DateTime          ,
+    module GI.Gst.Structs.DebugCategory     ,
+    module GI.Gst.Structs.DebugMessage      ,
+    module GI.Gst.Structs.Event             ,
+    module GI.Gst.Structs.FormatDefinition  ,
+    module GI.Gst.Structs.Iterator          ,
+    module GI.Gst.Structs.MapInfo           ,
+    module GI.Gst.Structs.Memory            ,
+    module GI.Gst.Structs.Message           ,
+    module GI.Gst.Structs.Meta              ,
+    module GI.Gst.Structs.MetaInfo          ,
+    module GI.Gst.Structs.MetaTransformCopy ,
+    module GI.Gst.Structs.MiniObject        ,
+    module GI.Gst.Structs.PadProbeInfo      ,
+    module GI.Gst.Structs.ParamSpecFraction ,
+    module GI.Gst.Structs.ParentBufferMeta  ,
+    module GI.Gst.Structs.ParseContext      ,
+    module GI.Gst.Structs.PluginDesc        ,
+    module GI.Gst.Structs.Poll              ,
+    module GI.Gst.Structs.PollFD            ,
+    module GI.Gst.Structs.ProtectionMeta    ,
+    module GI.Gst.Structs.Query             ,
+    module GI.Gst.Structs.Sample            ,
+    module GI.Gst.Structs.Segment           ,
+    module GI.Gst.Structs.StaticCaps        ,
+    module GI.Gst.Structs.StaticPadTemplate ,
+    module GI.Gst.Structs.Structure         ,
+    module GI.Gst.Structs.TagList           ,
+    module GI.Gst.Structs.TimedValue        ,
+    module GI.Gst.Structs.Toc               ,
+    module GI.Gst.Structs.TocEntry          ,
+    module GI.Gst.Structs.TypeFind          ,
+    module GI.Gst.Structs.Uri               ,
+    module GI.Gst.Structs.ValueTable        ,
+    module GI.Gst.Enums                     ,
+    module GI.Gst.Flags                     ,
+
+
+    ) where
+
+
+import {-# SOURCE #-} GI.Gst.Interfaces.ChildProxy
+import {-# SOURCE #-} GI.Gst.Interfaces.Preset
+import {-# SOURCE #-} GI.Gst.Interfaces.TagSetter
+import {-# SOURCE #-} GI.Gst.Interfaces.TocSetter
+import {-# SOURCE #-} GI.Gst.Interfaces.URIHandler
+import {-# SOURCE #-} GI.Gst.Objects.Allocator
+import {-# SOURCE #-} GI.Gst.Objects.Bin
+import {-# SOURCE #-} GI.Gst.Objects.BufferPool
+import {-# SOURCE #-} GI.Gst.Objects.Bus
+import {-# SOURCE #-} GI.Gst.Objects.Clock
+import {-# SOURCE #-} GI.Gst.Objects.ControlBinding
+import {-# SOURCE #-} GI.Gst.Objects.ControlSource
+import {-# SOURCE #-} GI.Gst.Objects.Device
+import {-# SOURCE #-} GI.Gst.Objects.DeviceMonitor
+import {-# SOURCE #-} GI.Gst.Objects.DeviceProvider
+import {-# SOURCE #-} GI.Gst.Objects.DeviceProviderFactory
+import {-# SOURCE #-} GI.Gst.Objects.Element
+import {-# SOURCE #-} GI.Gst.Objects.ElementFactory
+import {-# SOURCE #-} GI.Gst.Objects.GhostPad
+import {-# SOURCE #-} GI.Gst.Objects.Object
+import {-# SOURCE #-} GI.Gst.Objects.Pad
+import {-# SOURCE #-} GI.Gst.Objects.PadTemplate
+import {-# SOURCE #-} GI.Gst.Objects.Pipeline
+import {-# SOURCE #-} GI.Gst.Objects.Plugin
+import {-# SOURCE #-} GI.Gst.Objects.PluginFeature
+import {-# SOURCE #-} GI.Gst.Objects.ProxyPad
+import {-# SOURCE #-} GI.Gst.Objects.Registry
+import {-# SOURCE #-} GI.Gst.Objects.SystemClock
+import {-# SOURCE #-} GI.Gst.Objects.Task
+import {-# SOURCE #-} GI.Gst.Objects.TaskPool
+import {-# SOURCE #-} GI.Gst.Objects.TypeFindFactory
+import {-# SOURCE #-} GI.Gst.Structs.AllocationParams
+import {-# SOURCE #-} GI.Gst.Structs.AtomicQueue
+import {-# SOURCE #-} GI.Gst.Structs.Buffer
+import {-# SOURCE #-} GI.Gst.Structs.BufferList
+import {-# SOURCE #-} GI.Gst.Structs.BufferPoolAcquireParams
+import {-# SOURCE #-} GI.Gst.Structs.Caps
+import {-# SOURCE #-} GI.Gst.Structs.CapsFeatures
+import {-# SOURCE #-} GI.Gst.Structs.ClockEntry
+import {-# SOURCE #-} GI.Gst.Structs.Context
+import {-# SOURCE #-} GI.Gst.Structs.DateTime
+import {-# SOURCE #-} GI.Gst.Structs.DebugCategory
+import {-# SOURCE #-} GI.Gst.Structs.DebugMessage
+import {-# SOURCE #-} GI.Gst.Structs.Event
+import {-# SOURCE #-} GI.Gst.Structs.FormatDefinition
+import {-# SOURCE #-} GI.Gst.Structs.Iterator
+import {-# SOURCE #-} GI.Gst.Structs.MapInfo
+import {-# SOURCE #-} GI.Gst.Structs.Memory
+import {-# SOURCE #-} GI.Gst.Structs.Message
+import {-# SOURCE #-} GI.Gst.Structs.Meta
+import {-# SOURCE #-} GI.Gst.Structs.MetaInfo
+import {-# SOURCE #-} GI.Gst.Structs.MetaTransformCopy
+import {-# SOURCE #-} GI.Gst.Structs.MiniObject
+import {-# SOURCE #-} GI.Gst.Structs.PadProbeInfo
+import {-# SOURCE #-} GI.Gst.Structs.ParamSpecFraction
+import {-# SOURCE #-} GI.Gst.Structs.ParentBufferMeta
+import {-# SOURCE #-} GI.Gst.Structs.ParseContext
+import {-# SOURCE #-} GI.Gst.Structs.PluginDesc
+import {-# SOURCE #-} GI.Gst.Structs.Poll
+import {-# SOURCE #-} GI.Gst.Structs.PollFD
+import {-# SOURCE #-} GI.Gst.Structs.ProtectionMeta
+import {-# SOURCE #-} GI.Gst.Structs.Query
+import {-# SOURCE #-} GI.Gst.Structs.Sample
+import {-# SOURCE #-} GI.Gst.Structs.Segment
+import {-# SOURCE #-} GI.Gst.Structs.StaticCaps
+import {-# SOURCE #-} GI.Gst.Structs.StaticPadTemplate
+import {-# SOURCE #-} GI.Gst.Structs.Structure
+import {-# SOURCE #-} GI.Gst.Structs.TagList
+import {-# SOURCE #-} GI.Gst.Structs.TimedValue
+import {-# SOURCE #-} GI.Gst.Structs.Toc
+import {-# SOURCE #-} GI.Gst.Structs.TocEntry
+import {-# SOURCE #-} GI.Gst.Structs.TypeFind
+import {-# SOURCE #-} GI.Gst.Structs.Uri
+import {-# SOURCE #-} GI.Gst.Structs.ValueTable
+
+import GI.Gst.Enums
+import GI.Gst.Flags
+
diff --git a/LICENSE b/LICENSE
new file mode 100644
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,456 @@
+                  GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 2.1, February 1999
+
+ Copyright (C) 1991, 1999 Free Software Foundation, Inc.
+ 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+[This is the first released version of the Lesser GPL.  It also counts
+ as the successor of the GNU Library Public License, version 2, hence
+ the version number 2.1.]
+
+                            Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+  This license, the Lesser General Public License, applies to some
+specially designated software packages--typically libraries--of the
+Free Software Foundation and other authors who decide to use it.  You
+can use it too, but we suggest you first think carefully about whether
+this license or the ordinary General Public License is the better
+strategy to use in any particular case, based on the explanations below.
+
+  When we speak of free software, we are referring to freedom of use,
+not price.  Our General Public Licenses are designed to make sure that
+you have the freedom to distribute copies of free software (and charge
+for this service if you wish); that you receive source code or can get
+it if you want it; that you can change the software and use pieces of
+it in new free programs; and that you are informed that you can do
+these things.
+
+  To protect your rights, we need to make restrictions that forbid
+distributors to deny you these rights or to ask you to surrender these
+rights.  These restrictions translate to certain responsibilities for
+you if you distribute copies of the library or if you modify it.
+
+  For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you.  You must make sure that they, too, receive or can get the source
+code.  If you link other code with the library, you must provide
+complete object files to the recipients, so that they can relink them
+with the library after making changes to the library and recompiling
+it.  And you must show them these terms so they know their rights.
+
+  We protect your rights with a two-step method: (1) we copyright the
+library, and (2) we offer you this license, which gives you legal
+permission to copy, distribute and/or modify the library.
+
+  To protect each distributor, we want to make it very clear that
+there is no warranty for the free library.  Also, if the library is
+modified by someone else and passed on, the recipients should know
+that what they have is not the original version, so that the original
+author's reputation will not be affected by problems that might be
+introduced by others.
+
+  Finally, software patents pose a constant threat to the existence of
+any free program.  We wish to make sure that a company cannot
+effectively restrict the users of a free program by obtaining a
+restrictive license from a patent holder.  Therefore, we insist that
+any patent license obtained for a version of the library must be
+consistent with the full freedom of use specified in this license.
+
+  Most GNU software, including some libraries, is covered by the
+ordinary GNU General Public License.  This license, the GNU Lesser
+General Public License, applies to certain designated libraries, and
+is quite different from the ordinary General Public License.  We use
+this license for certain libraries in order to permit linking those
+libraries into non-free programs.
+
+  When a program is linked with a library, whether statically or using
+a shared library, the combination of the two is legally speaking a
+combined work, a derivative of the original library.  The ordinary
+General Public License therefore permits such linking only if the
+entire combination fits its criteria of freedom.  The Lesser General
+Public License permits more lax criteria for linking other code with
+the library.
+
+  We call this license the "Lesser" General Public License because it
+does Less to protect the user's freedom than the ordinary General
+Public License.  It also provides other free software developers Less
+of an advantage over competing non-free programs.  These disadvantages
+are the reason we use the ordinary General Public License for many
+libraries.  However, the Lesser license provides advantages in certain
+special circumstances.
+
+  For example, on rare occasions, there may be a special need to
+encourage the widest possible use of a certain library, so that it becomes
+a de-facto standard.  To achieve this, non-free programs must be
+allowed to use the library.  A more frequent case is that a free
+library does the same job as widely used non-free libraries.  In this
+case, there is little to gain by limiting the free library to free
+software only, so we use the Lesser General Public License.
+
+  In other cases, permission to use a particular library in non-free
+programs enables a greater number of people to use a large body of
+free software.  For example, permission to use the GNU C Library in
+non-free programs enables many more people to use the whole GNU
+operating system, as well as its variant, the GNU/Linux operating
+system.
+
+  Although the Lesser General Public License is Less protective of the
+users' freedom, it does ensure that the user of a program that is
+linked with the Library has the freedom and the wherewithal to run
+that program using a modified version of the Library.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.  Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library".  The
+former contains code derived from the library, whereas the latter must
+be combined with the library in order to run.
+
+                  GNU LESSER GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License Agreement applies to any software library or other
+program which contains a notice placed by the copyright holder or
+other authorized party saying it may be distributed under the terms of
+this Lesser General Public License (also called "this License").
+Each licensee is addressed as "you".
+
+  A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+  The "Library", below, refers to any such software library or work
+which has been distributed under these terms.  A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language.  (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+  "Source code" for a work means the preferred form of the work for
+making modifications to it.  For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control compilation
+and installation of the library.
+
+  Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it).  Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+
+  1. You may copy and distribute verbatim copies of the Library's
+complete source code as you receive it, in any medium, provided that
+you conspicuously and appropriately publish on each copy an
+appropriate copyright notice and disclaimer of warranty; keep intact
+all the notices that refer to this License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+
+  You may charge a fee for the physical act of transferring a copy,
+and you may at your option offer warranty protection in exchange for a
+fee.
+
+  2. You may modify your copy or copies of the Library or any portion
+of it, thus forming a work based on the Library, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) The modified work must itself be a software library.
+
+    b) You must cause the files modified to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    c) You must cause the whole of the work to be licensed at no
+    charge to all third parties under the terms of this License.
+
+    d) If a facility in the modified Library refers to a function or a
+    table of data to be supplied by an application program that uses
+    the facility, other than as an argument passed when the facility
+    is invoked, then you must make a good faith effort to ensure that,
+    in the event an application does not supply such function or
+    table, the facility still operates, and performs whatever part of
+    its purpose remains meaningful.
+
+    (For example, a function in a library to compute square roots has
+    a purpose that is entirely well-defined independent of the
+    application.  Therefore, Subsection 2d requires that any
+    application-supplied function or table used by this function must
+    be optional: if the application does not supply it, the square
+    root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Library,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Library, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote
+it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library.  To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License.  (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.)  Do not make any other change in
+these notices.
+
+  Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+  This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+  4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you accompany
+it with the complete corresponding machine-readable source code, which
+must be distributed under the terms of Sections 1 and 2 above on a
+medium customarily used for software interchange.
+
+  If distribution of object code is made by offering access to copy
+from a designated place, then offering equivalent access to copy the
+source code from the same place satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library".  Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+  However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library".  The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+  When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library.  The
+threshold for this to be true is not precisely defined by law.
+
+  If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work.  (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+  Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+
+  6. As an exception to the Sections above, you may also combine or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+  You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License.  You must supply a copy of this License.  If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License.  Also, you must do one
+of these things:
+
+    a) Accompany the work with the complete corresponding
+    machine-readable source code for the Library including whatever
+    changes were used in the work (which must be distributed under
+    Sections 1 and 2 above); and, if the work is an executable linked
+    with the Library, with the complete machine-readable "work that
+    uses the Library", as object code and/or source code, so that the
+    user can modify the Library and then relink to produce a modified
+    executable containing the modified Library.  (It is understood
+    that the user who changes the contents of definitions files in the
+    Library will not necessarily be able to recompile the application
+    to use the modified definitions.)
+
+    b) Use a suitable shared library mechanism for linking with the
+    Library.  A suitable mechanism is one that (1) uses at run time a
+    copy of the library already present on the user's computer system,
+    rather than copying library functions into the executable, and (2)
+    will operate properly with a modified version of the library, if
+    the user installs one, as long as the modified version is
+    interface-compatible with the version that the work was made with.
+
+    c) Accompany the work with a written offer, valid for at
+    least three years, to give the same user the materials
+    specified in Subsection 6a, above, for a charge no more
+    than the cost of performing this distribution.
+
+    d) If distribution of the work is made by offering access to copy
+    from a designated place, offer equivalent access to copy the above
+    specified materials from the same place.
+
+    e) Verify that the user has already received a copy of these
+    materials or that you have already sent this user a copy.
+
+  For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it.  However, as a special exception,
+the materials to be distributed need not include anything that is
+normally distributed (in either source or binary form) with the major
+components (compiler, kernel, and so on) of the operating system on
+which the executable runs, unless that component itself accompanies
+the executable.
+
+  It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system.  Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+
+  7. You may place library facilities that are a work based on the
+Library side-by-side in a single library together with other library
+facilities not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+    a) Accompany the combined library with a copy of the same work
+    based on the Library, uncombined with any other library
+    facilities.  This must be distributed under the terms of the
+    Sections above.
+
+    b) Give prominent notice with the combined library of the fact
+    that part of it is a work based on the Library, and explaining
+    where to find the accompanying uncombined form of the same work.
+
+  8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License.  Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library is void, and will automatically terminate your
+rights under this License.  However, parties who have received copies,
+or rights, from you under this License will not have their licenses
+terminated so long as such parties remain in full compliance.
+
+  9. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Library or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+  10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+subject to these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties with
+this License.
+
+  11. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Library at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Library by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under any
+particular circumstance, the balance of the section is intended to apply,
+and the section as a whole is intended to apply in other circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library under this License may add
+an explicit geographical distribution limitation excluding those countries,
+so that distribution is permitted only in or among countries not thus
+excluded.  In such case, this License incorporates the limitation as if
+written in the body of this License.
+
+  13. The Free Software Foundation may publish revised and/or new
+versions of the Lesser General Public License from time to time.
+Such new versions will be similar in spirit to the present version,
+but may differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Library
+specifies a version number of this License which applies to it and
+"any later version", you have the option of following the terms and
+conditions either of that version or of any later version published by
+the Free Software Foundation.  If the Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+
+  14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+write to the author to ask for permission.  For software which is
+copyrighted by the Free Software Foundation, write to the Free
+Software Foundation; we sometimes make exceptions for this.  Our
+decision will be guided by the two goals of preserving the free status
+of all derivatives of our free software and of promoting the sharing
+and reuse of software generally.
+
+                            NO WARRANTY
+
+  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
+LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
diff --git a/Setup.hs b/Setup.hs
new file mode 100644
--- /dev/null
+++ b/Setup.hs
@@ -0,0 +1,3 @@
+#!/usr/bin/env runhaskell
+import Distribution.Simple
+main = defaultMain
diff --git a/gi-gst.cabal b/gi-gst.cabal
new file mode 100644
--- /dev/null
+++ b/gi-gst.cabal
@@ -0,0 +1,112 @@
+-- Autogenerated, do not edit.
+name:               gi-gst
+version:            0.1.6.13
+synopsis:           Gst bindings
+description:        Bindings for Gst, autogenerated by haskell-gi.
+homepage:           https://github.com/haskell-gi/haskell-gi
+license:            LGPL-2.1
+license-file:       LICENSE
+author:             Will Thompson, Iñaki García Etxebarria and Jonas Platte
+maintainer:         Iñaki García Etxebarria (garetxe@gmail.com)
+category:           Bindings
+build-type:         Simple
+cabal-version:      >=1.10
+
+library
+    default-language:   Haskell2010
+    default-extensions: ScopedTypeVariables, CPP, OverloadedStrings, NegativeLiterals, ConstraintKinds, TypeFamilies, MultiParamTypeClasses, KindSignatures, FlexibleInstances, UndecidableInstances, DataKinds, FlexibleContexts
+    other-extensions:   PatternSynonyms ViewPatterns
+    ghc-options:        -fno-warn-unused-imports -fno-warn-warnings-deprecations
+    exposed-modules:    GI.Gst.Types
+                        GI.Gst
+                        GI.Gst.Callbacks
+                        GI.Gst.Constants
+                        GI.Gst.Enums
+                        GI.Gst.Flags
+                        GI.Gst.Functions
+                        GI.Gst.Interfaces
+                        GI.Gst.Interfaces.ChildProxy
+                        GI.Gst.Interfaces.Preset
+                        GI.Gst.Interfaces.TagSetter
+                        GI.Gst.Interfaces.TocSetter
+                        GI.Gst.Interfaces.URIHandler
+                        GI.Gst.Objects
+                        GI.Gst.Objects.Allocator
+                        GI.Gst.Objects.Bin
+                        GI.Gst.Objects.BufferPool
+                        GI.Gst.Objects.Bus
+                        GI.Gst.Objects.Clock
+                        GI.Gst.Objects.ControlBinding
+                        GI.Gst.Objects.ControlSource
+                        GI.Gst.Objects.Device
+                        GI.Gst.Objects.DeviceMonitor
+                        GI.Gst.Objects.DeviceProvider
+                        GI.Gst.Objects.DeviceProviderFactory
+                        GI.Gst.Objects.Element
+                        GI.Gst.Objects.ElementFactory
+                        GI.Gst.Objects.GhostPad
+                        GI.Gst.Objects.Object
+                        GI.Gst.Objects.Pad
+                        GI.Gst.Objects.PadTemplate
+                        GI.Gst.Objects.Pipeline
+                        GI.Gst.Objects.Plugin
+                        GI.Gst.Objects.PluginFeature
+                        GI.Gst.Objects.ProxyPad
+                        GI.Gst.Objects.Registry
+                        GI.Gst.Objects.SystemClock
+                        GI.Gst.Objects.Task
+                        GI.Gst.Objects.TaskPool
+                        GI.Gst.Objects.TypeFindFactory
+                        GI.Gst.Structs
+                        GI.Gst.Structs.AllocationParams
+                        GI.Gst.Structs.AtomicQueue
+                        GI.Gst.Structs.Buffer
+                        GI.Gst.Structs.BufferList
+                        GI.Gst.Structs.BufferPoolAcquireParams
+                        GI.Gst.Structs.Caps
+                        GI.Gst.Structs.CapsFeatures
+                        GI.Gst.Structs.ClockEntry
+                        GI.Gst.Structs.Context
+                        GI.Gst.Structs.DateTime
+                        GI.Gst.Structs.DebugCategory
+                        GI.Gst.Structs.DebugMessage
+                        GI.Gst.Structs.Event
+                        GI.Gst.Structs.FormatDefinition
+                        GI.Gst.Structs.Iterator
+                        GI.Gst.Structs.MapInfo
+                        GI.Gst.Structs.Memory
+                        GI.Gst.Structs.Message
+                        GI.Gst.Structs.Meta
+                        GI.Gst.Structs.MetaInfo
+                        GI.Gst.Structs.MetaTransformCopy
+                        GI.Gst.Structs.MiniObject
+                        GI.Gst.Structs.PadProbeInfo
+                        GI.Gst.Structs.ParamSpecFraction
+                        GI.Gst.Structs.ParentBufferMeta
+                        GI.Gst.Structs.ParseContext
+                        GI.Gst.Structs.PluginDesc
+                        GI.Gst.Structs.Poll
+                        GI.Gst.Structs.PollFD
+                        GI.Gst.Structs.ProtectionMeta
+                        GI.Gst.Structs.Query
+                        GI.Gst.Structs.Sample
+                        GI.Gst.Structs.Segment
+                        GI.Gst.Structs.StaticCaps
+                        GI.Gst.Structs.StaticPadTemplate
+                        GI.Gst.Structs.Structure
+                        GI.Gst.Structs.TagList
+                        GI.Gst.Structs.TimedValue
+                        GI.Gst.Structs.Toc
+                        GI.Gst.Structs.TocEntry
+                        GI.Gst.Structs.TypeFind
+                        GI.Gst.Structs.Uri
+                        GI.Gst.Structs.ValueTable
+    pkgconfig-depends:  gstreamer-1.0 >= 1.6
+    build-depends: base >= 4.8 && <5,
+        haskell-gi-base >= 0.13 && < 1,
+        gi-glib >= 0.2.46.13 && < 0.2.47,
+        gi-gobject >= 0.2.46.13 && < 0.2.47,
+        bytestring >= 0.10,
+        containers >= 0.5,
+        text >= 1.0,
+        transformers >= 0.3