{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- A representation of a difference between two t'GI.GstVideo.Structs.VideoTimeCode.VideoTimeCode' instances.
-- Will not necessarily correspond to a real timecode (e.g. 00:00:10;00)
-- 
-- /Since: 1.12/

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

module GI.GstVideo.Structs.VideoTimeCodeInterval
    ( 

-- * Exported types
    VideoTimeCodeInterval(..)               ,
    newZeroVideoTimeCodeInterval            ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [clear]("GI.GstVideo.Structs.VideoTimeCodeInterval#g:method:clear"), [copy]("GI.GstVideo.Structs.VideoTimeCodeInterval#g:method:copy"), [free]("GI.GstVideo.Structs.VideoTimeCodeInterval#g:method:free"), [init]("GI.GstVideo.Structs.VideoTimeCodeInterval#g:method:init").
-- 
-- ==== Getters
-- /None/.
-- 
-- ==== Setters
-- /None/.

#if defined(ENABLE_OVERLOADING)
    ResolveVideoTimeCodeIntervalMethod      ,
#endif

-- ** clear #method:clear#

#if defined(ENABLE_OVERLOADING)
    VideoTimeCodeIntervalClearMethodInfo    ,
#endif
    videoTimeCodeIntervalClear              ,


-- ** copy #method:copy#

#if defined(ENABLE_OVERLOADING)
    VideoTimeCodeIntervalCopyMethodInfo     ,
#endif
    videoTimeCodeIntervalCopy               ,


-- ** free #method:free#

#if defined(ENABLE_OVERLOADING)
    VideoTimeCodeIntervalFreeMethodInfo     ,
#endif
    videoTimeCodeIntervalFree               ,


-- ** init #method:init#

#if defined(ENABLE_OVERLOADING)
    VideoTimeCodeIntervalInitMethodInfo     ,
#endif
    videoTimeCodeIntervalInit               ,


-- ** new #method:new#

    videoTimeCodeIntervalNew                ,


-- ** newFromString #method:newFromString#

    videoTimeCodeIntervalNewFromString      ,




 -- * Properties


-- ** frames #attr:frames#
-- | the frames field of t'GI.GstVideo.Structs.VideoTimeCodeInterval.VideoTimeCodeInterval'

    getVideoTimeCodeIntervalFrames          ,
    setVideoTimeCodeIntervalFrames          ,
#if defined(ENABLE_OVERLOADING)
    videoTimeCodeInterval_frames            ,
#endif


-- ** hours #attr:hours#
-- | the hours field of t'GI.GstVideo.Structs.VideoTimeCodeInterval.VideoTimeCodeInterval'

    getVideoTimeCodeIntervalHours           ,
    setVideoTimeCodeIntervalHours           ,
#if defined(ENABLE_OVERLOADING)
    videoTimeCodeInterval_hours             ,
#endif


-- ** minutes #attr:minutes#
-- | the minutes field of t'GI.GstVideo.Structs.VideoTimeCodeInterval.VideoTimeCodeInterval'

    getVideoTimeCodeIntervalMinutes         ,
    setVideoTimeCodeIntervalMinutes         ,
#if defined(ENABLE_OVERLOADING)
    videoTimeCodeInterval_minutes           ,
#endif


-- ** seconds #attr:seconds#
-- | the seconds field of t'GI.GstVideo.Structs.VideoTimeCodeInterval.VideoTimeCodeInterval'

    getVideoTimeCodeIntervalSeconds         ,
    setVideoTimeCodeIntervalSeconds         ,
#if defined(ENABLE_OVERLOADING)
    videoTimeCodeInterval_seconds           ,
#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)

#else

#endif

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

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

foreign import ccall "gst_video_time_code_interval_get_type" c_gst_video_time_code_interval_get_type :: 
    IO GType

type instance O.ParentTypes VideoTimeCodeInterval = '[]
instance O.HasParentTypes VideoTimeCodeInterval

instance B.Types.TypedObject VideoTimeCodeInterval where
    glibType :: IO GType
glibType = IO GType
c_gst_video_time_code_interval_get_type

instance B.Types.GBoxed VideoTimeCodeInterval

-- | Convert 'VideoTimeCodeInterval' 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 VideoTimeCodeInterval) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_gst_video_time_code_interval_get_type
    gvalueSet_ :: Ptr GValue -> Maybe VideoTimeCodeInterval -> IO ()
gvalueSet_ Ptr GValue
gv Maybe VideoTimeCodeInterval
P.Nothing = Ptr GValue -> Ptr VideoTimeCodeInterval -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv (Ptr VideoTimeCodeInterval
forall a. Ptr a
FP.nullPtr :: FP.Ptr VideoTimeCodeInterval)
    gvalueSet_ Ptr GValue
gv (P.Just VideoTimeCodeInterval
obj) = VideoTimeCodeInterval
-> (Ptr VideoTimeCodeInterval -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr VideoTimeCodeInterval
obj (Ptr GValue -> Ptr VideoTimeCodeInterval -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe VideoTimeCodeInterval)
gvalueGet_ Ptr GValue
gv = do
        Ptr VideoTimeCodeInterval
ptr <- Ptr GValue -> IO (Ptr VideoTimeCodeInterval)
forall b. Ptr GValue -> IO (Ptr b)
B.GValue.get_boxed Ptr GValue
gv :: IO (Ptr VideoTimeCodeInterval)
        if Ptr VideoTimeCodeInterval
ptr Ptr VideoTimeCodeInterval -> Ptr VideoTimeCodeInterval -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr VideoTimeCodeInterval
forall a. Ptr a
FP.nullPtr
        then VideoTimeCodeInterval -> Maybe VideoTimeCodeInterval
forall a. a -> Maybe a
P.Just (VideoTimeCodeInterval -> Maybe VideoTimeCodeInterval)
-> IO VideoTimeCodeInterval -> IO (Maybe VideoTimeCodeInterval)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr VideoTimeCodeInterval -> VideoTimeCodeInterval)
-> Ptr VideoTimeCodeInterval -> IO VideoTimeCodeInterval
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr VideoTimeCodeInterval -> VideoTimeCodeInterval
VideoTimeCodeInterval Ptr VideoTimeCodeInterval
ptr
        else Maybe VideoTimeCodeInterval -> IO (Maybe VideoTimeCodeInterval)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe VideoTimeCodeInterval
forall a. Maybe a
P.Nothing
        
    

-- | Construct a `VideoTimeCodeInterval` struct initialized to zero.
newZeroVideoTimeCodeInterval :: MonadIO m => m VideoTimeCodeInterval
newZeroVideoTimeCodeInterval :: forall (m :: * -> *). MonadIO m => m VideoTimeCodeInterval
newZeroVideoTimeCodeInterval = IO VideoTimeCodeInterval -> m VideoTimeCodeInterval
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO VideoTimeCodeInterval -> m VideoTimeCodeInterval)
-> IO VideoTimeCodeInterval -> m VideoTimeCodeInterval
forall a b. (a -> b) -> a -> b
$ Int -> IO (Ptr VideoTimeCodeInterval)
forall a. GBoxed a => Int -> IO (Ptr a)
callocBoxedBytes Int
16 IO (Ptr VideoTimeCodeInterval)
-> (Ptr VideoTimeCodeInterval -> IO VideoTimeCodeInterval)
-> IO VideoTimeCodeInterval
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr VideoTimeCodeInterval -> VideoTimeCodeInterval)
-> Ptr VideoTimeCodeInterval -> IO VideoTimeCodeInterval
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr VideoTimeCodeInterval -> VideoTimeCodeInterval
VideoTimeCodeInterval

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


