{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- /No description available in the introspection data./

#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif

module GI.GES.Objects.UriClipAsset
    ( 

-- * Exported types
    UriClipAsset(..)                        ,
    IsUriClipAsset                          ,
    toUriClipAsset                          ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [addMetasFromString]("GI.GES.Interfaces.MetaContainer#g:method:addMetasFromString"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [checkMetaRegistered]("GI.GES.Interfaces.MetaContainer#g:method:checkMetaRegistered"), [extract]("GI.GES.Objects.Asset#g:method:extract"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [foreach]("GI.GES.Interfaces.MetaContainer#g:method:foreach"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [init]("GI.Gio.Interfaces.Initable#g:method:init"), [initAsync]("GI.Gio.Interfaces.AsyncInitable#g:method:initAsync"), [initFinish]("GI.Gio.Interfaces.AsyncInitable#g:method:initFinish"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [isImage]("GI.GES.Objects.UriClipAsset#g:method:isImage"), [listProxies]("GI.GES.Objects.Asset#g:method:listProxies"), [metasToString]("GI.GES.Interfaces.MetaContainer#g:method:metasToString"), [newFinish]("GI.Gio.Interfaces.AsyncInitable#g:method:newFinish"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [registerMeta]("GI.GES.Interfaces.MetaContainer#g:method:registerMeta"), [registerMetaBoolean]("GI.GES.Interfaces.MetaContainer#g:method:registerMetaBoolean"), [registerMetaDate]("GI.GES.Interfaces.MetaContainer#g:method:registerMetaDate"), [registerMetaDateTime]("GI.GES.Interfaces.MetaContainer#g:method:registerMetaDateTime"), [registerMetaDouble]("GI.GES.Interfaces.MetaContainer#g:method:registerMetaDouble"), [registerMetaFloat]("GI.GES.Interfaces.MetaContainer#g:method:registerMetaFloat"), [registerMetaInt]("GI.GES.Interfaces.MetaContainer#g:method:registerMetaInt"), [registerMetaInt64]("GI.GES.Interfaces.MetaContainer#g:method:registerMetaInt64"), [registerMetaString]("GI.GES.Interfaces.MetaContainer#g:method:registerMetaString"), [registerMetaUint]("GI.GES.Interfaces.MetaContainer#g:method:registerMetaUint"), [registerMetaUint64]("GI.GES.Interfaces.MetaContainer#g:method:registerMetaUint64"), [registerStaticMeta]("GI.GES.Interfaces.MetaContainer#g:method:registerStaticMeta"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unproxy]("GI.GES.Objects.Asset#g:method:unproxy"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getBoolean]("GI.GES.Interfaces.MetaContainer#g:method:getBoolean"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getDate]("GI.GES.Interfaces.MetaContainer#g:method:getDate"), [getDateTime]("GI.GES.Interfaces.MetaContainer#g:method:getDateTime"), [getDouble]("GI.GES.Interfaces.MetaContainer#g:method:getDouble"), [getDuration]("GI.GES.Objects.UriClipAsset#g:method:getDuration"), [getError]("GI.GES.Objects.Asset#g:method:getError"), [getExtractableType]("GI.GES.Objects.Asset#g:method:getExtractableType"), [getFloat]("GI.GES.Interfaces.MetaContainer#g:method:getFloat"), [getFrameTime]("GI.GES.Objects.ClipAsset#g:method:getFrameTime"), [getId]("GI.GES.Objects.Asset#g:method:getId"), [getInfo]("GI.GES.Objects.UriClipAsset#g:method:getInfo"), [getInt]("GI.GES.Interfaces.MetaContainer#g:method:getInt"), [getInt64]("GI.GES.Interfaces.MetaContainer#g:method:getInt64"), [getMarkerList]("GI.GES.Interfaces.MetaContainer#g:method:getMarkerList"), [getMaxDuration]("GI.GES.Objects.UriClipAsset#g:method:getMaxDuration"), [getMeta]("GI.GES.Interfaces.MetaContainer#g:method:getMeta"), [getNaturalFramerate]("GI.GES.Objects.ClipAsset#g:method:getNaturalFramerate"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getProxy]("GI.GES.Objects.Asset#g:method:getProxy"), [getProxyTarget]("GI.GES.Objects.Asset#g:method:getProxyTarget"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getStreamAssets]("GI.GES.Objects.UriClipAsset#g:method:getStreamAssets"), [getString]("GI.GES.Interfaces.MetaContainer#g:method:getString"), [getSupportedFormats]("GI.GES.Objects.ClipAsset#g:method:getSupportedFormats"), [getUint]("GI.GES.Interfaces.MetaContainer#g:method:getUint"), [getUint64]("GI.GES.Interfaces.MetaContainer#g:method:getUint64").
-- 
-- ==== Setters
-- [setBoolean]("GI.GES.Interfaces.MetaContainer#g:method:setBoolean"), [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setDate]("GI.GES.Interfaces.MetaContainer#g:method:setDate"), [setDateTime]("GI.GES.Interfaces.MetaContainer#g:method:setDateTime"), [setDouble]("GI.GES.Interfaces.MetaContainer#g:method:setDouble"), [setFloat]("GI.GES.Interfaces.MetaContainer#g:method:setFloat"), [setInt]("GI.GES.Interfaces.MetaContainer#g:method:setInt"), [setInt64]("GI.GES.Interfaces.MetaContainer#g:method:setInt64"), [setMarkerList]("GI.GES.Interfaces.MetaContainer#g:method:setMarkerList"), [setMeta]("GI.GES.Interfaces.MetaContainer#g:method:setMeta"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setProxy]("GI.GES.Objects.Asset#g:method:setProxy"), [setString]("GI.GES.Interfaces.MetaContainer#g:method:setString"), [setSupportedFormats]("GI.GES.Objects.ClipAsset#g:method:setSupportedFormats"), [setUint]("GI.GES.Interfaces.MetaContainer#g:method:setUint"), [setUint64]("GI.GES.Interfaces.MetaContainer#g:method:setUint64").

#if defined(ENABLE_OVERLOADING)
    ResolveUriClipAssetMethod               ,
#endif

-- ** finish #method:finish#

    uriClipAssetFinish                      ,


-- ** getDuration #method:getDuration#

#if defined(ENABLE_OVERLOADING)
    UriClipAssetGetDurationMethodInfo       ,
#endif
    uriClipAssetGetDuration                 ,


-- ** getInfo #method:getInfo#

#if defined(ENABLE_OVERLOADING)
    UriClipAssetGetInfoMethodInfo           ,
#endif
    uriClipAssetGetInfo                     ,


-- ** getMaxDuration #method:getMaxDuration#

#if defined(ENABLE_OVERLOADING)
    UriClipAssetGetMaxDurationMethodInfo    ,
#endif
    uriClipAssetGetMaxDuration              ,


-- ** getStreamAssets #method:getStreamAssets#

#if defined(ENABLE_OVERLOADING)
    UriClipAssetGetStreamAssetsMethodInfo   ,
#endif
    uriClipAssetGetStreamAssets             ,


-- ** isImage #method:isImage#

#if defined(ENABLE_OVERLOADING)
    UriClipAssetIsImageMethodInfo           ,
#endif
    uriClipAssetIsImage                     ,


-- ** new #method:new#

    uriClipAssetNew                         ,


-- ** requestSync #method:requestSync#

    uriClipAssetRequestSync                 ,




 -- * Properties


-- ** duration #attr:duration#
-- | The duration (in nanoseconds) of the media file

#if defined(ENABLE_OVERLOADING)
    UriClipAssetDurationPropertyInfo        ,
#endif
    constructUriClipAssetDuration           ,
    getUriClipAssetDuration                 ,
    setUriClipAssetDuration                 ,
#if defined(ENABLE_OVERLOADING)
    uriClipAssetDuration                    ,
#endif


-- ** isNestedTimeline #attr:isNestedTimeline#
-- | The duration (in nanoseconds) of the media file
-- 
-- /Since: 1.18/

#if defined(ENABLE_OVERLOADING)
    UriClipAssetIsNestedTimelinePropertyInfo,
#endif
    getUriClipAssetIsNestedTimeline         ,
#if defined(ENABLE_OVERLOADING)
    uriClipAssetIsNestedTimeline            ,
#endif




    ) 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.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
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 GHC.OverloadedLabels as OL
import qualified GHC.Records as R

import {-# SOURCE #-} qualified GI.GES.Interfaces.MetaContainer as GES.MetaContainer
import {-# SOURCE #-} qualified GI.GES.Objects.Asset as GES.Asset
import {-# SOURCE #-} qualified GI.GES.Objects.ClipAsset as GES.ClipAsset
import {-# SOURCE #-} qualified GI.GES.Objects.SourceClipAsset as GES.SourceClipAsset
import {-# SOURCE #-} qualified GI.GES.Objects.UriSourceAsset as GES.UriSourceAsset
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gio.Callbacks as Gio.Callbacks
import qualified GI.Gio.Interfaces.AsyncInitable as Gio.AsyncInitable
import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult
import qualified GI.Gio.Interfaces.Initable as Gio.Initable
import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable
import qualified GI.GstPbutils.Objects.DiscovererInfo as GstPbutils.DiscovererInfo

-- | Memory-managed wrapper type.
newtype UriClipAsset = UriClipAsset (SP.ManagedPtr UriClipAsset)
    deriving (UriClipAsset -> UriClipAsset -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: UriClipAsset -> UriClipAsset -> Bool
$c/= :: UriClipAsset -> UriClipAsset -> Bool
== :: UriClipAsset -> UriClipAsset -> Bool
$c== :: UriClipAsset -> UriClipAsset -> Bool
Eq)

instance SP.ManagedPtrNewtype UriClipAsset where
    toManagedPtr :: UriClipAsset -> ManagedPtr UriClipAsset
toManagedPtr (UriClipAsset ManagedPtr UriClipAsset
p) = ManagedPtr UriClipAsset
p

foreign import ccall "ges_uri_clip_asset_get_type"
    c_ges_uri_clip_asset_get_type :: IO B.Types.GType

instance B.Types.TypedObject UriClipAsset where
    glibType :: IO GType
glibType = IO GType
c_ges_uri_clip_asset_get_type

instance B.Types.GObject UriClipAsset

-- | Type class for types which can be safely cast to `UriClipAsset`, for instance with `toUriClipAsset`.
class (SP.GObject o, O.IsDescendantOf UriClipAsset o) => IsUriClipAsset o
instance (SP.GObject o, O.IsDescendantOf UriClipAsset o) => IsUriClipAsset o

instance O.HasParentTypes UriClipAsset
type instance O.ParentTypes UriClipAsset = '[GES.SourceClipAsset.SourceClipAsset, GES.ClipAsset.ClipAsset, GES.Asset.Asset, GObject.Object.Object, GES.MetaContainer.MetaContainer, Gio.AsyncInitable.AsyncInitable, Gio.Initable.Initable]

-- | Cast to `UriClipAsset`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toUriClipAsset :: (MIO.MonadIO m, IsUriClipAsset o) => o -> m UriClipAsset
toUriClipAsset :: forall (m :: * -> *) o.
(MonadIO m, IsUriClipAsset o) =>
o -> m UriClipAsset
toUriClipAsset = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
 ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr UriClipAsset -> UriClipAsset
UriClipAsset

-- | Convert 'UriClipAsset' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue (Maybe UriClipAsset) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_ges_uri_clip_asset_get_type
    gvalueSet_ :: Ptr GValue -> Maybe UriClipAsset -> IO ()
gvalueSet_ Ptr GValue
gv Maybe UriClipAsset
P.Nothing = forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (forall a. Ptr a
FP.nullPtr :: FP.Ptr UriClipAsset)
    gvalueSet_ Ptr GValue
gv (P.Just UriClipAsset
obj) = forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr UriClipAsset
obj (forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe UriClipAsset)
gvalueGet_ Ptr GValue
gv = do
        Ptr UriClipAsset
ptr <- forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr UriClipAsset)
        if Ptr UriClipAsset
ptr forall a. Eq a => a -> a -> Bool
/= forall a. Ptr a
FP.nullPtr
        then forall a. a -> Maybe a
P.Just forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr UriClipAsset -> UriClipAsset
UriClipAsset Ptr UriClipAsset
ptr
        else forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
P.Nothing
        
    

#if defined(ENABLE_OVERLOADING)
type family ResolveUriClipAssetMethod (t :: Symbol) (o :: *) :: * where
    ResolveUriClipAssetMethod "addMetasFromString" o = GES.MetaContainer.MetaContainerAddMetasFromStringMethodInfo
    ResolveUriClipAssetMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveUriClipAssetMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveUriClipAssetMethod "checkMetaRegistered" o = GES.MetaContainer.MetaContainerCheckMetaRegisteredMethodInfo
    ResolveUriClipAssetMethod "extract" o = GES.Asset.AssetExtractMethodInfo
    ResolveUriClipAssetMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveUriClipAssetMethod "foreach" o = GES.MetaContainer.MetaContainerForeachMethodInfo
    ResolveUriClipAssetMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveUriClipAssetMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveUriClipAssetMethod "init" o = Gio.Initable.InitableInitMethodInfo
    ResolveUriClipAssetMethod "initAsync" o = Gio.AsyncInitable.AsyncInitableInitAsyncMethodInfo
    ResolveUriClipAssetMethod "initFinish" o = Gio.AsyncInitable.AsyncInitableInitFinishMethodInfo
    ResolveUriClipAssetMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveUriClipAssetMethod "isImage" o = UriClipAssetIsImageMethodInfo
    ResolveUriClipAssetMethod "listProxies" o = GES.Asset.AssetListProxiesMethodInfo
    ResolveUriClipAssetMethod "metasToString" o = GES.MetaContainer.MetaContainerMetasToStringMethodInfo
    ResolveUriClipAssetMethod "newFinish" o = Gio.AsyncInitable.AsyncInitableNewFinishMethodInfo
    ResolveUriClipAssetMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveUriClipAssetMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveUriClipAssetMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveUriClipAssetMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveUriClipAssetMethod "registerMeta" o = GES.MetaContainer.MetaContainerRegisterMetaMethodInfo
    ResolveUriClipAssetMethod "registerMetaBoolean" o = GES.MetaContainer.MetaContainerRegisterMetaBooleanMethodInfo
    ResolveUriClipAssetMethod "registerMetaDate" o = GES.MetaContainer.MetaContainerRegisterMetaDateMethodInfo
    ResolveUriClipAssetMethod "registerMetaDateTime" o = GES.MetaContainer.MetaContainerRegisterMetaDateTimeMethodInfo
    ResolveUriClipAssetMethod "registerMetaDouble" o = GES.MetaContainer.MetaContainerRegisterMetaDoubleMethodInfo
    ResolveUriClipAssetMethod "registerMetaFloat" o = GES.MetaContainer.MetaContainerRegisterMetaFloatMethodInfo
    ResolveUriClipAssetMethod "registerMetaInt" o = GES.MetaContainer.MetaContainerRegisterMetaIntMethodInfo
    ResolveUriClipAssetMethod "registerMetaInt64" o = GES.MetaContainer.MetaContainerRegisterMetaInt64MethodInfo
    ResolveUriClipAssetMethod "registerMetaString" o = GES.MetaContainer.MetaContainerRegisterMetaStringMethodInfo
    ResolveUriClipAssetMethod "registerMetaUint" o = GES.MetaContainer.MetaContainerRegisterMetaUintMethodInfo
    ResolveUriClipAssetMethod "registerMetaUint64" o = GES.MetaContainer.MetaContainerRegisterMetaUint64MethodInfo
    ResolveUriClipAssetMethod "registerStaticMeta" o = GES.MetaContainer.MetaContainerRegisterStaticMetaMethodInfo
    ResolveUriClipAssetMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveUriClipAssetMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveUriClipAssetMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveUriClipAssetMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveUriClipAssetMethod "unproxy" o = GES.Asset.AssetUnproxyMethodInfo
    ResolveUriClipAssetMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveUriClipAssetMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveUriClipAssetMethod "getBoolean" o = GES.MetaContainer.MetaContainerGetBooleanMethodInfo
    ResolveUriClipAssetMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveUriClipAssetMethod "getDate" o = GES.MetaContainer.MetaContainerGetDateMethodInfo
    ResolveUriClipAssetMethod "getDateTime" o = GES.MetaContainer.MetaContainerGetDateTimeMethodInfo
    ResolveUriClipAssetMethod "getDouble" o = GES.MetaContainer.MetaContainerGetDoubleMethodInfo
    ResolveUriClipAssetMethod "getDuration" o = UriClipAssetGetDurationMethodInfo
    ResolveUriClipAssetMethod "getError" o = GES.Asset.AssetGetErrorMethodInfo
    ResolveUriClipAssetMethod "getExtractableType" o = GES.Asset.AssetGetExtractableTypeMethodInfo
    ResolveUriClipAssetMethod "getFloat" o = GES.MetaContainer.MetaContainerGetFloatMethodInfo
    ResolveUriClipAssetMethod "getFrameTime" o = GES.ClipAsset.ClipAssetGetFrameTimeMethodInfo
    ResolveUriClipAssetMethod "getId" o = GES.Asset.AssetGetIdMethodInfo
    ResolveUriClipAssetMethod "getInfo" o = UriClipAssetGetInfoMethodInfo
    ResolveUriClipAssetMethod "getInt" o = GES.MetaContainer.MetaContainerGetIntMethodInfo
    ResolveUriClipAssetMethod "getInt64" o = GES.MetaContainer.MetaContainerGetInt64MethodInfo
    ResolveUriClipAssetMethod "getMarkerList" o = GES.MetaContainer.MetaContainerGetMarkerListMethodInfo
    ResolveUriClipAssetMethod "getMaxDuration" o = UriClipAssetGetMaxDurationMethodInfo
    ResolveUriClipAssetMethod "getMeta" o = GES.MetaContainer.MetaContainerGetMetaMethodInfo
    ResolveUriClipAssetMethod "getNaturalFramerate" o = GES.ClipAsset.ClipAssetGetNaturalFramerateMethodInfo
    ResolveUriClipAssetMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveUriClipAssetMethod "getProxy" o = GES.Asset.AssetGetProxyMethodInfo
    ResolveUriClipAssetMethod "getProxyTarget" o = GES.Asset.AssetGetProxyTargetMethodInfo
    ResolveUriClipAssetMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveUriClipAssetMethod "getStreamAssets" o = UriClipAssetGetStreamAssetsMethodInfo
    ResolveUriClipAssetMethod "getString" o = GES.MetaContainer.MetaContainerGetStringMethodInfo
    ResolveUriClipAssetMethod "getSupportedFormats" o = GES.ClipAsset.ClipAssetGetSupportedFormatsMethodInfo
    ResolveUriClipAssetMethod "getUint" o = GES.MetaContainer.MetaContainerGetUintMethodInfo
    ResolveUriClipAssetMethod "getUint64" o = GES.MetaContainer.MetaContainerGetUint64MethodInfo
    ResolveUriClipAssetMethod "setBoolean" o = GES.MetaContainer.MetaContainerSetBooleanMethodInfo
    ResolveUriClipAssetMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveUriClipAssetMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveUriClipAssetMethod "setDate" o = GES.MetaContainer.MetaContainerSetDateMethodInfo
    ResolveUriClipAssetMethod "setDateTime" o = GES.MetaContainer.MetaContainerSetDateTimeMethodInfo
    ResolveUriClipAssetMethod "setDouble" o = GES.MetaContainer.MetaContainerSetDoubleMethodInfo
    ResolveUriClipAssetMethod "setFloat" o = GES.MetaContainer.MetaContainerSetFloatMethodInfo
    ResolveUriClipAssetMethod "setInt" o = GES.MetaContainer.MetaContainerSetIntMethodInfo
    ResolveUriClipAssetMethod "setInt64" o = GES.MetaContainer.MetaContainerSetInt64MethodInfo
    ResolveUriClipAssetMethod "setMarkerList" o = GES.MetaContainer.MetaContainerSetMarkerListMethodInfo
    ResolveUriClipAssetMethod "setMeta" o = GES.MetaContainer.MetaContainerSetMetaMethodInfo
    ResolveUriClipAssetMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveUriClipAssetMethod "setProxy" o = GES.Asset.AssetSetProxyMethodInfo
    ResolveUriClipAssetMethod "setString" o = GES.MetaContainer.MetaContainerSetStringMethodInfo
    ResolveUriClipAssetMethod "setSupportedFormats" o = GES.ClipAsset.ClipAssetSetSupportedFormatsMethodInfo
    ResolveUriClipAssetMethod "setUint" o = GES.MetaContainer.MetaContainerSetUintMethodInfo
    ResolveUriClipAssetMethod "setUint64" o = GES.MetaContainer.MetaContainerSetUint64MethodInfo
    ResolveUriClipAssetMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveUriClipAssetMethod t UriClipAsset, O.OverloadedMethod info UriClipAsset p) => OL.IsLabel t (UriClipAsset -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod @info
#else
    fromLabel _ = O.overloadedMethod @info
#endif

#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveUriClipAssetMethod t UriClipAsset, O.OverloadedMethod info UriClipAsset p, R.HasField t UriClipAsset p) => R.HasField t UriClipAsset p where
    getField = O.overloadedMethod @info

#endif

instance (info ~ ResolveUriClipAssetMethod t UriClipAsset, O.OverloadedMethodInfo info UriClipAsset) => OL.IsLabel t (O.MethodProxy info UriClipAsset) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.MethodProxy
#else
    fromLabel _ = O.MethodProxy
#endif

#endif

-- VVV Prop "duration"
   -- Type: TBasicType TUInt64
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Nothing)

-- | Get the value of the “@duration@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' uriClipAsset #duration
-- @
getUriClipAssetDuration :: (MonadIO m, IsUriClipAsset o) => o -> m Word64
getUriClipAssetDuration :: forall (m :: * -> *) o.
(MonadIO m, IsUriClipAsset o) =>
o -> m Word64
getUriClipAssetDuration o
obj = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ forall a. GObject a => a -> String -> IO Word64
B.Properties.getObjectPropertyUInt64 o
obj String
"duration"

-- | Set the value of the “@duration@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' uriClipAsset [ #duration 'Data.GI.Base.Attributes.:=' value ]
-- @
setUriClipAssetDuration :: (MonadIO m, IsUriClipAsset o) => o -> Word64 -> m ()
setUriClipAssetDuration :: forall (m :: * -> *) o.
(MonadIO m, IsUriClipAsset o) =>
o -> Word64 -> m ()
setUriClipAssetDuration o
obj Word64
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ do
    forall a. GObject a => a -> String -> Word64 -> IO ()
B.Properties.setObjectPropertyUInt64 o
obj String
"duration" Word64
val

-- | Construct a `GValueConstruct` with valid value for the “@duration@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructUriClipAssetDuration :: (IsUriClipAsset o, MIO.MonadIO m) => Word64 -> m (GValueConstruct o)
constructUriClipAssetDuration :: forall o (m :: * -> *).
(IsUriClipAsset o, MonadIO m) =>
Word64 -> m (GValueConstruct o)
constructUriClipAssetDuration Word64
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ do
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ forall o. String -> Word64 -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyUInt64 String
"duration" Word64
val

#if defined(ENABLE_OVERLOADING)
data UriClipAssetDurationPropertyInfo
instance AttrInfo UriClipAssetDurationPropertyInfo where
    type AttrAllowedOps UriClipAssetDurationPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint UriClipAssetDurationPropertyInfo = IsUriClipAsset
    type AttrSetTypeConstraint UriClipAssetDurationPropertyInfo = (~) Word64
    type AttrTransferTypeConstraint UriClipAssetDurationPropertyInfo = (~) Word64
    type AttrTransferType UriClipAssetDurationPropertyInfo = Word64
    type AttrGetType UriClipAssetDurationPropertyInfo = Word64
    type AttrLabel UriClipAssetDurationPropertyInfo = "duration"
    type AttrOrigin UriClipAssetDurationPropertyInfo = UriClipAsset
    attrGet = getUriClipAssetDuration
    attrSet = setUriClipAssetDuration
    attrTransfer _ v = do
        return v
    attrConstruct = constructUriClipAssetDuration
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.UriClipAsset.duration"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.1/docs/GI-GES-Objects-UriClipAsset.html#g:attr:duration"
        })
#endif

-- VVV Prop "is-nested-timeline"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@is-nested-timeline@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' uriClipAsset #isNestedTimeline
-- @
getUriClipAssetIsNestedTimeline :: (MonadIO m, IsUriClipAsset o) => o -> m Bool
getUriClipAssetIsNestedTimeline :: forall (m :: * -> *) o.
(MonadIO m, IsUriClipAsset o) =>
o -> m Bool
getUriClipAssetIsNestedTimeline o
obj = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"is-nested-timeline"

#if defined(ENABLE_OVERLOADING)
data UriClipAssetIsNestedTimelinePropertyInfo
instance AttrInfo UriClipAssetIsNestedTimelinePropertyInfo where
    type AttrAllowedOps UriClipAssetIsNestedTimelinePropertyInfo = '[ 'AttrGet]
    type AttrBaseTypeConstraint UriClipAssetIsNestedTimelinePropertyInfo = IsUriClipAsset
    type AttrSetTypeConstraint UriClipAssetIsNestedTimelinePropertyInfo = (~) ()
    type AttrTransferTypeConstraint UriClipAssetIsNestedTimelinePropertyInfo = (~) ()
    type AttrTransferType UriClipAssetIsNestedTimelinePropertyInfo = ()
    type AttrGetType UriClipAssetIsNestedTimelinePropertyInfo = Bool
    type AttrLabel UriClipAssetIsNestedTimelinePropertyInfo = "is-nested-timeline"
    type AttrOrigin UriClipAssetIsNestedTimelinePropertyInfo = UriClipAsset
    attrGet = getUriClipAssetIsNestedTimeline
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.UriClipAsset.isNestedTimeline"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.1/docs/GI-GES-Objects-UriClipAsset.html#g:attr:isNestedTimeline"
        })
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList UriClipAsset
type instance O.AttributeList UriClipAsset = UriClipAssetAttributeList
type UriClipAssetAttributeList = ('[ '("duration", UriClipAssetDurationPropertyInfo), '("extractableType", GES.Asset.AssetExtractableTypePropertyInfo), '("id", GES.Asset.AssetIdPropertyInfo), '("isNestedTimeline", UriClipAssetIsNestedTimelinePropertyInfo), '("proxy", GES.Asset.AssetProxyPropertyInfo), '("proxyTarget", GES.Asset.AssetProxyTargetPropertyInfo), '("supportedFormats", GES.ClipAsset.ClipAssetSupportedFormatsPropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
uriClipAssetDuration :: AttrLabelProxy "duration"
uriClipAssetDuration = AttrLabelProxy

uriClipAssetIsNestedTimeline :: AttrLabelProxy "isNestedTimeline"
uriClipAssetIsNestedTimeline = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList UriClipAsset = UriClipAssetSignalList
type UriClipAssetSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo), '("notifyMeta", GES.MetaContainer.MetaContainerNotifyMetaSignalInfo)] :: [(Symbol, *)])

#endif

-- method UriClipAsset::get_duration
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "UriClipAsset" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GESUriClipAsset" , 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 "ges_uri_clip_asset_get_duration" ges_uri_clip_asset_get_duration :: 
    Ptr UriClipAsset ->                     -- self : TInterface (Name {namespace = "GES", name = "UriClipAsset"})
    IO Word64

-- | Gets duration of the file represented by /@self@/
uriClipAssetGetDuration ::
    (B.CallStack.HasCallStack, MonadIO m, IsUriClipAsset a) =>
    a
    -- ^ /@self@/: a t'GI.GES.Objects.UriClipAsset.UriClipAsset'
    -> m Word64
    -- ^ __Returns:__ The duration of /@self@/
uriClipAssetGetDuration :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsUriClipAsset a) =>
a -> m Word64
uriClipAssetGetDuration a
self = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr UriClipAsset
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Word64
result <- Ptr UriClipAsset -> IO Word64
ges_uri_clip_asset_get_duration Ptr UriClipAsset
self'
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall (m :: * -> *) a. Monad m => a -> m a
return Word64
result

#if defined(ENABLE_OVERLOADING)
data UriClipAssetGetDurationMethodInfo
instance (signature ~ (m Word64), MonadIO m, IsUriClipAsset a) => O.OverloadedMethod UriClipAssetGetDurationMethodInfo a signature where
    overloadedMethod = uriClipAssetGetDuration

instance O.OverloadedMethodInfo UriClipAssetGetDurationMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.UriClipAsset.uriClipAssetGetDuration",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.1/docs/GI-GES-Objects-UriClipAsset.html#v:uriClipAssetGetDuration"
        })


#endif

-- method UriClipAsset::get_info
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "UriClipAsset" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "Target asset" , 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 "ges_uri_clip_asset_get_info" ges_uri_clip_asset_get_info :: 
    Ptr UriClipAsset ->                     -- self : TInterface (Name {namespace = "GES", name = "UriClipAsset"})
    IO (Ptr GstPbutils.DiscovererInfo.DiscovererInfo)

-- | Gets t'GI.GstPbutils.Objects.DiscovererInfo.DiscovererInfo' about the file
uriClipAssetGetInfo ::
    (B.CallStack.HasCallStack, MonadIO m, IsUriClipAsset a) =>
    a
    -- ^ /@self@/: Target asset
    -> m GstPbutils.DiscovererInfo.DiscovererInfo
    -- ^ __Returns:__ t'GI.GstPbutils.Objects.DiscovererInfo.DiscovererInfo' of specified asset
uriClipAssetGetInfo :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsUriClipAsset a) =>
a -> m DiscovererInfo
uriClipAssetGetInfo a
self = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr UriClipAsset
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr DiscovererInfo
result <- Ptr UriClipAsset -> IO (Ptr DiscovererInfo)
ges_uri_clip_asset_get_info Ptr UriClipAsset
self'
    forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"uriClipAssetGetInfo" Ptr DiscovererInfo
result
    DiscovererInfo
result' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr DiscovererInfo -> DiscovererInfo
GstPbutils.DiscovererInfo.DiscovererInfo) Ptr DiscovererInfo
result
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall (m :: * -> *) a. Monad m => a -> m a
return DiscovererInfo
result'

