{- |
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 containing the information of a URI analyzed by 'GI.GstPbutils.Objects.Discoverer.Discoverer'.
-}

module GI.GstPbutils.Objects.DiscovererInfo
    ( 

-- * Exported types
    DiscovererInfo(..)                      ,
    IsDiscovererInfo                        ,
    toDiscovererInfo                        ,
    noDiscovererInfo                        ,


 -- * Methods
-- ** copy #method:copy#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DiscovererInfoCopyMethodInfo            ,
#endif
    discovererInfoCopy                      ,


-- ** fromVariant #method:fromVariant#
    discovererInfoFromVariant               ,


-- ** getAudioStreams #method:getAudioStreams#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DiscovererInfoGetAudioStreamsMethodInfo ,
#endif
    discovererInfoGetAudioStreams           ,


-- ** getContainerStreams #method:getContainerStreams#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DiscovererInfoGetContainerStreamsMethodInfo,
#endif
    discovererInfoGetContainerStreams       ,


-- ** getDuration #method:getDuration#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DiscovererInfoGetDurationMethodInfo     ,
#endif
    discovererInfoGetDuration               ,


-- ** getMisc #method:getMisc#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DiscovererInfoGetMiscMethodInfo         ,
#endif
    discovererInfoGetMisc                   ,


-- ** getMissingElementsInstallerDetails #method:getMissingElementsInstallerDetails#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DiscovererInfoGetMissingElementsInstallerDetailsMethodInfo,
#endif
    discovererInfoGetMissingElementsInstallerDetails,


-- ** getResult #method:getResult#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DiscovererInfoGetResultMethodInfo       ,
#endif
    discovererInfoGetResult                 ,


-- ** getSeekable #method:getSeekable#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DiscovererInfoGetSeekableMethodInfo     ,
#endif
    discovererInfoGetSeekable               ,


-- ** getStreamInfo #method:getStreamInfo#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DiscovererInfoGetStreamInfoMethodInfo   ,
#endif
    discovererInfoGetStreamInfo             ,


-- ** getStreamList #method:getStreamList#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DiscovererInfoGetStreamListMethodInfo   ,
#endif
    discovererInfoGetStreamList             ,


-- ** getStreams #method:getStreams#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DiscovererInfoGetStreamsMethodInfo      ,
#endif
    discovererInfoGetStreams                ,


-- ** getSubtitleStreams #method:getSubtitleStreams#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DiscovererInfoGetSubtitleStreamsMethodInfo,
#endif
    discovererInfoGetSubtitleStreams        ,


-- ** getTags #method:getTags#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DiscovererInfoGetTagsMethodInfo         ,
#endif
    discovererInfoGetTags                   ,


-- ** getToc #method:getToc#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DiscovererInfoGetTocMethodInfo          ,
#endif
    discovererInfoGetToc                    ,


-- ** getUri #method:getUri#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DiscovererInfoGetUriMethodInfo          ,
#endif
    discovererInfoGetUri                    ,


-- ** getVideoStreams #method:getVideoStreams#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DiscovererInfoGetVideoStreamsMethodInfo ,
#endif
    discovererInfoGetVideoStreams           ,


-- ** toVariant #method:toVariant#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DiscovererInfoToVariantMethodInfo       ,
#endif
    discovererInfoToVariant                 ,




    ) where

import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP

import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gst.Structs.Structure as Gst.Structure
import qualified GI.Gst.Structs.TagList as Gst.TagList
import qualified GI.Gst.Structs.Toc as Gst.Toc
import {-# SOURCE #-} qualified GI.GstPbutils.Enums as GstPbutils.Enums
import {-# SOURCE #-} qualified GI.GstPbutils.Flags as GstPbutils.Flags
import {-# SOURCE #-} qualified GI.GstPbutils.Objects.DiscovererStreamInfo as GstPbutils.DiscovererStreamInfo

newtype DiscovererInfo = DiscovererInfo (ManagedPtr DiscovererInfo)
foreign import ccall "gst_discoverer_info_get_type"
    c_gst_discoverer_info_get_type :: IO GType

instance GObject DiscovererInfo where
    gobjectType _ = c_gst_discoverer_info_get_type
    

class GObject o => IsDiscovererInfo o
#if MIN_VERSION_base(4,9,0)
instance {-# OVERLAPPABLE #-} (GObject a, O.UnknownAncestorError DiscovererInfo a) =>
    IsDiscovererInfo a
#endif
instance IsDiscovererInfo DiscovererInfo
instance GObject.Object.IsObject DiscovererInfo

toDiscovererInfo :: (MonadIO m, IsDiscovererInfo o) => o -> m DiscovererInfo
toDiscovererInfo = liftIO . unsafeCastTo DiscovererInfo

noDiscovererInfo :: Maybe DiscovererInfo
noDiscovererInfo = Nothing

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
type family ResolveDiscovererInfoMethod (t :: Symbol) (o :: *) :: * where
    ResolveDiscovererInfoMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveDiscovererInfoMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveDiscovererInfoMethod "copy" o = DiscovererInfoCopyMethodInfo
    ResolveDiscovererInfoMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveDiscovererInfoMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveDiscovererInfoMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveDiscovererInfoMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveDiscovererInfoMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveDiscovererInfoMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveDiscovererInfoMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveDiscovererInfoMethod "replaceData" o = GObject.Object.ObjectReplaceDataMethodInfo
    ResolveDiscovererInfoMethod "replaceQdata" o = GObject.Object.ObjectReplaceQdataMethodInfo
    ResolveDiscovererInfoMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveDiscovererInfoMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveDiscovererInfoMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveDiscovererInfoMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveDiscovererInfoMethod "toVariant" o = DiscovererInfoToVariantMethodInfo
    ResolveDiscovererInfoMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveDiscovererInfoMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveDiscovererInfoMethod "getAudioStreams" o = DiscovererInfoGetAudioStreamsMethodInfo
    ResolveDiscovererInfoMethod "getContainerStreams" o = DiscovererInfoGetContainerStreamsMethodInfo
    ResolveDiscovererInfoMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveDiscovererInfoMethod "getDuration" o = DiscovererInfoGetDurationMethodInfo
    ResolveDiscovererInfoMethod "getMisc" o = DiscovererInfoGetMiscMethodInfo
    ResolveDiscovererInfoMethod "getMissingElementsInstallerDetails" o = DiscovererInfoGetMissingElementsInstallerDetailsMethodInfo
    ResolveDiscovererInfoMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveDiscovererInfoMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveDiscovererInfoMethod "getResult" o = DiscovererInfoGetResultMethodInfo
    ResolveDiscovererInfoMethod "getSeekable" o = DiscovererInfoGetSeekableMethodInfo
    ResolveDiscovererInfoMethod "getStreamInfo" o = DiscovererInfoGetStreamInfoMethodInfo
    ResolveDiscovererInfoMethod "getStreamList" o = DiscovererInfoGetStreamListMethodInfo
    ResolveDiscovererInfoMethod "getStreams" o = DiscovererInfoGetStreamsMethodInfo
    ResolveDiscovererInfoMethod "getSubtitleStreams" o = DiscovererInfoGetSubtitleStreamsMethodInfo
    ResolveDiscovererInfoMethod "getTags" o = DiscovererInfoGetTagsMethodInfo
    ResolveDiscovererInfoMethod "getToc" o = DiscovererInfoGetTocMethodInfo
    ResolveDiscovererInfoMethod "getUri" o = DiscovererInfoGetUriMethodInfo
    ResolveDiscovererInfoMethod "getVideoStreams" o = DiscovererInfoGetVideoStreamsMethodInfo
    ResolveDiscovererInfoMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveDiscovererInfoMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveDiscovererInfoMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveDiscovererInfoMethod t DiscovererInfo, O.MethodInfo info DiscovererInfo p) => O.IsLabelProxy t (DiscovererInfo -> p) where
    fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

#if MIN_VERSION_base(4,9,0)
instance (info ~ ResolveDiscovererInfoMethod t DiscovererInfo, O.MethodInfo info DiscovererInfo p) => O.IsLabel t (DiscovererInfo -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#else
    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif
#endif

#endif

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
instance O.HasAttributeList DiscovererInfo
type instance O.AttributeList DiscovererInfo = DiscovererInfoAttributeList
type DiscovererInfoAttributeList = ('[ ] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
#endif

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
type instance O.SignalList DiscovererInfo = DiscovererInfoSignalList
type DiscovererInfoSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

#endif

-- method DiscovererInfo::copy
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "ptr", argType = TInterface (Name {namespace = "GstPbutils", name = "DiscovererInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstDiscovererInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "GstPbutils", name = "DiscovererInfo"}))
-- throws : False
-- Skip return : False

foreign import ccall "gst_discoverer_info_copy" gst_discoverer_info_copy :: 
    Ptr DiscovererInfo ->                   -- ptr : TInterface (Name {namespace = "GstPbutils", name = "DiscovererInfo"})
    IO (Ptr DiscovererInfo)

{- |
/No description available in the introspection data./
-}
discovererInfoCopy ::
    (B.CallStack.HasCallStack, MonadIO m, IsDiscovererInfo a) =>
    a
    {- ^ /@ptr@/: a 'GI.GstPbutils.Objects.DiscovererInfo.DiscovererInfo' -}
    -> m DiscovererInfo
    {- ^ __Returns:__ A copy of the 'GI.GstPbutils.Objects.DiscovererInfo.DiscovererInfo' -}
discovererInfoCopy ptr = liftIO $ do
    ptr' <- unsafeManagedPtrCastPtr ptr
    result <- gst_discoverer_info_copy ptr'
    checkUnexpectedReturnNULL "discovererInfoCopy" result
    result' <- (wrapObject DiscovererInfo) result
    touchManagedPtr ptr
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DiscovererInfoCopyMethodInfo
instance (signature ~ (m DiscovererInfo), MonadIO m, IsDiscovererInfo a) => O.MethodInfo DiscovererInfoCopyMethodInfo a signature where
    overloadedMethod _ = discovererInfoCopy

#endif

-- method DiscovererInfo::get_audio_streams
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GstPbutils", name = "DiscovererInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstDiscovererInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TGList (TInterface (Name {namespace = "GstPbutils", name = "DiscovererStreamInfo"})))
-- throws : False
-- Skip return : False

foreign import ccall "gst_discoverer_info_get_audio_streams" gst_discoverer_info_get_audio_streams :: 
    Ptr DiscovererInfo ->                   -- info : TInterface (Name {namespace = "GstPbutils", name = "DiscovererInfo"})
    IO (Ptr (GList (Ptr GstPbutils.DiscovererStreamInfo.DiscovererStreamInfo)))

{- |
Finds all the 'GI.GstPbutils.Objects.DiscovererAudioInfo.DiscovererAudioInfo' contained in /@info@/
-}
discovererInfoGetAudioStreams ::
    (B.CallStack.HasCallStack, MonadIO m, IsDiscovererInfo a) =>
    a
    {- ^ /@info@/: a 'GI.GstPbutils.Objects.DiscovererInfo.DiscovererInfo' -}
    -> m [GstPbutils.DiscovererStreamInfo.DiscovererStreamInfo]
    {- ^ __Returns:__ A 'GI.GLib.Structs.List.List' of
matching 'GI.GstPbutils.Objects.DiscovererStreamInfo.DiscovererStreamInfo'. The caller should free it with
'GI.GstPbutils.Objects.DiscovererStreamInfo.discovererStreamInfoListFree'. -}
discovererInfoGetAudioStreams info = liftIO $ do
    info' <- unsafeManagedPtrCastPtr info
    result <- gst_discoverer_info_get_audio_streams info'
    result' <- unpackGList result
    result'' <- mapM (wrapObject GstPbutils.DiscovererStreamInfo.DiscovererStreamInfo) result'
    g_list_free result
    touchManagedPtr info
    return result''

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DiscovererInfoGetAudioStreamsMethodInfo
instance (signature ~ (m [GstPbutils.DiscovererStreamInfo.DiscovererStreamInfo]), MonadIO m, IsDiscovererInfo a) => O.MethodInfo DiscovererInfoGetAudioStreamsMethodInfo a signature where
    overloadedMethod _ = discovererInfoGetAudioStreams

#endif

-- method DiscovererInfo::get_container_streams
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GstPbutils", name = "DiscovererInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstDiscovererInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TGList (TInterface (Name {namespace = "GstPbutils", name = "DiscovererStreamInfo"})))
-- throws : False
-- Skip return : False

foreign import ccall "gst_discoverer_info_get_container_streams" gst_discoverer_info_get_container_streams :: 
    Ptr DiscovererInfo ->                   -- info : TInterface (Name {namespace = "GstPbutils", name = "DiscovererInfo"})
    IO (Ptr (GList (Ptr GstPbutils.DiscovererStreamInfo.DiscovererStreamInfo)))

{- |
Finds all the 'GI.GstPbutils.Objects.DiscovererContainerInfo.DiscovererContainerInfo' contained in /@info@/
-}
discovererInfoGetContainerStreams ::
    (B.CallStack.HasCallStack, MonadIO m, IsDiscovererInfo a) =>
    a
    {- ^ /@info@/: a 'GI.GstPbutils.Objects.DiscovererInfo.DiscovererInfo' -}
    -> m [GstPbutils.DiscovererStreamInfo.DiscovererStreamInfo]
    {- ^ __Returns:__ A 'GI.GLib.Structs.List.List' of
matching 'GI.GstPbutils.Objects.DiscovererStreamInfo.DiscovererStreamInfo'. The caller should free it with
'GI.GstPbutils.Objects.DiscovererStreamInfo.discovererStreamInfoListFree'. -}
discovererInfoGetContainerStreams info = liftIO $ do
    info' <- unsafeManagedPtrCastPtr info
    result <- gst_discoverer_info_get_container_streams info'
    result' <- unpackGList result
    result'' <- mapM (wrapObject GstPbutils.DiscovererStreamInfo.DiscovererStreamInfo) result'
    g_list_free result
    touchManagedPtr info
    return result''

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DiscovererInfoGetContainerStreamsMethodInfo
instance (signature ~ (m [GstPbutils.DiscovererStreamInfo.DiscovererStreamInfo]), MonadIO m, IsDiscovererInfo a) => O.MethodInfo DiscovererInfoGetContainerStreamsMethodInfo a signature where
    overloadedMethod _ = discovererInfoGetContainerStreams

#endif

-- method DiscovererInfo::get_duration
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GstPbutils", name = "DiscovererInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstDiscovererInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUInt64)
-- throws : False
-- Skip return : False

foreign import ccall "gst_discoverer_info_get_duration" gst_discoverer_info_get_duration :: 
    Ptr DiscovererInfo ->                   -- info : TInterface (Name {namespace = "GstPbutils", name = "DiscovererInfo"})
    IO Word64

{- |
/No description available in the introspection data./
-}
discovererInfoGetDuration ::
    (B.CallStack.HasCallStack, MonadIO m, IsDiscovererInfo a) =>
    a
    {- ^ /@info@/: a 'GI.GstPbutils.Objects.DiscovererInfo.DiscovererInfo' -}
    -> m Word64
    {- ^ __Returns:__ the duration of the URI in @/GstClockTime/@ (nanoseconds). -}
discovererInfoGetDuration info = liftIO $ do
    info' <- unsafeManagedPtrCastPtr info
    result <- gst_discoverer_info_get_duration info'
    touchManagedPtr info
    return result

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DiscovererInfoGetDurationMethodInfo
instance (signature ~ (m Word64), MonadIO m, IsDiscovererInfo a) => O.MethodInfo DiscovererInfoGetDurationMethodInfo a signature where
    overloadedMethod _ = discovererInfoGetDuration

#endif

-- method DiscovererInfo::get_misc
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GstPbutils", name = "DiscovererInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstDiscovererInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gst", name = "Structure"}))
-- throws : False
-- Skip return : False

foreign import ccall "gst_discoverer_info_get_misc" gst_discoverer_info_get_misc :: 
    Ptr DiscovererInfo ->                   -- info : TInterface (Name {namespace = "GstPbutils", name = "DiscovererInfo"})
    IO (Ptr Gst.Structure.Structure)

{-# DEPRECATED discovererInfoGetMisc ["This functions is deprecated since version 1.4, use","@/gst_discoverer_info_get_missing_elements_installer_details/@"] #-}
{- |
/No description available in the introspection data./
-}
discovererInfoGetMisc ::
    (B.CallStack.HasCallStack, MonadIO m, IsDiscovererInfo a) =>
    a
    {- ^ /@info@/: a 'GI.GstPbutils.Objects.DiscovererInfo.DiscovererInfo' -}
    -> m Gst.Structure.Structure
    {- ^ __Returns:__ Miscellaneous information stored as a 'GI.Gst.Structs.Structure.Structure'
(for example: information about missing plugins). If you wish to use the
'GI.Gst.Structs.Structure.Structure' after the life-time of /@info@/, you will need to copy it. -}
discovererInfoGetMisc info = liftIO $ do
    info' <- unsafeManagedPtrCastPtr info
    result <- gst_discoverer_info_get_misc info'
    checkUnexpectedReturnNULL "discovererInfoGetMisc" result
    result' <- (newBoxed Gst.Structure.Structure) result
    touchManagedPtr info
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DiscovererInfoGetMiscMethodInfo
instance (signature ~ (m Gst.Structure.Structure), MonadIO m, IsDiscovererInfo a) => O.MethodInfo DiscovererInfoGetMiscMethodInfo a signature where
    overloadedMethod _ = discovererInfoGetMisc

#endif

-- method DiscovererInfo::get_missing_elements_installer_details
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GstPbutils", name = "DiscovererInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstDiscovererStreamInfo to retrieve installer detail\nfor the missing element", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TCArray True (-1) (-1) (TBasicType TUTF8))
-- throws : False
-- Skip return : False

foreign import ccall "gst_discoverer_info_get_missing_elements_installer_details" gst_discoverer_info_get_missing_elements_installer_details :: 
    Ptr DiscovererInfo ->                   -- info : TInterface (Name {namespace = "GstPbutils", name = "DiscovererInfo"})
    IO (Ptr CString)

{- |
Get the installer details for missing elements

@since 1.4
-}
discovererInfoGetMissingElementsInstallerDetails ::
    (B.CallStack.HasCallStack, MonadIO m, IsDiscovererInfo a) =>
    a
    {- ^ /@info@/: a 'GI.GstPbutils.Objects.DiscovererStreamInfo.DiscovererStreamInfo' to retrieve installer detail
for the missing element -}
    -> m [T.Text]
    {- ^ __Returns:__ An array of strings
containing informations about how to install the various missing elements
for /@info@/ to be usable. If you wish to use the strings after the life-time
of /@info@/, you will need to copy them. -}
discovererInfoGetMissingElementsInstallerDetails info = liftIO $ do
    info' <- unsafeManagedPtrCastPtr info
    result <- gst_discoverer_info_get_missing_elements_installer_details info'
    checkUnexpectedReturnNULL "discovererInfoGetMissingElementsInstallerDetails" result
    result' <- unpackZeroTerminatedUTF8CArray result
    touchManagedPtr info
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DiscovererInfoGetMissingElementsInstallerDetailsMethodInfo
instance (signature ~ (m [T.Text]), MonadIO m, IsDiscovererInfo a) => O.MethodInfo DiscovererInfoGetMissingElementsInstallerDetailsMethodInfo a signature where
    overloadedMethod _ = discovererInfoGetMissingElementsInstallerDetails

#endif

-- method DiscovererInfo::get_result
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GstPbutils", name = "DiscovererInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstDiscovererInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "GstPbutils", name = "DiscovererResult"}))
-- throws : False
-- Skip return : False

foreign import ccall "gst_discoverer_info_get_result" gst_discoverer_info_get_result :: 
    Ptr DiscovererInfo ->                   -- info : TInterface (Name {namespace = "GstPbutils", name = "DiscovererInfo"})
    IO CUInt

{- |
/No description available in the introspection data./
-}
discovererInfoGetResult ::
    (B.CallStack.HasCallStack, MonadIO m, IsDiscovererInfo a) =>
    a
    {- ^ /@info@/: a 'GI.GstPbutils.Objects.DiscovererInfo.DiscovererInfo' -}
    -> m GstPbutils.Enums.DiscovererResult
    {- ^ __Returns:__ the result of the discovery as a 'GI.GstPbutils.Enums.DiscovererResult'. -}
discovererInfoGetResult info = liftIO $ do
    info' <- unsafeManagedPtrCastPtr info
    result <- gst_discoverer_info_get_result info'
    let result' = (toEnum . fromIntegral) result
    touchManagedPtr info
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DiscovererInfoGetResultMethodInfo
instance (signature ~ (m GstPbutils.Enums.DiscovererResult), MonadIO m, IsDiscovererInfo a) => O.MethodInfo DiscovererInfoGetResultMethodInfo a signature where
    overloadedMethod _ = discovererInfoGetResult

#endif

-- method DiscovererInfo::get_seekable
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GstPbutils", name = "DiscovererInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstDiscovererInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gst_discoverer_info_get_seekable" gst_discoverer_info_get_seekable :: 
    Ptr DiscovererInfo ->                   -- info : TInterface (Name {namespace = "GstPbutils", name = "DiscovererInfo"})
    IO CInt

{- |
/No description available in the introspection data./
-}
discovererInfoGetSeekable ::
    (B.CallStack.HasCallStack, MonadIO m, IsDiscovererInfo a) =>
    a
    {- ^ /@info@/: a 'GI.GstPbutils.Objects.DiscovererInfo.DiscovererInfo' -}
    -> m Bool
    {- ^ __Returns:__ the whether the URI is seekable. -}
discovererInfoGetSeekable info = liftIO $ do
    info' <- unsafeManagedPtrCastPtr info
    result <- gst_discoverer_info_get_seekable info'
    let result' = (/= 0) result
    touchManagedPtr info
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DiscovererInfoGetSeekableMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsDiscovererInfo a) => O.MethodInfo DiscovererInfoGetSeekableMethodInfo a signature where
    overloadedMethod _ = discovererInfoGetSeekable

#endif

-- method DiscovererInfo::get_stream_info
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GstPbutils", name = "DiscovererInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstDiscovererInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "GstPbutils", name = "DiscovererStreamInfo"}))
-- throws : False
-- Skip return : False