-- | Get the value of the “@hours@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' videoTimeCodeInterval #hours
-- @
getVideoTimeCodeIntervalHours :: MonadIO m => VideoTimeCodeInterval -> m Word32
getVideoTimeCodeIntervalHours :: forall (m :: * -> *).
MonadIO m =>
VideoTimeCodeInterval -> m Word32
getVideoTimeCodeIntervalHours VideoTimeCodeInterval
s = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ VideoTimeCodeInterval
-> (Ptr VideoTimeCodeInterval -> IO Word32) -> IO Word32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoTimeCodeInterval
s ((Ptr VideoTimeCodeInterval -> IO Word32) -> IO Word32)
-> (Ptr VideoTimeCodeInterval -> IO Word32) -> IO Word32
forall a b. (a -> b) -> a -> b
$ \Ptr VideoTimeCodeInterval
ptr -> do
    Word32
val <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek (Ptr VideoTimeCodeInterval
ptr Ptr VideoTimeCodeInterval -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) :: IO Word32
    Word32 -> IO Word32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
val

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

#if defined(ENABLE_OVERLOADING)
data VideoTimeCodeIntervalHoursFieldInfo
instance AttrInfo VideoTimeCodeIntervalHoursFieldInfo where
    type AttrBaseTypeConstraint VideoTimeCodeIntervalHoursFieldInfo = (~) VideoTimeCodeInterval
    type AttrAllowedOps VideoTimeCodeIntervalHoursFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint VideoTimeCodeIntervalHoursFieldInfo = (~) Word32
    type AttrTransferTypeConstraint VideoTimeCodeIntervalHoursFieldInfo = (~)Word32
    type AttrTransferType VideoTimeCodeIntervalHoursFieldInfo = Word32
    type AttrGetType VideoTimeCodeIntervalHoursFieldInfo = Word32
    type AttrLabel VideoTimeCodeIntervalHoursFieldInfo = "hours"
    type AttrOrigin VideoTimeCodeIntervalHoursFieldInfo = VideoTimeCodeInterval
    attrGet = getVideoTimeCodeIntervalHours
    attrSet = setVideoTimeCodeIntervalHours
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GstVideo.Structs.VideoTimeCodeInterval.hours"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gstvideo-1.0.29/docs/GI-GstVideo-Structs-VideoTimeCodeInterval.html#g:attr:hours"
        })