#if defined(ENABLE_OVERLOADING)
data UriClipAssetGetInfoMethodInfo
instance (signature ~ (m GstPbutils.DiscovererInfo.DiscovererInfo), MonadIO m, IsUriClipAsset a) => O.OverloadedMethod UriClipAssetGetInfoMethodInfo a signature where
    overloadedMethod = uriClipAssetGetInfo

instance O.OverloadedMethodInfo UriClipAssetGetInfoMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.UriClipAsset.uriClipAssetGetInfo",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.1/docs/GI-GES-Objects-UriClipAsset.html#v:uriClipAssetGetInfo"
        })


#endif

-- method UriClipAsset::get_max_duration
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "UriClipAsset" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GESUriClipAsset" , 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 "ges_uri_clip_asset_get_max_duration" ges_uri_clip_asset_get_max_duration :: 
    Ptr UriClipAsset ->                     -- self : TInterface (Name {namespace = "GES", name = "UriClipAsset"})
    IO Word64

-- | Gets maximum duration of the file represented by /@self@/,
-- it is usually the same as GESUriClipAsset[duration](#g:signal:duration),
-- but in the case of nested timelines, for example, they
-- are different as those can be extended \'infinitely\'.
-- 
-- /Since: 1.18/
uriClipAssetGetMaxDuration ::
    (B.CallStack.HasCallStack, MonadIO m, IsUriClipAsset a) =>
    a
    -- ^ /@self@/: a t'GI.GES.Objects.UriClipAsset.UriClipAsset'
    -> m Word64
    -- ^ __Returns:__ The maximum duration of /@self@/
uriClipAssetGetMaxDuration :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsUriClipAsset a) =>
a -> m Word64
uriClipAssetGetMaxDuration a
self = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr UriClipAsset
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Word64
result <- Ptr UriClipAsset -> IO Word64
ges_uri_clip_asset_get_max_duration Ptr UriClipAsset
self'
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall (m :: * -> *) a. Monad m => a -> m a
return Word64
result