foreign import ccall "gst_discoverer_info_get_stream_info" gst_discoverer_info_get_stream_info :: 
    Ptr DiscovererInfo ->                   -- info : TInterface (Name {namespace = "GstPbutils", name = "DiscovererInfo"})
    IO (Ptr GstPbutils.DiscovererStreamInfo.DiscovererStreamInfo)

{- |
/No description available in the introspection data./
-}
discovererInfoGetStreamInfo ::
    (B.CallStack.HasCallStack, MonadIO m, IsDiscovererInfo a) =>
    a
    {- ^ /@info@/: a 'GI.GstPbutils.Objects.DiscovererInfo.DiscovererInfo' -}
    -> m GstPbutils.DiscovererStreamInfo.DiscovererStreamInfo
    {- ^ __Returns:__ the structure (or topology) of the URI as a
'GI.GstPbutils.Objects.DiscovererStreamInfo.DiscovererStreamInfo'.
This structure can be traversed to see the original hierarchy. Unref with
@/gst_discoverer_stream_info_unref()/@ after usage. -}
discovererInfoGetStreamInfo info = liftIO $ do
    info' <- unsafeManagedPtrCastPtr info
    result <- gst_discoverer_info_get_stream_info info'
    checkUnexpectedReturnNULL "discovererInfoGetStreamInfo" result
    result' <- (wrapObject GstPbutils.DiscovererStreamInfo.DiscovererStreamInfo) result
    touchManagedPtr info
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DiscovererInfoGetStreamInfoMethodInfo
instance (signature ~ (m GstPbutils.DiscovererStreamInfo.DiscovererStreamInfo), MonadIO m, IsDiscovererInfo a) => O.MethodInfo DiscovererInfoGetStreamInfoMethodInfo a signature where
    overloadedMethod _ = discovererInfoGetStreamInfo