videoTimeCodeInterval_hours :: AttrLabelProxy "hours"
videoTimeCodeInterval_hours = AttrLabelProxy

#endif


-- | Get the value of the “@minutes@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' videoTimeCodeInterval #minutes
-- @
getVideoTimeCodeIntervalMinutes :: MonadIO m => VideoTimeCodeInterval -> m Word32
getVideoTimeCodeIntervalMinutes :: forall (m :: * -> *).
MonadIO m =>
VideoTimeCodeInterval -> m Word32
getVideoTimeCodeIntervalMinutes VideoTimeCodeInterval
s = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ VideoTimeCodeInterval
-> (Ptr VideoTimeCodeInterval -> IO Word32) -> IO Word32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoTimeCodeInterval
s ((Ptr VideoTimeCodeInterval -> IO Word32) -> IO Word32)
-> (Ptr VideoTimeCodeInterval -> IO Word32) -> IO Word32
forall a b. (a -> b) -> a -> b
$ \Ptr VideoTimeCodeInterval
ptr -> do
    Word32
val <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek (Ptr VideoTimeCodeInterval
ptr Ptr VideoTimeCodeInterval -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
4) :: IO Word32
    Word32 -> IO Word32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
val

-- | Set the value of the “@minutes@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' videoTimeCodeInterval [ #minutes 'Data.GI.Base.Attributes.:=' value ]
-- @
setVideoTimeCodeIntervalMinutes :: MonadIO m => VideoTimeCodeInterval -> Word32 -> m ()
setVideoTimeCodeIntervalMinutes :: forall (m :: * -> *).
MonadIO m =>
VideoTimeCodeInterval -> Word32 -> m ()
setVideoTimeCodeIntervalMinutes VideoTimeCodeInterval
s Word32
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
$ VideoTimeCodeInterval
-> (Ptr VideoTimeCodeInterval -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoTimeCodeInterval
s ((Ptr VideoTimeCodeInterval -> IO ()) -> IO ())
-> (Ptr VideoTimeCodeInterval -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr VideoTimeCodeInterval
ptr -> do
    Ptr Word32 -> Word32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr VideoTimeCodeInterval
ptr Ptr VideoTimeCodeInterval -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
4) (Word32
val :: Word32)

#if defined(ENABLE_OVERLOADING)
data VideoTimeCodeIntervalMinutesFieldInfo
instance AttrInfo VideoTimeCodeIntervalMinutesFieldInfo where
    type AttrBaseTypeConstraint VideoTimeCodeIntervalMinutesFieldInfo = (~) VideoTimeCodeInterval
    type AttrAllowedOps VideoTimeCodeIntervalMinutesFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint VideoTimeCodeIntervalMinutesFieldInfo = (~) Word32
    type AttrTransferTypeConstraint VideoTimeCodeIntervalMinutesFieldInfo = (~)Word32
    type AttrTransferType VideoTimeCodeIntervalMinutesFieldInfo = Word32
    type AttrGetType VideoTimeCodeIntervalMinutesFieldInfo = Word32
    type AttrLabel VideoTimeCodeIntervalMinutesFieldInfo = "minutes"
    type AttrOrigin VideoTimeCodeIntervalMinutesFieldInfo = VideoTimeCodeInterval
    attrGet = getVideoTimeCodeIntervalMinutes
    attrSet = setVideoTimeCodeIntervalMinutes
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GstVideo.Structs.VideoTimeCodeInterval.minutes"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gstvideo-1.0.29/docs/GI-GstVideo-Structs-VideoTimeCodeInterval.html#g:attr:minutes"
        })

videoTimeCodeInterval_minutes :: AttrLabelProxy "minutes"
videoTimeCodeInterval_minutes = AttrLabelProxy

#endif


-- | Get the value of the “@seconds@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' videoTimeCodeInterval #seconds
-- @
getVideoTimeCodeIntervalSeconds :: MonadIO m => VideoTimeCodeInterval -> m Word32
getVideoTimeCodeIntervalSeconds :: forall (m :: * -> *).
MonadIO m =>
VideoTimeCodeInterval -> m Word32
getVideoTimeCodeIntervalSeconds VideoTimeCodeInterval
s = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ VideoTimeCodeInterval
-> (Ptr VideoTimeCodeInterval -> IO Word32) -> IO Word32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoTimeCodeInterval
s ((Ptr VideoTimeCodeInterval -> IO Word32) -> IO Word32)
-> (Ptr VideoTimeCodeInterval -> IO Word32) -> IO Word32
forall a b. (a -> b) -> a -> b
$ \Ptr VideoTimeCodeInterval
ptr -> do
    Word32
val <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek (Ptr VideoTimeCodeInterval
ptr Ptr VideoTimeCodeInterval -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) :: IO Word32
    Word32 -> IO Word32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
val