#if defined(ENABLE_OVERLOADING)
data UriClipAssetGetMaxDurationMethodInfo
instance (signature ~ (m Word64), MonadIO m, IsUriClipAsset a) => O.OverloadedMethod UriClipAssetGetMaxDurationMethodInfo a signature where
    overloadedMethod = uriClipAssetGetMaxDuration

instance O.OverloadedMethodInfo UriClipAssetGetMaxDurationMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.UriClipAsset.uriClipAssetGetMaxDuration",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.1/docs/GI-GES-Objects-UriClipAsset.html#v:uriClipAssetGetMaxDuration"
        })


#endif

-- method UriClipAsset::get_stream_assets
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "UriClipAsset" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #GESUriClipAsset" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TGList
--                  (TInterface Name { namespace = "GES" , name = "UriSourceAsset" }))
-- throws : False
-- Skip return : False

foreign import ccall "ges_uri_clip_asset_get_stream_assets" ges_uri_clip_asset_get_stream_assets :: 
    Ptr UriClipAsset ->                     -- self : TInterface (Name {namespace = "GES", name = "UriClipAsset"})
    IO (Ptr (GList (Ptr GES.UriSourceAsset.UriSourceAsset)))

-- | Get the GESUriSourceAsset /@self@/ containes
uriClipAssetGetStreamAssets ::
    (B.CallStack.HasCallStack, MonadIO m, IsUriClipAsset a) =>
    a
    -- ^ /@self@/: A t'GI.GES.Objects.UriClipAsset.UriClipAsset'
    -> m [GES.UriSourceAsset.UriSourceAsset]
    -- ^ __Returns:__ a
    -- t'GI.GLib.Structs.List.List' of t'GI.GES.Objects.UriSourceAsset.UriSourceAsset'