#endif

-- method DiscovererInfo::get_stream_list
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GstPbutils", name = "DiscovererInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstDiscovererInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TGList (TInterface (Name {namespace = "GstPbutils", name = "DiscovererStreamInfo"})))
-- throws : False
-- Skip return : False

foreign import ccall "gst_discoverer_info_get_stream_list" gst_discoverer_info_get_stream_list :: 
    Ptr DiscovererInfo ->                   -- info : TInterface (Name {namespace = "GstPbutils", name = "DiscovererInfo"})
    IO (Ptr (GList (Ptr GstPbutils.DiscovererStreamInfo.DiscovererStreamInfo)))

{- |
/No description available in the introspection data./
-}
discovererInfoGetStreamList ::
    (B.CallStack.HasCallStack, MonadIO m, IsDiscovererInfo a) =>
    a
    {- ^ /@info@/: a 'GI.GstPbutils.Objects.DiscovererInfo.DiscovererInfo' -}
    -> m [GstPbutils.DiscovererStreamInfo.DiscovererStreamInfo]
    {- ^ __Returns:__ the list of
all streams contained in the @/info/@. Free after usage
with 'GI.GstPbutils.Objects.DiscovererStreamInfo.discovererStreamInfoListFree'. -}
discovererInfoGetStreamList info = liftIO $ do
    info' <- unsafeManagedPtrCastPtr info
    result <- gst_discoverer_info_get_stream_list info'
    result' <- unpackGList result
    result'' <- mapM (wrapObject GstPbutils.DiscovererStreamInfo.DiscovererStreamInfo) result'
    g_list_free result
    touchManagedPtr info
    return result''

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DiscovererInfoGetStreamListMethodInfo
instance (signature ~ (m [GstPbutils.DiscovererStreamInfo.DiscovererStreamInfo]), MonadIO m, IsDiscovererInfo a) => O.MethodInfo DiscovererInfoGetStreamListMethodInfo a signature where
    overloadedMethod _ = discovererInfoGetStreamList