-- | Set the value of the “@seconds@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' videoTimeCodeInterval [ #seconds 'Data.GI.Base.Attributes.:=' value ]
-- @
setVideoTimeCodeIntervalSeconds :: MonadIO m => VideoTimeCodeInterval -> Word32 -> m ()
setVideoTimeCodeIntervalSeconds :: forall (m :: * -> *).
MonadIO m =>
VideoTimeCodeInterval -> Word32 -> m ()
setVideoTimeCodeIntervalSeconds VideoTimeCodeInterval
s Word32
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
$ VideoTimeCodeInterval
-> (Ptr VideoTimeCodeInterval -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoTimeCodeInterval
s ((Ptr VideoTimeCodeInterval -> IO ()) -> IO ())
-> (Ptr VideoTimeCodeInterval -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr VideoTimeCodeInterval
ptr -> do
    Ptr Word32 -> Word32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr VideoTimeCodeInterval
ptr Ptr VideoTimeCodeInterval -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (Word32
val :: Word32)

#if defined(ENABLE_OVERLOADING)
data VideoTimeCodeIntervalSecondsFieldInfo
instance AttrInfo VideoTimeCodeIntervalSecondsFieldInfo where
    type AttrBaseTypeConstraint VideoTimeCodeIntervalSecondsFieldInfo = (~) VideoTimeCodeInterval
    type AttrAllowedOps VideoTimeCodeIntervalSecondsFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint VideoTimeCodeIntervalSecondsFieldInfo = (~) Word32
    type AttrTransferTypeConstraint VideoTimeCodeIntervalSecondsFieldInfo = (~)Word32
    type AttrTransferType VideoTimeCodeIntervalSecondsFieldInfo = Word32
    type AttrGetType VideoTimeCodeIntervalSecondsFieldInfo = Word32
    type AttrLabel VideoTimeCodeIntervalSecondsFieldInfo = "seconds"
    type AttrOrigin VideoTimeCodeIntervalSecondsFieldInfo = VideoTimeCodeInterval
    attrGet = getVideoTimeCodeIntervalSeconds
    attrSet = setVideoTimeCodeIntervalSeconds
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GstVideo.Structs.VideoTimeCodeInterval.seconds"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gstvideo-1.0.29/docs/GI-GstVideo-Structs-VideoTimeCodeInterval.html#g:attr:seconds"
        })

videoTimeCodeInterval_seconds :: AttrLabelProxy "seconds"
videoTimeCodeInterval_seconds = AttrLabelProxy

#endif


-- | Get the value of the “@frames@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' videoTimeCodeInterval #frames
-- @
getVideoTimeCodeIntervalFrames :: MonadIO m => VideoTimeCodeInterval -> m Word32
getVideoTimeCodeIntervalFrames :: forall (m :: * -> *).
MonadIO m =>
VideoTimeCodeInterval -> m Word32
getVideoTimeCodeIntervalFrames VideoTimeCodeInterval
s = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ VideoTimeCodeInterval
-> (Ptr VideoTimeCodeInterval -> IO Word32) -> IO Word32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoTimeCodeInterval
s ((Ptr VideoTimeCodeInterval -> IO Word32) -> IO Word32)
-> (Ptr VideoTimeCodeInterval -> IO Word32) -> IO Word32
forall a b. (a -> b) -> a -> b
$ \Ptr VideoTimeCodeInterval
ptr -> do
    Word32
val <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek (Ptr VideoTimeCodeInterval
ptr Ptr VideoTimeCodeInterval -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
12) :: IO Word32
    Word32 -> IO Word32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
val

-- | Set the value of the “@frames@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' videoTimeCodeInterval [ #frames 'Data.GI.Base.Attributes.:=' value ]
-- @
setVideoTimeCodeIntervalFrames :: MonadIO m => VideoTimeCodeInterval -> Word32 -> m ()
setVideoTimeCodeIntervalFrames :: forall (m :: * -> *).
MonadIO m =>
VideoTimeCodeInterval -> Word32 -> m ()
setVideoTimeCodeIntervalFrames VideoTimeCodeInterval
s Word32
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
$ VideoTimeCodeInterval
-> (Ptr VideoTimeCodeInterval -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr VideoTimeCodeInterval
s ((Ptr VideoTimeCodeInterval -> IO ()) -> IO ())
-> (Ptr VideoTimeCodeInterval -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr VideoTimeCodeInterval
ptr -> do
    Ptr Word32 -> Word32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr VideoTimeCodeInterval
ptr Ptr VideoTimeCodeInterval -> Int -> Ptr Word32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
12) (Word32
val :: Word32)

#if defined(ENABLE_OVERLOADING)
data VideoTimeCodeIntervalFramesFieldInfo
instance AttrInfo VideoTimeCodeIntervalFramesFieldInfo where
    type AttrBaseTypeConstraint VideoTimeCodeIntervalFramesFieldInfo = (~) VideoTimeCodeInterval
    type AttrAllowedOps VideoTimeCodeIntervalFramesFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint VideoTimeCodeIntervalFramesFieldInfo = (~) Word32
    type AttrTransferTypeConstraint VideoTimeCodeIntervalFramesFieldInfo = (~)Word32
    type AttrTransferType VideoTimeCodeIntervalFramesFieldInfo = Word32
    type AttrGetType VideoTimeCodeIntervalFramesFieldInfo = Word32
    type AttrLabel VideoTimeCodeIntervalFramesFieldInfo = "frames"
    type AttrOrigin VideoTimeCodeIntervalFramesFieldInfo = VideoTimeCodeInterval
    attrGet = getVideoTimeCodeIntervalFrames
    attrSet = setVideoTimeCodeIntervalFrames
    attrConstruct = undefined
    attrClear = undefined
    attrTransfer _ v = do
        return v
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GstVideo.Structs.VideoTimeCodeInterval.frames"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gstvideo-1.0.29/docs/GI-GstVideo-Structs-VideoTimeCodeInterval.html#g:attr:frames"
        })