uriClipAssetGetStreamAssets :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsUriClipAsset a) =>
a -> m [UriSourceAsset]
uriClipAssetGetStreamAssets a
self = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr UriClipAsset
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    Ptr (GList (Ptr UriSourceAsset))
result <- Ptr UriClipAsset -> IO (Ptr (GList (Ptr UriSourceAsset)))
ges_uri_clip_asset_get_stream_assets Ptr UriClipAsset
self'
    [Ptr UriSourceAsset]
result' <- forall a. Ptr (GList (Ptr a)) -> IO [Ptr a]
unpackGList Ptr (GList (Ptr UriSourceAsset))
result
    [UriSourceAsset]
result'' <- forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr UriSourceAsset -> UriSourceAsset
GES.UriSourceAsset.UriSourceAsset) [Ptr UriSourceAsset]
result'
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall (m :: * -> *) a. Monad m => a -> m a
return [UriSourceAsset]
result''

#if defined(ENABLE_OVERLOADING)
data UriClipAssetGetStreamAssetsMethodInfo
instance (signature ~ (m [GES.UriSourceAsset.UriSourceAsset]), MonadIO m, IsUriClipAsset a) => O.OverloadedMethod UriClipAssetGetStreamAssetsMethodInfo a signature where
    overloadedMethod = uriClipAssetGetStreamAssets