#endif

-- method DiscovererInfo::get_streams
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GstPbutils", name = "DiscovererInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstDiscovererInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "streamtype", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GType derived from #GstDiscovererStreamInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TGList (TInterface (Name {namespace = "GstPbutils", name = "DiscovererStreamInfo"})))
-- throws : False
-- Skip return : False

foreign import ccall "gst_discoverer_info_get_streams" gst_discoverer_info_get_streams :: 
    Ptr DiscovererInfo ->                   -- info : TInterface (Name {namespace = "GstPbutils", name = "DiscovererInfo"})
    CGType ->                               -- streamtype : TBasicType TGType
    IO (Ptr (GList (Ptr GstPbutils.DiscovererStreamInfo.DiscovererStreamInfo)))

{- |
Finds the 'GI.GstPbutils.Objects.DiscovererStreamInfo.DiscovererStreamInfo' contained in /@info@/ that match the
given /@streamtype@/.
-}
discovererInfoGetStreams ::
    (B.CallStack.HasCallStack, MonadIO m, IsDiscovererInfo a) =>
    a
    {- ^ /@info@/: a 'GI.GstPbutils.Objects.DiscovererInfo.DiscovererInfo' -}
    -> GType
    {- ^ /@streamtype@/: a 'GType' derived from 'GI.GstPbutils.Objects.DiscovererStreamInfo.DiscovererStreamInfo' -}
    -> m [GstPbutils.DiscovererStreamInfo.DiscovererStreamInfo]
    {- ^ __Returns:__ A 'GI.GLib.Structs.List.List' of
matching 'GI.GstPbutils.Objects.DiscovererStreamInfo.DiscovererStreamInfo'. The caller should free it with
'GI.GstPbutils.Objects.DiscovererStreamInfo.discovererStreamInfoListFree'. -}
discovererInfoGetStreams info streamtype = liftIO $ do
    info' <- unsafeManagedPtrCastPtr info
    let streamtype' = gtypeToCGType streamtype
    result <- gst_discoverer_info_get_streams info' streamtype'
    result' <- unpackGList result
    result'' <- mapM (wrapObject GstPbutils.DiscovererStreamInfo.DiscovererStreamInfo) result'
    g_list_free result
    touchManagedPtr info
    return result''

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DiscovererInfoGetStreamsMethodInfo
instance (signature ~ (GType -> m [GstPbutils.DiscovererStreamInfo.DiscovererStreamInfo]), MonadIO m, IsDiscovererInfo a) => O.MethodInfo DiscovererInfoGetStreamsMethodInfo a signature where
    overloadedMethod _ = discovererInfoGetStreams