videoTimeCodeInterval_frames :: AttrLabelProxy "frames"
videoTimeCodeInterval_frames = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList VideoTimeCodeInterval
type instance O.AttributeList VideoTimeCodeInterval = VideoTimeCodeIntervalAttributeList
type VideoTimeCodeIntervalAttributeList = ('[ '("hours", VideoTimeCodeIntervalHoursFieldInfo), '("minutes", VideoTimeCodeIntervalMinutesFieldInfo), '("seconds", VideoTimeCodeIntervalSecondsFieldInfo), '("frames", VideoTimeCodeIntervalFramesFieldInfo)] :: [(Symbol, DK.Type)])
#endif

-- method VideoTimeCodeInterval::new
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "hours"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the hours field of #GstVideoTimeCodeInterval"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "minutes"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the minutes field of #GstVideoTimeCodeInterval"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "seconds"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the seconds field of #GstVideoTimeCodeInterval"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "frames"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the frames field of #GstVideoTimeCodeInterval"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name { namespace = "GstVideo" , name = "VideoTimeCodeInterval" })
-- throws : False
-- Skip return : False

foreign import ccall "gst_video_time_code_interval_new" gst_video_time_code_interval_new :: 
    Word32 ->                               -- hours : TBasicType TUInt
    Word32 ->                               -- minutes : TBasicType TUInt
    Word32 ->                               -- seconds : TBasicType TUInt
    Word32 ->                               -- frames : TBasicType TUInt
    IO (Ptr VideoTimeCodeInterval)

-- | /No description available in the introspection data./
-- 
-- /Since: 1.12/
videoTimeCodeIntervalNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Word32
    -- ^ /@hours@/: the hours field of t'GI.GstVideo.Structs.VideoTimeCodeInterval.VideoTimeCodeInterval'
    -> Word32
    -- ^ /@minutes@/: the minutes field of t'GI.GstVideo.Structs.VideoTimeCodeInterval.VideoTimeCodeInterval'
    -> Word32
    -- ^ /@seconds@/: the seconds field of t'GI.GstVideo.Structs.VideoTimeCodeInterval.VideoTimeCodeInterval'
    -> Word32
    -- ^ /@frames@/: the frames field of t'GI.GstVideo.Structs.VideoTimeCodeInterval.VideoTimeCodeInterval'
    -> m VideoTimeCodeInterval
    -- ^ __Returns:__ a new t'GI.GstVideo.Structs.VideoTimeCodeInterval.VideoTimeCodeInterval' with the given values.
videoTimeCodeIntervalNew :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Word32 -> Word32 -> Word32 -> Word32 -> m VideoTimeCodeInterval
videoTimeCodeIntervalNew Word32
hours Word32
minutes Word32
seconds Word32
frames = IO VideoTimeCodeInterval -> m VideoTimeCodeInterval
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO VideoTimeCodeInterval -> m VideoTimeCodeInterval)
-> IO VideoTimeCodeInterval -> m VideoTimeCodeInterval
forall a b. (a -> b) -> a -> b
$ do
    Ptr VideoTimeCodeInterval
result <- Word32
-> Word32 -> Word32 -> Word32 -> IO (Ptr VideoTimeCodeInterval)
gst_video_time_code_interval_new Word32
hours Word32
minutes Word32
seconds Word32
frames
    Text -> Ptr VideoTimeCodeInterval -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"videoTimeCodeIntervalNew" Ptr VideoTimeCodeInterval
result
    VideoTimeCodeInterval
result' <- ((ManagedPtr VideoTimeCodeInterval -> VideoTimeCodeInterval)
-> Ptr VideoTimeCodeInterval -> IO VideoTimeCodeInterval
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr VideoTimeCodeInterval -> VideoTimeCodeInterval
VideoTimeCodeInterval) Ptr VideoTimeCodeInterval
result
    VideoTimeCodeInterval -> IO VideoTimeCodeInterval
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return VideoTimeCodeInterval
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method VideoTimeCodeInterval::new_from_string
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "tc_inter_str"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "The string that represents the #GstVideoTimeCodeInterval"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name { namespace = "GstVideo" , name = "VideoTimeCodeInterval" })
-- throws : False
-- Skip return : False