instance O.OverloadedMethodInfo UriClipAssetGetStreamAssetsMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.UriClipAsset.uriClipAssetGetStreamAssets",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.1/docs/GI-GES-Objects-UriClipAsset.html#v:uriClipAssetGetStreamAssets"
        })


#endif

-- method UriClipAsset::is_image
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "self"
--           , argType =
--               TInterface Name { namespace = "GES" , name = "UriClipAsset" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GESUriClipAsset" , 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 "ges_uri_clip_asset_is_image" ges_uri_clip_asset_is_image :: 
    Ptr UriClipAsset ->                     -- self : TInterface (Name {namespace = "GES", name = "UriClipAsset"})
    IO CInt

-- | Gets Whether the file represented by /@self@/ is an image or not
-- 
-- /Since: 1.18/
uriClipAssetIsImage ::
    (B.CallStack.HasCallStack, MonadIO m, IsUriClipAsset a) =>
    a
    -- ^ /@self@/: a t'GI.GES.Objects.UriClipAsset.UriClipAsset'
    -> m Bool
    -- ^ __Returns:__ Whether the file represented by /@self@/ is an image or not
uriClipAssetIsImage :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsUriClipAsset a) =>
a -> m Bool
uriClipAssetIsImage a
self = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr UriClipAsset
self' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
self
    CInt