#endif

-- method DiscovererInfo::get_subtitle_streams
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GstPbutils", name = "DiscovererInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstDiscovererInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TGList (TInterface (Name {namespace = "GstPbutils", name = "DiscovererStreamInfo"})))
-- throws : False
-- Skip return : False

foreign import ccall "gst_discoverer_info_get_subtitle_streams" gst_discoverer_info_get_subtitle_streams :: 
    Ptr DiscovererInfo ->                   -- info : TInterface (Name {namespace = "GstPbutils", name = "DiscovererInfo"})
    IO (Ptr (GList (Ptr GstPbutils.DiscovererStreamInfo.DiscovererStreamInfo)))

{- |
Finds all the 'GI.GstPbutils.Objects.DiscovererSubtitleInfo.DiscovererSubtitleInfo' contained in /@info@/
-}
discovererInfoGetSubtitleStreams ::
    (B.CallStack.HasCallStack, MonadIO m, IsDiscovererInfo a) =>
    a
    {- ^ /@info@/: a 'GI.GstPbutils.Objects.DiscovererInfo.DiscovererInfo' -}
    -> m [GstPbutils.DiscovererStreamInfo.DiscovererStreamInfo]
    {- ^ __Returns:__ A 'GI.GLib.Structs.List.List' of
matching 'GI.GstPbutils.Objects.DiscovererStreamInfo.DiscovererStreamInfo'. The caller should free it with
'GI.GstPbutils.Objects.DiscovererStreamInfo.discovererStreamInfoListFree'. -}
discovererInfoGetSubtitleStreams info = liftIO $ do
    info' <- unsafeManagedPtrCastPtr info
    result <- gst_discoverer_info_get_subtitle_streams info'
    result' <- unpackGList result
    result'' <- mapM (wrapObject GstPbutils.DiscovererStreamInfo.DiscovererStreamInfo) result'
    g_list_free result
    touchManagedPtr info
    return result''

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DiscovererInfoGetSubtitleStreamsMethodInfo
instance (signature ~ (m [GstPbutils.DiscovererStreamInfo.DiscovererStreamInfo]), MonadIO m, IsDiscovererInfo a) => O.MethodInfo DiscovererInfoGetSubtitleStreamsMethodInfo a signature where
    overloadedMethod _ = discovererInfoGetSubtitleStreams

#endif