foreign import ccall "gst_video_time_code_interval_new_from_string" gst_video_time_code_interval_new_from_string :: 
    CString ->                              -- tc_inter_str : TBasicType TUTF8
    IO (Ptr VideoTimeCodeInterval)

-- | /@tcInterStr@/ must only have \":\" as separators.
-- 
-- /Since: 1.12/
videoTimeCodeIntervalNewFromString ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    T.Text
    -- ^ /@tcInterStr@/: The string that represents the t'GI.GstVideo.Structs.VideoTimeCodeInterval.VideoTimeCodeInterval'
    -> m (Maybe VideoTimeCodeInterval)
    -- ^ __Returns:__ a new t'GI.GstVideo.Structs.VideoTimeCodeInterval.VideoTimeCodeInterval' from the given string
    --   or 'P.Nothing' if the string could not be passed.
videoTimeCodeIntervalNewFromString :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> m (Maybe VideoTimeCodeInterval)
videoTimeCodeIntervalNewFromString Text
tcInterStr = IO (Maybe VideoTimeCodeInterval) -> m (Maybe VideoTimeCodeInterval)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe VideoTimeCodeInterval)
 -> m (Maybe VideoTimeCodeInterval))
-> IO (Maybe VideoTimeCodeInterval)
-> m (Maybe VideoTimeCodeInterval)
forall a b. (a -> b) -> a -> b
$ do
    CString
tcInterStr' <- Text -> IO CString
textToCString Text
tcInterStr
    Ptr VideoTimeCodeInterval
result <- CString -> IO (Ptr VideoTimeCodeInterval)
gst_video_time_code_interval_new_from_string CString
tcInterStr'
    Maybe VideoTimeCodeInterval
maybeResult <- Ptr VideoTimeCodeInterval
-> (Ptr VideoTimeCodeInterval -> IO VideoTimeCodeInterval)
-> IO (Maybe VideoTimeCodeInterval)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr VideoTimeCodeInterval
result ((Ptr VideoTimeCodeInterval -> IO VideoTimeCodeInterval)
 -> IO (Maybe VideoTimeCodeInterval))
-> (Ptr VideoTimeCodeInterval -> IO VideoTimeCodeInterval)
-> IO (Maybe VideoTimeCodeInterval)
forall a b. (a -> b) -> a -> b
$ \Ptr VideoTimeCodeInterval
result' -> do
        VideoTimeCodeInterval
result'' <- ((ManagedPtr VideoTimeCodeInterval -> VideoTimeCodeInterval)
-> Ptr VideoTimeCodeInterval -> IO VideoTimeCodeInterval
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr VideoTimeCodeInterval -> VideoTimeCodeInterval
VideoTimeCodeInterval) Ptr VideoTimeCodeInterval
result'
        VideoTimeCodeInterval -> IO VideoTimeCodeInterval
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return VideoTimeCodeInterval
result''
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
tcInterStr'
    Maybe VideoTimeCodeInterval -> IO (Maybe VideoTimeCodeInterval)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe VideoTimeCodeInterval
maybeResult

#if defined(ENABLE_OVERLOADING)
#endif

-- method VideoTimeCodeInterval::clear
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "tc"
--           , argType =
--               TInterface
--                 Name { namespace = "GstVideo" , name = "VideoTimeCodeInterval" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstVideoTimeCodeInterval"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gst_video_time_code_interval_clear" gst_video_time_code_interval_clear :: 
    Ptr VideoTimeCodeInterval ->            -- tc : TInterface (Name {namespace = "GstVideo", name = "VideoTimeCodeInterval"})
    IO ()

-- | Initializes /@tc@/ with empty\/zero\/NULL values.
-- 
-- /Since: 1.12/
videoTimeCodeIntervalClear ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    VideoTimeCodeInterval
    -- ^ /@tc@/: a t'GI.GstVideo.Structs.VideoTimeCodeInterval.VideoTimeCodeInterval'
    -> m ()
videoTimeCodeIntervalClear :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VideoTimeCodeInterval -> m ()
videoTimeCodeIntervalClear VideoTimeCodeInterval
tc = 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
$ do
    Ptr VideoTimeCodeInterval
tc' <- VideoTimeCodeInterval -> IO (Ptr VideoTimeCodeInterval)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VideoTimeCodeInterval
tc
    Ptr VideoTimeCodeInterval -> IO ()
gst_video_time_code_interval_clear Ptr VideoTimeCodeInterval
tc'
    VideoTimeCodeInterval -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr VideoTimeCodeInterval
tc
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data VideoTimeCodeIntervalClearMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod VideoTimeCodeIntervalClearMethodInfo VideoTimeCodeInterval signature where
    overloadedMethod = videoTimeCodeIntervalClear

instance O.OverloadedMethodInfo VideoTimeCodeIntervalClearMethodInfo VideoTimeCodeInterval where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GstVideo.Structs.VideoTimeCodeInterval.videoTimeCodeIntervalClear",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gstvideo-1.0.29/docs/GI-GstVideo-Structs-VideoTimeCodeInterval.html#v:videoTimeCodeIntervalClear"
        })


