{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- Structure describing the t'GI.Gst.Structs.StaticPadTemplate.StaticPadTemplate'.

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

module GI.Gst.Structs.StaticPadTemplate
    ( 

-- * Exported types
    StaticPadTemplate(..)                   ,
    newZeroStaticPadTemplate                ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [get]("GI.Gst.Structs.StaticPadTemplate#g:method:get").
-- 
-- ==== Getters
-- [getCaps]("GI.Gst.Structs.StaticPadTemplate#g:method:getCaps").
-- 
-- ==== Setters
-- /None/.

#if defined(ENABLE_OVERLOADING)
    ResolveStaticPadTemplateMethod          ,
#endif

-- ** get #method:get#

#if defined(ENABLE_OVERLOADING)
    StaticPadTemplateGetMethodInfo          ,
#endif
    staticPadTemplateGet                    ,


-- ** getCaps #method:getCaps#

#if defined(ENABLE_OVERLOADING)
    StaticPadTemplateGetCapsMethodInfo      ,
#endif
    staticPadTemplateGetCaps                ,




 -- * Properties


-- ** direction #attr:direction#
-- | the direction of the template

    getStaticPadTemplateDirection           ,
    setStaticPadTemplateDirection           ,
#if defined(ENABLE_OVERLOADING)
    staticPadTemplate_direction             ,
#endif


-- ** nameTemplate #attr:nameTemplate#
-- | the name of the template

    clearStaticPadTemplateNameTemplate      ,
    getStaticPadTemplateNameTemplate        ,
    setStaticPadTemplateNameTemplate        ,
#if defined(ENABLE_OVERLOADING)
    staticPadTemplate_nameTemplate          ,
#endif


-- ** presence #attr:presence#
-- | the presence of the template

    getStaticPadTemplatePresence            ,
    setStaticPadTemplatePresence            ,
#if defined(ENABLE_OVERLOADING)
    staticPadTemplate_presence              ,
#endif


-- ** staticCaps #attr:staticCaps#
-- | the caps of the template.

    getStaticPadTemplateStaticCaps          ,
#if defined(ENABLE_OVERLOADING)
    staticPadTemplate_staticCaps            ,
#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.Kind as DK
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 qualified Data.Word as DW
import qualified Data.Int as DI
import qualified System.Posix.Types as SPT
import qualified Foreign.C.Types as FCT

-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392
#if MIN_VERSION_base(4,18,0)
import qualified GI.GLib.Callbacks as GLib.Callbacks
import qualified GI.GLib.Structs.Bytes as GLib.Bytes
import qualified GI.GLib.Structs.Date as GLib.Date
import qualified GI.GLib.Structs.DateTime as GLib.DateTime
import qualified GI.GLib.Structs.PollFD as GLib.PollFD
import qualified GI.GLib.Structs.Source as GLib.Source
import qualified GI.GLib.Unions.Mutex as GLib.Mutex
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.GObject.Structs.ValueArray as GObject.ValueArray
import qualified GI.Gst.Callbacks as Gst.Callbacks
import {-# SOURCE #-} qualified GI.Gst.Enums as Gst.Enums
import {-# SOURCE #-} qualified GI.Gst.Flags as Gst.Flags
import {-# SOURCE #-} qualified GI.Gst.Objects.Allocator as Gst.Allocator
import {-# SOURCE #-} qualified GI.Gst.Objects.BufferPool as Gst.BufferPool
import {-# SOURCE #-} qualified GI.Gst.Objects.Bus as Gst.Bus
import {-# SOURCE #-} qualified GI.Gst.Objects.Clock as Gst.Clock
import {-# SOURCE #-} qualified GI.Gst.Objects.ControlBinding as Gst.ControlBinding
import {-# SOURCE #-} qualified GI.Gst.Objects.Device as Gst.Device
import {-# SOURCE #-} qualified GI.Gst.Objects.Element as Gst.Element
import {-# SOURCE #-} qualified GI.Gst.Objects.ElementFactory as Gst.ElementFactory
import {-# SOURCE #-} qualified GI.Gst.Objects.Object as Gst.Object
import {-# SOURCE #-} qualified GI.Gst.Objects.Pad as Gst.Pad
import {-# SOURCE #-} qualified GI.Gst.Objects.PadTemplate as Gst.PadTemplate
import {-# SOURCE #-} qualified GI.Gst.Objects.Plugin as Gst.Plugin
import {-# SOURCE #-} qualified GI.Gst.Objects.PluginFeature as Gst.PluginFeature
import {-# SOURCE #-} qualified GI.Gst.Objects.Stream as Gst.Stream
import {-# SOURCE #-} qualified GI.Gst.Objects.StreamCollection as Gst.StreamCollection
import {-# SOURCE #-} qualified GI.Gst.Structs.AllocationParams as Gst.AllocationParams
import {-# SOURCE #-} qualified GI.Gst.Structs.Buffer as Gst.Buffer
import {-# SOURCE #-} qualified GI.Gst.Structs.BufferList as Gst.BufferList
import {-# SOURCE #-} qualified GI.Gst.Structs.BufferPoolAcquireParams as Gst.BufferPoolAcquireParams
import {-# SOURCE #-} qualified GI.Gst.Structs.ByteArrayInterface as Gst.ByteArrayInterface
import {-# SOURCE #-} qualified GI.Gst.Structs.Caps as Gst.Caps
import {-# SOURCE #-} qualified GI.Gst.Structs.CapsFeatures as Gst.CapsFeatures
import {-# SOURCE #-} qualified GI.Gst.Structs.Context as Gst.Context
import {-# SOURCE #-} qualified GI.Gst.Structs.CustomMeta as Gst.CustomMeta
import {-# SOURCE #-} qualified GI.Gst.Structs.DateTime as Gst.DateTime
import {-# SOURCE #-} qualified GI.Gst.Structs.Event as Gst.Event
import {-# SOURCE #-} qualified GI.Gst.Structs.Iterator as Gst.Iterator
import {-# SOURCE #-} qualified GI.Gst.Structs.MapInfo as Gst.MapInfo
import {-# SOURCE #-} qualified GI.Gst.Structs.Memory as Gst.Memory
import {-# SOURCE #-} qualified GI.Gst.Structs.Message as Gst.Message
import {-# SOURCE #-} qualified GI.Gst.Structs.Meta as Gst.Meta
import {-# SOURCE #-} qualified GI.Gst.Structs.MetaInfo as Gst.MetaInfo
import {-# SOURCE #-} qualified GI.Gst.Structs.MiniObject as Gst.MiniObject
import {-# SOURCE #-} qualified GI.Gst.Structs.ParentBufferMeta as Gst.ParentBufferMeta
import {-# SOURCE #-} qualified GI.Gst.Structs.ProtectionMeta as Gst.ProtectionMeta
import {-# SOURCE #-} qualified GI.Gst.Structs.Query as Gst.Query
import {-# SOURCE #-} qualified GI.Gst.Structs.ReferenceTimestampMeta as Gst.ReferenceTimestampMeta
import {-# SOURCE #-} qualified GI.Gst.Structs.Sample as Gst.Sample
import {-# SOURCE #-} qualified GI.Gst.Structs.Segment as Gst.Segment
import {-# SOURCE #-} qualified GI.Gst.Structs.StaticCaps as Gst.StaticCaps
import {-# SOURCE #-} qualified GI.Gst.Structs.Structure as Gst.Structure
import {-# SOURCE #-} qualified GI.Gst.Structs.TagList as Gst.TagList
import {-# SOURCE #-} qualified GI.Gst.Structs.Toc as Gst.Toc
import {-# SOURCE #-} qualified GI.Gst.Structs.TocEntry as Gst.TocEntry

#else
import {-# SOURCE #-} qualified GI.Gst.Enums as Gst.Enums
import {-# SOURCE #-} qualified GI.Gst.Objects.PadTemplate as Gst.PadTemplate
import {-# SOURCE #-} qualified GI.Gst.Structs.Caps as Gst.Caps
import {-# SOURCE #-} qualified GI.Gst.Structs.StaticCaps as Gst.StaticCaps

#endif

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

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

instance BoxedPtr StaticPadTemplate where
    boxedPtrCopy :: StaticPadTemplate -> IO StaticPadTemplate
boxedPtrCopy = \StaticPadTemplate
p -> StaticPadTemplate
-> (Ptr StaticPadTemplate -> IO StaticPadTemplate)
-> IO StaticPadTemplate
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr StaticPadTemplate
p (Int -> Ptr StaticPadTemplate -> IO (Ptr StaticPadTemplate)
forall a. (HasCallStack, CallocPtr a) => Int -> Ptr a -> IO (Ptr a)
copyBytes Int
64 (Ptr StaticPadTemplate -> IO (Ptr StaticPadTemplate))
-> (Ptr StaticPadTemplate -> IO StaticPadTemplate)
-> Ptr StaticPadTemplate
-> IO StaticPadTemplate
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (ManagedPtr StaticPadTemplate -> StaticPadTemplate)
-> Ptr StaticPadTemplate -> IO StaticPadTemplate
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.wrapPtr ManagedPtr StaticPadTemplate -> StaticPadTemplate
StaticPadTemplate)
    boxedPtrFree :: StaticPadTemplate -> IO ()
boxedPtrFree = \StaticPadTemplate
x -> StaticPadTemplate -> (Ptr StaticPadTemplate -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
SP.withManagedPtr StaticPadTemplate
x Ptr StaticPadTemplate -> IO ()
forall a. Ptr a -> IO ()
SP.freeMem
instance CallocPtr StaticPadTemplate where
    boxedPtrCalloc :: IO (Ptr StaticPadTemplate)
boxedPtrCalloc = Int -> IO (Ptr StaticPadTemplate)
forall a. Int -> IO (Ptr a)
callocBytes Int
64


-- | Construct a `StaticPadTemplate` struct initialized to zero.
newZeroStaticPadTemplate :: MonadIO m => m StaticPadTemplate
newZeroStaticPadTemplate :: forall (m :: * -> *). MonadIO m => m StaticPadTemplate
newZeroStaticPadTemplate = IO StaticPadTemplate -> m StaticPadTemplate
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO StaticPadTemplate -> m StaticPadTemplate)
-> IO StaticPadTemplate -> m StaticPadTemplate
forall a b. (a -> b) -> a -> b
$ IO (Ptr StaticPadTemplate)
forall a. CallocPtr a => IO (Ptr a)
boxedPtrCalloc IO (Ptr StaticPadTemplate)
-> (Ptr StaticPadTemplate -> IO StaticPadTemplate)
-> IO StaticPadTemplate
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr StaticPadTemplate -> StaticPadTemplate)
-> Ptr StaticPadTemplate -> IO StaticPadTemplate
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr StaticPadTemplate -> StaticPadTemplate
StaticPadTemplate

instance tag ~ 'AttrSet => Constructible StaticPadTemplate tag where
    new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr StaticPadTemplate -> StaticPadTemplate)
-> [AttrOp StaticPadTemplate tag] -> m StaticPadTemplate
new ManagedPtr StaticPadTemplate -> StaticPadTemplate
_ [AttrOp StaticPadTemplate tag]
attrs = do
        StaticPadTemplate
o <- m StaticPadTemplate
forall (m :: * -> *). MonadIO m => m StaticPadTemplate
newZeroStaticPadTemplate
        StaticPadTemplate -> [AttrOp StaticPadTemplate 'AttrSet] -> m ()
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set StaticPadTemplate
o [AttrOp StaticPadTemplate tag]
[AttrOp StaticPadTemplate 'AttrSet]
attrs
        StaticPadTemplate -> m StaticPadTemplate
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return StaticPadTemplate
o


-- | Get the value of the “@name_template@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' staticPadTemplate #nameTemplate
-- @
getStaticPadTemplateNameTemplate :: MonadIO m => StaticPadTemplate -> m (Maybe T.Text)
getStaticPadTemplateNameTemplate :: forall (m :: * -> *).
MonadIO m =>
StaticPadTemplate -> m (Maybe Text)
getStaticPadTemplateNameTemplate StaticPadTemplate
s = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ StaticPadTemplate
-> (Ptr StaticPadTemplate -> IO (Maybe Text)) -> IO (Maybe Text)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr StaticPadTemplate
s ((Ptr StaticPadTemplate -> IO (Maybe Text)) -> IO (Maybe Text))
-> (Ptr StaticPadTemplate -> IO (Maybe Text)) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \Ptr StaticPadTemplate
ptr -> do
    CString
val <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek (Ptr StaticPadTemplate
ptr Ptr StaticPadTemplate -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) :: IO CString
    Maybe Text
result <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull CString
val ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
val' -> do
        Text
val'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
val'
        Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
val''
    Maybe Text -> IO (Maybe Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
result

-- | Set the value of the “@name_template@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' staticPadTemplate [ #nameTemplate 'Data.GI.Base.Attributes.:=' value ]
-- @
setStaticPadTemplateNameTemplate :: MonadIO m => StaticPadTemplate -> CString -> m ()
setStaticPadTemplateNameTemplate :: forall (m :: * -> *).
MonadIO m =>
StaticPadTemplate -> CString -> m ()
setStaticPadTemplateNameTemplate StaticPadTemplate
s CString
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ StaticPadTemplate -> (Ptr StaticPadTemplate -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr StaticPadTemplate
s ((Ptr StaticPadTemplate -> IO ()) -> IO ())
-> (Ptr StaticPadTemplate -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr StaticPadTemplate
ptr -> do
    Ptr CString -> CString -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr StaticPadTemplate
ptr Ptr StaticPadTemplate -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (CString
val :: CString)

-- | Set the value of the “@name_template@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #nameTemplate
-- @
clearStaticPadTemplateNameTemplate :: MonadIO m => StaticPadTemplate -> m ()
clearStaticPadTemplateNameTemplate :: forall (m :: * -> *). MonadIO m => StaticPadTemplate -> m ()
clearStaticPadTemplateNameTemplate StaticPadTemplate
s = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ StaticPadTemplate -> (Ptr StaticPadTemplate -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr StaticPadTemplate
s ((Ptr StaticPadTemplate -> IO ()) -> IO ())
-> (Ptr StaticPadTemplate -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr StaticPadTemplate
ptr -> do
    Ptr CString -> CString -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr StaticPadTemplate
ptr Ptr StaticPadTemplate -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (CString
forall a. Ptr a
FP.nullPtr :: CString)

#if defined(ENABLE_OVERLOADING)
data StaticPadTemplateNameTemplateFieldInfo
instance AttrInfo StaticPadTemplateNameTemplateFieldInfo where
    type AttrBaseTypeConstraint StaticPadTemplateNameTemplateFieldInfo = (~) StaticPadTemplate
    type AttrAllowedOps StaticPadTemplateNameTemplateFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint StaticPadTemplateNameTemplateFieldInfo = (~) CString
    type AttrTransferTypeConstraint StaticPadTemplateNameTemplateFieldInfo = (~)CString
    type AttrTransferType StaticPadTemplateNameTemplateFieldInfo = CString
    type AttrGetType StaticPadTemplateNameTemplateFieldInfo = Maybe T.Text
    type AttrLabel StaticPadTemplateNameTemplateFieldInfo = "name_template"
    type AttrOrigin StaticPadTemplateNameTemplateFieldInfo = StaticPadTemplate
    attrGet = getStaticPadTemplateNameTemplate
    attrSet = setStaticPadTemplateNameTemplate
    attrConstruct = undefined
    attrClear = clearStaticPadTemplateNameTemplate
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gst.Structs.StaticPadTemplate.nameTemplate"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.30/docs/GI-Gst-Structs-StaticPadTemplate.html#g:attr:nameTemplate"
        })

staticPadTemplate_nameTemplate :: AttrLabelProxy "nameTemplate"
staticPadTemplate_nameTemplate = AttrLabelProxy

#endif


-- | Get the value of the “@direction@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' staticPadTemplate #direction
-- @
getStaticPadTemplateDirection :: MonadIO m => StaticPadTemplate -> m Gst.Enums.PadDirection
getStaticPadTemplateDirection :: forall (m :: * -> *).
MonadIO m =>
StaticPadTemplate -> m PadDirection
getStaticPadTemplateDirection StaticPadTemplate
s = IO PadDirection -> m PadDirection
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO PadDirection -> m PadDirection)
-> IO PadDirection -> m PadDirection
forall a b. (a -> b) -> a -> b
$ StaticPadTemplate
-> (Ptr StaticPadTemplate -> IO PadDirection) -> IO PadDirection
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr StaticPadTemplate
s ((Ptr StaticPadTemplate -> IO PadDirection) -> IO PadDirection)
-> (Ptr StaticPadTemplate -> IO PadDirection) -> IO PadDirection
forall a b. (a -> b) -> a -> b
$ \Ptr StaticPadTemplate
ptr -> do
    CUInt
val <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek (Ptr StaticPadTemplate
ptr Ptr StaticPadTemplate -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) :: IO CUInt
    let val' :: PadDirection
val' = (Int -> PadDirection
forall a. Enum a => Int -> a
toEnum (Int -> PadDirection) -> (CUInt -> Int) -> CUInt -> PadDirection
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
val
    PadDirection -> IO PadDirection
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return PadDirection
val'

-- | Set the value of the “@direction@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' staticPadTemplate [ #direction 'Data.GI.Base.Attributes.:=' value ]
-- @
setStaticPadTemplateDirection :: MonadIO m => StaticPadTemplate -> Gst.Enums.PadDirection -> m ()
setStaticPadTemplateDirection :: forall (m :: * -> *).
MonadIO m =>
StaticPadTemplate -> PadDirection -> m ()
setStaticPadTemplateDirection StaticPadTemplate
s PadDirection
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ StaticPadTemplate -> (Ptr StaticPadTemplate -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr StaticPadTemplate
s ((Ptr StaticPadTemplate -> IO ()) -> IO ())
-> (Ptr StaticPadTemplate -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr StaticPadTemplate
ptr -> do
    let val' :: CUInt
val' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (PadDirection -> Int) -> PadDirection -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PadDirection -> Int
forall a. Enum a => a -> Int
fromEnum) PadDirection
val
    Ptr CUInt -> CUInt -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr StaticPadTemplate
ptr Ptr StaticPadTemplate -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (CUInt
val' :: CUInt)

#if defined(ENABLE_OVERLOADING)
data StaticPadTemplateDirectionFieldInfo
instance AttrInfo StaticPadTemplateDirectionFieldInfo where
    type AttrBaseTypeConstraint StaticPadTemplateDirectionFieldInfo = (~) StaticPadTemplate
    type AttrAllowedOps StaticPadTemplateDirectionFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint StaticPadTemplateDirectionFieldInfo = (~) Gst.Enums.PadDirection
    type AttrTransferTypeConstraint StaticPadTemplateDirectionFieldInfo = (~)Gst.Enums.PadDirection
    type AttrTransferType StaticPadTemplateDirectionFieldInfo = Gst.Enums.PadDirection
    type AttrGetType StaticPadTemplateDirectionFieldInfo = Gst.Enums.PadDirection
    type AttrLabel StaticPadTemplateDirectionFieldInfo = "direction"
    type AttrOrigin StaticPadTemplateDirectionFieldInfo = StaticPadTemplate
    attrGet = getStaticPadTemplateDirection
    attrSet = setStaticPadTemplateDirection
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gst.Structs.StaticPadTemplate.direction"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.30/docs/GI-Gst-Structs-StaticPadTemplate.html#g:attr:direction"
        })

staticPadTemplate_direction :: AttrLabelProxy "direction"
staticPadTemplate_direction = AttrLabelProxy

#endif


-- | Get the value of the “@presence@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' staticPadTemplate #presence
-- @
getStaticPadTemplatePresence :: MonadIO m => StaticPadTemplate -> m Gst.Enums.PadPresence
getStaticPadTemplatePresence :: forall (m :: * -> *).
MonadIO m =>
StaticPadTemplate -> m PadPresence
getStaticPadTemplatePresence StaticPadTemplate
s = IO PadPresence -> m PadPresence
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO PadPresence -> m PadPresence)
-> IO PadPresence -> m PadPresence
forall a b. (a -> b) -> a -> b
$ StaticPadTemplate
-> (Ptr StaticPadTemplate -> IO PadPresence) -> IO PadPresence
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr StaticPadTemplate
s ((Ptr StaticPadTemplate -> IO PadPresence) -> IO PadPresence)
-> (Ptr StaticPadTemplate -> IO PadPresence) -> IO PadPresence
forall a b. (a -> b) -> a -> b
$ \Ptr StaticPadTemplate
ptr -> do
    CUInt
val <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek (Ptr StaticPadTemplate
ptr Ptr StaticPadTemplate -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
12) :: IO CUInt
    let val' :: PadPresence
val' = (Int -> PadPresence
forall a. Enum a => Int -> a
toEnum (Int -> PadPresence) -> (CUInt -> Int) -> CUInt -> PadPresence
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
val
    PadPresence -> IO PadPresence
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return PadPresence
val'

-- | Set the value of the “@presence@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' staticPadTemplate [ #presence 'Data.GI.Base.Attributes.:=' value ]
-- @
setStaticPadTemplatePresence :: MonadIO m => StaticPadTemplate -> Gst.Enums.PadPresence -> m ()
setStaticPadTemplatePresence :: forall (m :: * -> *).
MonadIO m =>
StaticPadTemplate -> PadPresence -> m ()
setStaticPadTemplatePresence StaticPadTemplate
s PadPresence
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ StaticPadTemplate -> (Ptr StaticPadTemplate -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr StaticPadTemplate
s ((Ptr StaticPadTemplate -> IO ()) -> IO ())
-> (Ptr StaticPadTemplate -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr StaticPadTemplate
ptr -> do
    let val' :: CUInt
val' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (PadPresence -> Int) -> PadPresence -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PadPresence -> Int
forall a. Enum a => a -> Int
fromEnum) PadPresence
val
    Ptr CUInt -> CUInt -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr StaticPadTemplate
ptr Ptr StaticPadTemplate -> Int -> Ptr CUInt
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
12) (CUInt
val' :: CUInt)

#if defined(ENABLE_OVERLOADING)
data StaticPadTemplatePresenceFieldInfo
instance AttrInfo StaticPadTemplatePresenceFieldInfo where
    type AttrBaseTypeConstraint StaticPadTemplatePresenceFieldInfo = (~) StaticPadTemplate
    type AttrAllowedOps StaticPadTemplatePresenceFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint StaticPadTemplatePresenceFieldInfo = (~) Gst.Enums.PadPresence
    type AttrTransferTypeConstraint StaticPadTemplatePresenceFieldInfo = (~)Gst.Enums.PadPresence
    type AttrTransferType StaticPadTemplatePresenceFieldInfo = Gst.Enums.PadPresence
    type AttrGetType StaticPadTemplatePresenceFieldInfo = Gst.Enums.PadPresence
    type AttrLabel StaticPadTemplatePresenceFieldInfo = "presence"
    type AttrOrigin StaticPadTemplatePresenceFieldInfo = StaticPadTemplate
    attrGet = getStaticPadTemplatePresence
    attrSet = setStaticPadTemplatePresence
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gst.Structs.StaticPadTemplate.presence"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.30/docs/GI-Gst-Structs-StaticPadTemplate.html#g:attr:presence"
        })

staticPadTemplate_presence :: AttrLabelProxy "presence"
staticPadTemplate_presence = AttrLabelProxy

#endif


-- | Get the value of the “@static_caps@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' staticPadTemplate #staticCaps
-- @
getStaticPadTemplateStaticCaps :: MonadIO m => StaticPadTemplate -> m Gst.StaticCaps.StaticCaps
getStaticPadTemplateStaticCaps :: forall (m :: * -> *).
MonadIO m =>
StaticPadTemplate -> m StaticCaps
getStaticPadTemplateStaticCaps StaticPadTemplate
s = IO StaticCaps -> m StaticCaps
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO StaticCaps -> m StaticCaps) -> IO StaticCaps -> m StaticCaps
forall a b. (a -> b) -> a -> b
$ StaticPadTemplate
-> (Ptr StaticPadTemplate -> IO StaticCaps) -> IO StaticCaps
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr StaticPadTemplate
s ((Ptr StaticPadTemplate -> IO StaticCaps) -> IO StaticCaps)
-> (Ptr StaticPadTemplate -> IO StaticCaps) -> IO StaticCaps
forall a b. (a -> b) -> a -> b
$ \Ptr StaticPadTemplate
ptr -> do
    let val :: Ptr StaticCaps
val = Ptr StaticPadTemplate
ptr Ptr StaticPadTemplate -> Int -> Ptr StaticCaps
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16 :: (Ptr Gst.StaticCaps.StaticCaps)
    StaticCaps
val' <- ((ManagedPtr StaticCaps -> StaticCaps)
-> Ptr StaticCaps -> IO StaticCaps
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr StaticCaps -> StaticCaps
Gst.StaticCaps.StaticCaps) Ptr StaticCaps
val
    StaticCaps -> IO StaticCaps
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return StaticCaps
val'

#if defined(ENABLE_OVERLOADING)
data StaticPadTemplateStaticCapsFieldInfo
instance AttrInfo StaticPadTemplateStaticCapsFieldInfo where
    type AttrBaseTypeConstraint StaticPadTemplateStaticCapsFieldInfo = (~) StaticPadTemplate
    type AttrAllowedOps StaticPadTemplateStaticCapsFieldInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint StaticPadTemplateStaticCapsFieldInfo = (~) (Ptr Gst.StaticCaps.StaticCaps)
    type AttrTransferTypeConstraint StaticPadTemplateStaticCapsFieldInfo = (~)(Ptr Gst.StaticCaps.StaticCaps)
    type AttrTransferType StaticPadTemplateStaticCapsFieldInfo = (Ptr Gst.StaticCaps.StaticCaps)
    type AttrGetType StaticPadTemplateStaticCapsFieldInfo = Gst.StaticCaps.StaticCaps
    type AttrLabel StaticPadTemplateStaticCapsFieldInfo = "static_caps"
    type AttrOrigin StaticPadTemplateStaticCapsFieldInfo = StaticPadTemplate
    attrGet = getStaticPadTemplateStaticCaps
    attrSet = undefined
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gst.Structs.StaticPadTemplate.staticCaps"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.30/docs/GI-Gst-Structs-StaticPadTemplate.html#g:attr:staticCaps"
        })

staticPadTemplate_staticCaps :: AttrLabelProxy "staticCaps"
staticPadTemplate_staticCaps = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList StaticPadTemplate
type instance O.AttributeList StaticPadTemplate = StaticPadTemplateAttributeList
type StaticPadTemplateAttributeList = ('[ '("nameTemplate", StaticPadTemplateNameTemplateFieldInfo), '("direction", StaticPadTemplateDirectionFieldInfo), '("presence", StaticPadTemplatePresenceFieldInfo), '("staticCaps", StaticPadTemplateStaticCapsFieldInfo)] :: [(Symbol, DK.Type)])
#endif

-- method StaticPadTemplate::get
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "pad_template"
--           , argType =
--               TInterface Name { namespace = "Gst" , name = "StaticPadTemplate" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the static pad template"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gst" , name = "PadTemplate" })
-- throws : False
-- Skip return : False

foreign import ccall "gst_static_pad_template_get" gst_static_pad_template_get :: 
    Ptr StaticPadTemplate ->                -- pad_template : TInterface (Name {namespace = "Gst", name = "StaticPadTemplate"})
    IO (Ptr Gst.PadTemplate.PadTemplate)

-- | Converts a t'GI.Gst.Structs.StaticPadTemplate.StaticPadTemplate' into a t'GI.Gst.Objects.PadTemplate.PadTemplate'.
staticPadTemplateGet ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    StaticPadTemplate
    -- ^ /@padTemplate@/: the static pad template
    -> m (Maybe Gst.PadTemplate.PadTemplate)
    -- ^ __Returns:__ a new t'GI.Gst.Objects.PadTemplate.PadTemplate'.
staticPadTemplateGet :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
StaticPadTemplate -> m (Maybe PadTemplate)
staticPadTemplateGet StaticPadTemplate
padTemplate = IO (Maybe PadTemplate) -> m (Maybe PadTemplate)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe PadTemplate) -> m (Maybe PadTemplate))
-> IO (Maybe PadTemplate) -> m (Maybe PadTemplate)
forall a b. (a -> b) -> a -> b
$ do
    Ptr StaticPadTemplate
padTemplate' <- StaticPadTemplate -> IO (Ptr StaticPadTemplate)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr StaticPadTemplate
padTemplate
    Ptr PadTemplate
result <- Ptr StaticPadTemplate -> IO (Ptr PadTemplate)
gst_static_pad_template_get Ptr StaticPadTemplate
padTemplate'
    Maybe PadTemplate
maybeResult <- Ptr PadTemplate
-> (Ptr PadTemplate -> IO PadTemplate) -> IO (Maybe PadTemplate)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr PadTemplate
result ((Ptr PadTemplate -> IO PadTemplate) -> IO (Maybe PadTemplate))
-> (Ptr PadTemplate -> IO PadTemplate) -> IO (Maybe PadTemplate)
forall a b. (a -> b) -> a -> b
$ \Ptr PadTemplate
result' -> do
        PadTemplate
result'' <- ((ManagedPtr PadTemplate -> PadTemplate)
-> Ptr PadTemplate -> IO PadTemplate
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr PadTemplate -> PadTemplate
Gst.PadTemplate.PadTemplate) Ptr PadTemplate
result'
        PadTemplate -> IO PadTemplate
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return PadTemplate
result''
    StaticPadTemplate -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr StaticPadTemplate
padTemplate
    Maybe PadTemplate -> IO (Maybe PadTemplate)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe PadTemplate
maybeResult

#if defined(ENABLE_OVERLOADING)
data StaticPadTemplateGetMethodInfo
instance (signature ~ (m (Maybe Gst.PadTemplate.PadTemplate)), MonadIO m) => O.OverloadedMethod StaticPadTemplateGetMethodInfo StaticPadTemplate signature where
    overloadedMethod = staticPadTemplateGet

instance O.OverloadedMethodInfo StaticPadTemplateGetMethodInfo StaticPadTemplate where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gst.Structs.StaticPadTemplate.staticPadTemplateGet",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.30/docs/GI-Gst-Structs-StaticPadTemplate.html#v:staticPadTemplateGet"
        })


#endif

-- method StaticPadTemplate::get_caps
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "templ"
--           , argType =
--               TInterface Name { namespace = "Gst" , name = "StaticPadTemplate" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a #GstStaticPadTemplate to get capabilities of."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gst" , name = "Caps" })
-- throws : False
-- Skip return : False

foreign import ccall "gst_static_pad_template_get_caps" gst_static_pad_template_get_caps :: 
    Ptr StaticPadTemplate ->                -- templ : TInterface (Name {namespace = "Gst", name = "StaticPadTemplate"})
    IO (Ptr Gst.Caps.Caps)

-- | Gets the capabilities of the static pad template.
staticPadTemplateGetCaps ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    StaticPadTemplate
    -- ^ /@templ@/: a t'GI.Gst.Structs.StaticPadTemplate.StaticPadTemplate' to get capabilities of.
    -> m Gst.Caps.Caps
    -- ^ __Returns:__ the t'GI.Gst.Structs.Caps.Caps' of the static pad template.
    -- Unref after usage. Since the core holds an additional
    -- ref to the returned caps, use @/gst_caps_make_writable()/@
    -- on the returned caps to modify it.
staticPadTemplateGetCaps :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
StaticPadTemplate -> m Caps
staticPadTemplateGetCaps StaticPadTemplate
templ = IO Caps -> m Caps
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Caps -> m Caps) -> IO Caps -> m Caps
forall a b. (a -> b) -> a -> b
$ do
    Ptr StaticPadTemplate
templ' <- StaticPadTemplate -> IO (Ptr StaticPadTemplate)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr StaticPadTemplate
templ
    Ptr Caps
result <- Ptr StaticPadTemplate -> IO (Ptr Caps)
gst_static_pad_template_get_caps Ptr StaticPadTemplate
templ'
    Text -> Ptr Caps -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"staticPadTemplateGetCaps" Ptr Caps
result
    Caps
result' <- ((ManagedPtr Caps -> Caps) -> Ptr Caps -> IO Caps
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Caps -> Caps
Gst.Caps.Caps) Ptr Caps
result
    StaticPadTemplate -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr StaticPadTemplate
templ
    Caps -> IO Caps
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Caps
result'

#if defined(ENABLE_OVERLOADING)
data StaticPadTemplateGetCapsMethodInfo
instance (signature ~ (m Gst.Caps.Caps), MonadIO m) => O.OverloadedMethod StaticPadTemplateGetCapsMethodInfo StaticPadTemplate signature where
    overloadedMethod = staticPadTemplateGetCaps

instance O.OverloadedMethodInfo StaticPadTemplateGetCapsMethodInfo StaticPadTemplate where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Gst.Structs.StaticPadTemplate.staticPadTemplateGetCaps",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gst-1.0.30/docs/GI-Gst-Structs-StaticPadTemplate.html#v:staticPadTemplateGetCaps"
        })


#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveStaticPadTemplateMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
    ResolveStaticPadTemplateMethod "get" o = StaticPadTemplateGetMethodInfo
    ResolveStaticPadTemplateMethod "getCaps" o = StaticPadTemplateGetCapsMethodInfo
    ResolveStaticPadTemplateMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveStaticPadTemplateMethod t StaticPadTemplate, O.OverloadedMethod info StaticPadTemplate p) => OL.IsLabel t (StaticPadTemplate -> 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 ~ ResolveStaticPadTemplateMethod t StaticPadTemplate, O.OverloadedMethod info StaticPadTemplate p, R.HasField t StaticPadTemplate p) => R.HasField t StaticPadTemplate p where
    getField = O.overloadedMethod @info

#endif

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

#endif