-- method DiscovererInfo::get_tags
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GstPbutils", name = "DiscovererInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstDiscovererInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gst", name = "TagList"}))
-- throws : False
-- Skip return : False

foreign import ccall "gst_discoverer_info_get_tags" gst_discoverer_info_get_tags :: 
    Ptr DiscovererInfo ->                   -- info : TInterface (Name {namespace = "GstPbutils", name = "DiscovererInfo"})
    IO (Ptr Gst.TagList.TagList)

{- |
/No description available in the introspection data./
-}
discovererInfoGetTags ::
    (B.CallStack.HasCallStack, MonadIO m, IsDiscovererInfo a) =>
    a
    {- ^ /@info@/: a 'GI.GstPbutils.Objects.DiscovererInfo.DiscovererInfo' -}
    -> m Gst.TagList.TagList
    {- ^ __Returns:__ all tags contained in the URI. If you wish to use
the tags after the life-time of /@info@/, you will need to copy them. -}
discovererInfoGetTags info = liftIO $ do
    info' <- unsafeManagedPtrCastPtr info
    result <- gst_discoverer_info_get_tags info'
    checkUnexpectedReturnNULL "discovererInfoGetTags" result
    result' <- (newBoxed Gst.TagList.TagList) result
    touchManagedPtr info
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DiscovererInfoGetTagsMethodInfo
instance (signature ~ (m Gst.TagList.TagList), MonadIO m, IsDiscovererInfo a) => O.MethodInfo DiscovererInfoGetTagsMethodInfo a signature where
    overloadedMethod _ = discovererInfoGetTags

#endif

-- method DiscovererInfo::get_toc
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GstPbutils", name = "DiscovererInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstDiscovererInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gst", name = "Toc"}))
-- throws : False
-- Skip return : False

foreign import ccall "gst_discoverer_info_get_toc" gst_discoverer_info_get_toc :: 
    Ptr DiscovererInfo ->                   -- info : TInterface (Name {namespace = "GstPbutils", name = "DiscovererInfo"})
    IO (Ptr Gst.Toc.Toc)

{- |
/No description available in the introspection data./
-}
discovererInfoGetToc ::
    (B.CallStack.HasCallStack, MonadIO m, IsDiscovererInfo a) =>
    a
    {- ^ /@info@/: a 'GI.GstPbutils.Objects.DiscovererInfo.DiscovererInfo' -}
    -> m Gst.Toc.Toc
    {- ^ __Returns:__ TOC contained in the URI. If you wish to use
the TOC after the life-time of /@info@/, you will need to copy it. -}
discovererInfoGetToc info = liftIO $ do
    info' <- unsafeManagedPtrCastPtr info
    result <- gst_discoverer_info_get_toc info'
    checkUnexpectedReturnNULL "discovererInfoGetToc" result
    result' <- (newBoxed Gst.Toc.Toc) result
    touchManagedPtr info
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DiscovererInfoGetTocMethodInfo
instance (signature ~ (m Gst.Toc.Toc), MonadIO m, IsDiscovererInfo a) => O.MethodInfo DiscovererInfoGetTocMethodInfo a signature where
    overloadedMethod _ = discovererInfoGetToc

#endif

-- method DiscovererInfo::get_uri
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GstPbutils", name = "DiscovererInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstDiscovererInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "gst_discoverer_info_get_uri" gst_discoverer_info_get_uri :: 
    Ptr DiscovererInfo ->                   -- info : TInterface (Name {namespace = "GstPbutils", name = "DiscovererInfo"})
    IO CString

{- |
/No description available in the introspection data./
-}
discovererInfoGetUri ::
    (B.CallStack.HasCallStack, MonadIO m, IsDiscovererInfo a) =>
    a
    {- ^ /@info@/: a 'GI.GstPbutils.Objects.DiscovererInfo.DiscovererInfo' -}
    -> m T.Text
    {- ^ __Returns:__ the URI to which this information corresponds to.
Copy it if you wish to use it after the life-time of /@info@/. -}
discovererInfoGetUri info = liftIO $ do
    info' <- unsafeManagedPtrCastPtr info
    result <- gst_discoverer_info_get_uri info'
    checkUnexpectedReturnNULL "discovererInfoGetUri" result
    result' <- cstringToText result
    touchManagedPtr info
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DiscovererInfoGetUriMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsDiscovererInfo a) => O.MethodInfo DiscovererInfoGetUriMethodInfo a signature where
    overloadedMethod _ = discovererInfoGetUri

#endif

-- method DiscovererInfo::get_video_streams
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GstPbutils", name = "DiscovererInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstDiscovererInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TGList (TInterface (Name {namespace = "GstPbutils", name = "DiscovererStreamInfo"})))
-- throws : False
-- Skip return : False

foreign import ccall "gst_discoverer_info_get_video_streams" gst_discoverer_info_get_video_streams :: 
    Ptr DiscovererInfo ->                   -- info : TInterface (Name {namespace = "GstPbutils", name = "DiscovererInfo"})
    IO (Ptr (GList (Ptr GstPbutils.DiscovererStreamInfo.DiscovererStreamInfo)))