result <- Ptr UriClipAsset -> IO CInt
ges_uri_clip_asset_is_image Ptr UriClipAsset
self'
    let result' :: Bool
result' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
self
    forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data UriClipAssetIsImageMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsUriClipAsset a) => O.OverloadedMethod UriClipAssetIsImageMethodInfo a signature where
    overloadedMethod = uriClipAssetIsImage

instance O.OverloadedMethodInfo UriClipAssetIsImageMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GES.Objects.UriClipAsset.uriClipAssetIsImage",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-ges-1.0.1/docs/GI-GES-Objects-UriClipAsset.html#v:uriClipAssetIsImage"
        })


#endif

-- method UriClipAsset::finish
-- method type : MemberFunction
-- Args: [ Arg
--           { argCName = "res"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "AsyncResult" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "The #GAsyncResult from which to get the newly created #GESUriClipAsset"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "GES" , name = "UriClipAsset" })
-- throws : True
-- Skip return : False

foreign import ccall "ges_uri_clip_asset_finish" ges_uri_clip_asset_finish :: 
    Ptr Gio.AsyncResult.AsyncResult ->      -- res : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr UriClipAsset)

-- | Finalize the request of an async t'GI.GES.Objects.UriClipAsset.UriClipAsset'
-- 
-- /Since: 1.16/
uriClipAssetFinish ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.AsyncResult.IsAsyncResult a) =>
    a
    -- ^ /@res@/: The t'GI.Gio.Interfaces.AsyncResult.AsyncResult' from which to get the newly created t'GI.GES.Objects.UriClipAsset.UriClipAsset'
    -> m UriClipAsset
    -- ^ __Returns:__ The t'GI.GES.Objects.UriClipAsset.UriClipAsset' previously requested /(Can throw 'Data.GI.Base.GError.GError')/