#endif

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

foreign import ccall "gst_video_time_code_interval_copy" gst_video_time_code_interval_copy :: 
    Ptr VideoTimeCodeInterval ->            -- tc : TInterface (Name {namespace = "GstVideo", name = "VideoTimeCodeInterval"})
    IO (Ptr VideoTimeCodeInterval)

-- | /No description available in the introspection data./
-- 
-- /Since: 1.12/
videoTimeCodeIntervalCopy ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    VideoTimeCodeInterval
    -- ^ /@tc@/: a t'GI.GstVideo.Structs.VideoTimeCodeInterval.VideoTimeCodeInterval'
    -> m VideoTimeCodeInterval
    -- ^ __Returns:__ a new t'GI.GstVideo.Structs.VideoTimeCodeInterval.VideoTimeCodeInterval' with the same values as /@tc@/.
videoTimeCodeIntervalCopy :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VideoTimeCodeInterval -> m VideoTimeCodeInterval
videoTimeCodeIntervalCopy VideoTimeCodeInterval
tc = IO VideoTimeCodeInterval -> m VideoTimeCodeInterval
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO VideoTimeCodeInterval -> m VideoTimeCodeInterval)
-> IO VideoTimeCodeInterval -> m VideoTimeCodeInterval
forall a b. (a -> b) -> a -> b
$ do
    Ptr VideoTimeCodeInterval
tc' <- VideoTimeCodeInterval -> IO (Ptr VideoTimeCodeInterval)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VideoTimeCodeInterval
tc
    Ptr VideoTimeCodeInterval
result <- Ptr VideoTimeCodeInterval -> IO (Ptr VideoTimeCodeInterval)
gst_video_time_code_interval_copy Ptr VideoTimeCodeInterval
tc'
    Text -> Ptr VideoTimeCodeInterval -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"videoTimeCodeIntervalCopy" Ptr VideoTimeCodeInterval
result
    VideoTimeCodeInterval
result' <- ((ManagedPtr VideoTimeCodeInterval -> VideoTimeCodeInterval)
-> Ptr VideoTimeCodeInterval -> IO VideoTimeCodeInterval
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr VideoTimeCodeInterval -> VideoTimeCodeInterval
VideoTimeCodeInterval) Ptr VideoTimeCodeInterval
result
    VideoTimeCodeInterval -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr VideoTimeCodeInterval
tc
    VideoTimeCodeInterval -> IO VideoTimeCodeInterval
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return VideoTimeCodeInterval
result'

#if defined(ENABLE_OVERLOADING)
data VideoTimeCodeIntervalCopyMethodInfo
instance (signature ~ (m VideoTimeCodeInterval), MonadIO m) => O.OverloadedMethod VideoTimeCodeIntervalCopyMethodInfo VideoTimeCodeInterval signature where
    overloadedMethod = videoTimeCodeIntervalCopy

instance O.OverloadedMethodInfo VideoTimeCodeIntervalCopyMethodInfo VideoTimeCodeInterval where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GstVideo.Structs.VideoTimeCodeInterval.videoTimeCodeIntervalCopy",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gstvideo-1.0.29/docs/GI-GstVideo-Structs-VideoTimeCodeInterval.html#v:videoTimeCodeIntervalCopy"
        })


#endif

-- method VideoTimeCodeInterval::free
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "tc"
--           , argType =
--               TInterface
--                 Name { namespace = "GstVideo" , name = "VideoTimeCodeInterval" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstVideoTimeCodeInterval"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gst_video_time_code_interval_free" gst_video_time_code_interval_free :: 
    Ptr VideoTimeCodeInterval ->            -- tc : TInterface (Name {namespace = "GstVideo", name = "VideoTimeCodeInterval"})
    IO ()

-- | Frees /@tc@/.
-- 
-- /Since: 1.12/
videoTimeCodeIntervalFree ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    VideoTimeCodeInterval
    -- ^ /@tc@/: a t'GI.GstVideo.Structs.VideoTimeCodeInterval.VideoTimeCodeInterval'
    -> m ()
videoTimeCodeIntervalFree :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VideoTimeCodeInterval -> m ()
videoTimeCodeIntervalFree VideoTimeCodeInterval
tc = 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
$ do
    Ptr VideoTimeCodeInterval
tc' <- VideoTimeCodeInterval -> IO (Ptr VideoTimeCodeInterval)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VideoTimeCodeInterval
tc
    Ptr VideoTimeCodeInterval -> IO ()
gst_video_time_code_interval_free Ptr VideoTimeCodeInterval
tc'
    VideoTimeCodeInterval -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr VideoTimeCodeInterval
tc
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data VideoTimeCodeIntervalFreeMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod VideoTimeCodeIntervalFreeMethodInfo VideoTimeCodeInterval signature where
    overloadedMethod = videoTimeCodeIntervalFree

instance O.OverloadedMethodInfo VideoTimeCodeIntervalFreeMethodInfo VideoTimeCodeInterval where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GstVideo.Structs.VideoTimeCodeInterval.videoTimeCodeIntervalFree",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gstvideo-1.0.29/docs/GI-GstVideo-Structs-VideoTimeCodeInterval.html#v:videoTimeCodeIntervalFree"
        })