{- |
Finds all the 'GI.GstPbutils.Objects.DiscovererVideoInfo.DiscovererVideoInfo' contained in /@info@/
-}
discovererInfoGetVideoStreams ::
    (B.CallStack.HasCallStack, MonadIO m, IsDiscovererInfo a) =>
    a
    {- ^ /@info@/: a 'GI.GstPbutils.Objects.DiscovererInfo.DiscovererInfo' -}
    -> m [GstPbutils.DiscovererStreamInfo.DiscovererStreamInfo]
    {- ^ __Returns:__ A 'GI.GLib.Structs.List.List' of
matching 'GI.GstPbutils.Objects.DiscovererStreamInfo.DiscovererStreamInfo'. The caller should free it with
'GI.GstPbutils.Objects.DiscovererStreamInfo.discovererStreamInfoListFree'. -}
discovererInfoGetVideoStreams info = liftIO $ do
    info' <- unsafeManagedPtrCastPtr info
    result <- gst_discoverer_info_get_video_streams info'
    result' <- unpackGList result
    result'' <- mapM (wrapObject GstPbutils.DiscovererStreamInfo.DiscovererStreamInfo) result'
    g_list_free result
    touchManagedPtr info
    return result''

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DiscovererInfoGetVideoStreamsMethodInfo
instance (signature ~ (m [GstPbutils.DiscovererStreamInfo.DiscovererStreamInfo]), MonadIO m, IsDiscovererInfo a) => O.MethodInfo DiscovererInfoGetVideoStreamsMethodInfo a signature where
    overloadedMethod _ = discovererInfoGetVideoStreams

#endif

-- method DiscovererInfo::to_variant
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "info", argType = TInterface (Name {namespace = "GstPbutils", name = "DiscovererInfo"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GstDiscovererInfo", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "GstPbutils", name = "DiscovererSerializeFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A combination of #GstDiscovererSerializeFlags to specify\nwhat needs to be serialized.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just TVariant
-- throws : False
-- Skip return : False

foreign import ccall "gst_discoverer_info_to_variant" gst_discoverer_info_to_variant :: 
    Ptr DiscovererInfo ->                   -- info : TInterface (Name {namespace = "GstPbutils", name = "DiscovererInfo"})
    CUInt ->                                -- flags : TInterface (Name {namespace = "GstPbutils", name = "DiscovererSerializeFlags"})
    IO (Ptr GVariant)

{- |
Serializes /@info@/ to a 'GVariant' that can be parsed again
through 'GI.GstPbutils.Objects.DiscovererInfo.discovererInfoFromVariant'.

Note that any 'GI.Gst.Structs.Toc.Toc' (s) that might have been discovered will not be serialized
for now.

@since 1.6
-}
discovererInfoToVariant ::
    (B.CallStack.HasCallStack, MonadIO m, IsDiscovererInfo a) =>
    a
    {- ^ /@info@/: A 'GI.GstPbutils.Objects.DiscovererInfo.DiscovererInfo' -}
    -> [GstPbutils.Flags.DiscovererSerializeFlags]
    {- ^ /@flags@/: A combination of 'GI.GstPbutils.Flags.DiscovererSerializeFlags' to specify
what needs to be serialized. -}
    -> m GVariant
    {- ^ __Returns:__ A newly-allocated 'GVariant' representing /@info@/. -}
discovererInfoToVariant info flags = liftIO $ do
    info' <- unsafeManagedPtrCastPtr info
    let flags' = gflagsToWord flags
    result <- gst_discoverer_info_to_variant info' flags'
    checkUnexpectedReturnNULL "discovererInfoToVariant" result
    result' <- wrapGVariantPtr result
    touchManagedPtr info
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DiscovererInfoToVariantMethodInfo
instance (signature ~ ([GstPbutils.Flags.DiscovererSerializeFlags] -> m GVariant), MonadIO m, IsDiscovererInfo a) => O.MethodInfo DiscovererInfoToVariantMethodInfo a signature where
    overloadedMethod _ = discovererInfoToVariant

#endif

-- method DiscovererInfo::from_variant
-- method type : MemberFunction
-- Args : [Arg {argCName = "variant", argType = TVariant, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GVariant to deserialize into a #GstDiscovererInfo.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "GstPbutils", name = "DiscovererInfo"}))
-- throws : False
-- Skip return : False

foreign import ccall "gst_discoverer_info_from_variant" gst_discoverer_info_from_variant :: 
    Ptr GVariant ->                         -- variant : TVariant
    IO (Ptr DiscovererInfo)

{- |
Parses a 'GVariant' as produced by 'GI.GstPbutils.Objects.DiscovererInfo.discovererInfoToVariant'
back to a 'GI.GstPbutils.Objects.DiscovererInfo.DiscovererInfo'.

@since 1.6
-}
discovererInfoFromVariant ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    GVariant
    {- ^ /@variant@/: A 'GVariant' to deserialize into a 'GI.GstPbutils.Objects.DiscovererInfo.DiscovererInfo'. -}
    -> m DiscovererInfo
    {- ^ __Returns:__ A newly-allocated 'GI.GstPbutils.Objects.DiscovererInfo.DiscovererInfo'. -}
discovererInfoFromVariant variant = liftIO $ do
    variant' <- unsafeManagedPtrGetPtr variant
    result <- gst_discoverer_info_from_variant variant'
    checkUnexpectedReturnNULL "discovererInfoFromVariant" result
    result' <- (wrapObject DiscovererInfo) result
    touchManagedPtr variant
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
#endif