uriClipAssetFinish :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsAsyncResult a) =>
a -> m UriClipAsset
uriClipAssetFinish a
res = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    Ptr AsyncResult
res' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
res
    forall a b. IO a -> IO b -> IO a
onException (do
        Ptr UriClipAsset
result <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr AsyncResult -> Ptr (Ptr GError) -> IO (Ptr UriClipAsset)
ges_uri_clip_asset_finish Ptr AsyncResult
res'
        forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"uriClipAssetFinish" Ptr UriClipAsset
result
        UriClipAsset
result' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr UriClipAsset -> UriClipAsset
UriClipAsset) Ptr UriClipAsset
result
        forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
res
        forall (m :: * -> *) a. Monad m => a -> m a
return UriClipAsset
result'
     ) (do
        forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

#if defined(ENABLE_OVERLOADING)
#endif

-- method UriClipAsset::new
-- method type : MemberFunction
-- Args: [ Arg
--           { argCName = "uri"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "The URI of the file for which to create a #GESUriClipAsset"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "cancellable"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "Cancellable" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "optional %GCancellable object, %NULL to ignore."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "callback"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "AsyncReadyCallback" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "a #GAsyncReadyCallback to call when the initialization is finished"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeAsync
--           , argClosure = 3
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "The user data to pass when @callback is called"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "ges_uri_clip_asset_new" ges_uri_clip_asset_new :: 
    CString ->                              -- uri : TBasicType TUTF8
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"})
    Ptr () ->                               -- user_data : TBasicType TPtr
    IO ()

-- | Creates a t'GI.GES.Objects.UriClipAsset.UriClipAsset' for /@uri@/
-- 
-- Example of request of a GESUriClipAsset:
-- >
-- >// The request callback
-- >static void
-- >filesource_asset_loaded_cb (GESAsset * source, GAsyncResult * res, gpointer user_data)
-- >{
-- >  GError *error = NULL;
-- >  GESUriClipAsset *filesource_asset;
-- >
-- >  filesource_asset = ges_uri_clip_asset_finish (res, &error);
-- >  if (filesource_asset) {
-- >   gst_print ("The file: %s is usable as a FileSource, it is%s an image and lasts %" GST_TIME_FORMAT,
-- >       ges_asset_get_id (GES_ASSET (filesource_asset))
-- >       ges_uri_clip_asset_is_image (filesource_asset) ? "" : " not",
-- >       GST_TIME_ARGS (ges_uri_clip_asset_get_duration (filesource_asset));
-- >  } else {
-- >   gst_print ("The file: %s is *not* usable as a FileSource because: %s",
-- >       ges_asset_get_id (source), error->message);
-- >  }
-- >
-- >  gst_object_unref (mfs);
-- >}
-- >
-- >// The request:
-- >ges_uri_clip_asset_new (uri, (GAsyncReadyCallback) filesource_asset_loaded_cb, user_data);
uriClipAssetNew ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.Cancellable.IsCancellable a) =>
    T.Text
    -- ^ /@uri@/: The URI of the file for which to create a t'GI.GES.Objects.UriClipAsset.UriClipAsset'
    -> Maybe (a)
    -- ^ /@cancellable@/: optional @/GCancellable/@ object, 'P.Nothing' to ignore.
    -> Maybe (Gio.Callbacks.AsyncReadyCallback)
    -- ^ /@callback@/: a t'GI.Gio.Callbacks.AsyncReadyCallback' to call when the initialization is finished
    -> m ()
uriClipAssetNew :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsCancellable a) =>
Text -> Maybe a -> Maybe AsyncReadyCallback -> m ()
uriClipAssetNew Text
uri Maybe a
cancellable Maybe AsyncReadyCallback
callback = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    CString
uri' <- Text -> IO CString
textToCString Text
uri
    Ptr Cancellable
maybeCancellable <- case Maybe a
cancellable of
        Maybe a
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
        Just a
jCancellable -> do
            Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
jCancellable
            forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    FunPtr C_AsyncReadyCallback
maybeCallback <- case Maybe AsyncReadyCallback
callback of
        Maybe AsyncReadyCallback
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return (forall a b. Ptr a -> FunPtr b
castPtrToFunPtr forall a. Ptr a
nullPtr)
        Just AsyncReadyCallback
jCallback -> do
            Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
            FunPtr C_AsyncReadyCallback
jCallback' <- C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
Gio.Callbacks.mk_AsyncReadyCallback (Maybe (Ptr (FunPtr C_AsyncReadyCallback))
-> AsyncReadyCallback_WithClosures -> C_AsyncReadyCallback
Gio.Callbacks.wrap_AsyncReadyCallback (forall a. a -> Maybe a
Just Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback) (AsyncReadyCallback -> AsyncReadyCallback_WithClosures
Gio.Callbacks.drop_closures_AsyncReadyCallback AsyncReadyCallback
jCallback))
            forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback FunPtr C_AsyncReadyCallback
jCallback'
            forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_AsyncReadyCallback
jCallback'
    let userData :: Ptr a
userData = forall a. Ptr a
nullPtr
    CString
-> Ptr Cancellable
-> FunPtr C_AsyncReadyCallback
-> Ptr ()
-> IO ()
ges_uri_clip_asset_new CString
uri' Ptr Cancellable
maybeCancellable FunPtr C_AsyncReadyCallback
maybeCallback forall a. Ptr a
userData
    forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe a
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    forall a. Ptr a -> IO ()
freeMem CString
uri'
    forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
#endif

-- method UriClipAsset::request_sync
-- method type : MemberFunction
-- Args: [ Arg
--           { argCName = "uri"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "The URI of the file for which to create a #GESUriClipAsset.\nYou can also use multi file uris for #GESMultiFileSource."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "GES" , name = "UriClipAsset" })
-- throws : True
-- Skip return : False

foreign import ccall "ges_uri_clip_asset_request_sync" ges_uri_clip_asset_request_sync :: 
    CString ->                              -- uri : TBasicType TUTF8
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr UriClipAsset)

-- | Creates a t'GI.GES.Objects.UriClipAsset.UriClipAsset' for /@uri@/ syncronously. You should avoid
-- to use it in application, and rather create t'GI.GES.Objects.UriClipAsset.UriClipAsset' asynchronously
uriClipAssetRequestSync ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    T.Text
    -- ^ /@uri@/: The URI of the file for which to create a t'GI.GES.Objects.UriClipAsset.UriClipAsset'.
    -- You can also use multi file uris for t'GI.GES.Objects.MultiFileSource.MultiFileSource'.
    -> m UriClipAsset
    -- ^ __Returns:__ A reference to the requested asset or 'P.Nothing' if
    -- an error happened /(Can throw 'Data.GI.Base.GError.GError')/
uriClipAssetRequestSync :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> m UriClipAsset
uriClipAssetRequestSync Text
uri = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
    CString
uri' <- Text -> IO CString
textToCString Text
uri
    forall a b. IO a -> IO b -> IO a
onException (do
        Ptr UriClipAsset
result <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ CString -> Ptr (Ptr GError) -> IO (Ptr UriClipAsset)
ges_uri_clip_asset_request_sync CString
uri'
        forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"uriClipAssetRequestSync" Ptr UriClipAsset
result
        UriClipAsset
result' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr UriClipAsset -> UriClipAsset
UriClipAsset) Ptr UriClipAsset
result
        forall a. Ptr a -> IO ()
freeMem CString
uri'
        forall (m :: * -> *) a. Monad m => a -> m a
return UriClipAsset
result'
     ) (do
        forall a. Ptr a -> IO ()
freeMem CString
uri'
     )

#if defined(ENABLE_OVERLOADING)
#endif