#endif

-- method VideoTimeCodeInterval::init
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "tc"
--           , argType =
--               TInterface
--                 Name { namespace = "GstVideo" , name = "VideoTimeCodeInterval" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GstVideoTimeCodeInterval"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "hours"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the hours field of #GstVideoTimeCodeInterval"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "minutes"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the minutes field of #GstVideoTimeCodeInterval"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "seconds"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the seconds field of #GstVideoTimeCodeInterval"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "frames"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the frames field of #GstVideoTimeCodeInterval"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gst_video_time_code_interval_init" gst_video_time_code_interval_init :: 
    Ptr VideoTimeCodeInterval ->            -- tc : TInterface (Name {namespace = "GstVideo", name = "VideoTimeCodeInterval"})
    Word32 ->                               -- hours : TBasicType TUInt
    Word32 ->                               -- minutes : TBasicType TUInt
    Word32 ->                               -- seconds : TBasicType TUInt
    Word32 ->                               -- frames : TBasicType TUInt
    IO ()

-- | Initializes /@tc@/ with the given values.
-- 
-- /Since: 1.12/
videoTimeCodeIntervalInit ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    VideoTimeCodeInterval
    -- ^ /@tc@/: a t'GI.GstVideo.Structs.VideoTimeCodeInterval.VideoTimeCodeInterval'
    -> Word32
    -- ^ /@hours@/: the hours field of t'GI.GstVideo.Structs.VideoTimeCodeInterval.VideoTimeCodeInterval'
    -> Word32
    -- ^ /@minutes@/: the minutes field of t'GI.GstVideo.Structs.VideoTimeCodeInterval.VideoTimeCodeInterval'
    -> Word32
    -- ^ /@seconds@/: the seconds field of t'GI.GstVideo.Structs.VideoTimeCodeInterval.VideoTimeCodeInterval'
    -> Word32
    -- ^ /@frames@/: the frames field of t'GI.GstVideo.Structs.VideoTimeCodeInterval.VideoTimeCodeInterval'
    -> m ()
videoTimeCodeIntervalInit :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
VideoTimeCodeInterval
-> Word32 -> Word32 -> Word32 -> Word32 -> m ()
videoTimeCodeIntervalInit VideoTimeCodeInterval
tc Word32
hours Word32
minutes Word32
seconds Word32
frames = 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
$ do
    Ptr VideoTimeCodeInterval
tc' <- VideoTimeCodeInterval -> IO (Ptr VideoTimeCodeInterval)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr VideoTimeCodeInterval
tc
    Ptr VideoTimeCodeInterval
-> Word32 -> Word32 -> Word32 -> Word32 -> IO ()
gst_video_time_code_interval_init Ptr VideoTimeCodeInterval
tc' Word32
hours Word32
minutes Word32
seconds Word32
frames
    VideoTimeCodeInterval -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr VideoTimeCodeInterval
tc
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data VideoTimeCodeIntervalInitMethodInfo
instance (signature ~ (Word32 -> Word32 -> Word32 -> Word32 -> m ()), MonadIO m) => O.OverloadedMethod VideoTimeCodeIntervalInitMethodInfo VideoTimeCodeInterval signature where
    overloadedMethod = videoTimeCodeIntervalInit

instance O.OverloadedMethodInfo VideoTimeCodeIntervalInitMethodInfo VideoTimeCodeInterval where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GstVideo.Structs.VideoTimeCodeInterval.videoTimeCodeIntervalInit",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gstvideo-1.0.29/docs/GI-GstVideo-Structs-VideoTimeCodeInterval.html#v:videoTimeCodeIntervalInit"
        })


#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveVideoTimeCodeIntervalMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
    ResolveVideoTimeCodeIntervalMethod "clear" o = VideoTimeCodeIntervalClearMethodInfo
    ResolveVideoTimeCodeIntervalMethod "copy" o = VideoTimeCodeIntervalCopyMethodInfo
    ResolveVideoTimeCodeIntervalMethod "free" o = VideoTimeCodeIntervalFreeMethodInfo
    ResolveVideoTimeCodeIntervalMethod "init" o = VideoTimeCodeIntervalInitMethodInfo
    ResolveVideoTimeCodeIntervalMethod l o = O.MethodResolutionFailed l o

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

#endif

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

#endif