{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- 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            ,
    noVideoTimeCodeInterval                 ,


 -- * Methods
-- ** Overloaded methods #method:Overloaded methods#

#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.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
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 Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL


-- | Memory-managed wrapper type.
newtype VideoTimeCodeInterval = VideoTimeCodeInterval (ManagedPtr VideoTimeCodeInterval)
    deriving (VideoTimeCodeInterval -> VideoTimeCodeInterval -> Bool
(VideoTimeCodeInterval -> VideoTimeCodeInterval -> Bool)
-> (VideoTimeCodeInterval -> VideoTimeCodeInterval -> Bool)
-> Eq VideoTimeCodeInterval
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VideoTimeCodeInterval -> VideoTimeCodeInterval -> Bool
$c/= :: VideoTimeCodeInterval -> VideoTimeCodeInterval -> Bool
== :: VideoTimeCodeInterval -> VideoTimeCodeInterval -> Bool
$c== :: VideoTimeCodeInterval -> VideoTimeCodeInterval -> Bool
Eq)
foreign import ccall "gst_video_time_code_interval_get_type" c_gst_video_time_code_interval_get_type :: 
    IO GType

instance BoxedObject VideoTimeCodeInterval where
    boxedType :: VideoTimeCodeInterval -> IO GType
boxedType _ = IO GType
c_gst_video_time_code_interval_get_type

-- | Convert 'VideoTimeCodeInterval' to and from 'Data.GI.Base.GValue.GValue' with 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue VideoTimeCodeInterval where
    toGValue :: VideoTimeCodeInterval -> IO GValue
toGValue o :: VideoTimeCodeInterval
o = do
        GType
gtype <- IO GType
c_gst_video_time_code_interval_get_type
        VideoTimeCodeInterval
-> (Ptr VideoTimeCodeInterval -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr VideoTimeCodeInterval
o (GType
-> (GValue -> Ptr VideoTimeCodeInterval -> IO ())
-> Ptr VideoTimeCodeInterval
-> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr VideoTimeCodeInterval -> IO ()
forall a. GValue -> Ptr a -> IO ()
B.GValue.set_boxed)
        
    fromGValue :: GValue -> IO VideoTimeCodeInterval
fromGValue gv :: GValue
gv = do
        Ptr VideoTimeCodeInterval
ptr <- GValue -> IO (Ptr VideoTimeCodeInterval)
forall b. GValue -> IO (Ptr b)
B.GValue.get_boxed GValue
gv :: IO (Ptr VideoTimeCodeInterval)
        (ManagedPtr VideoTimeCodeInterval -> VideoTimeCodeInterval)
-> Ptr VideoTimeCodeInterval -> IO VideoTimeCodeInterval
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr VideoTimeCodeInterval -> VideoTimeCodeInterval
VideoTimeCodeInterval Ptr VideoTimeCodeInterval
ptr
        
    

-- | Construct a `VideoTimeCodeInterval` struct initialized to zero.
newZeroVideoTimeCodeInterval :: MonadIO m => m VideoTimeCodeInterval
newZeroVideoTimeCodeInterval :: m VideoTimeCodeInterval
newZeroVideoTimeCodeInterval = IO VideoTimeCodeInterval -> m VideoTimeCodeInterval
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. BoxedObject a => Int -> IO (Ptr a)
callocBoxedBytes 16 IO (Ptr VideoTimeCodeInterval)
-> (Ptr VideoTimeCodeInterval -> IO VideoTimeCodeInterval)
-> IO VideoTimeCodeInterval
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr VideoTimeCodeInterval -> VideoTimeCodeInterval)
-> Ptr VideoTimeCodeInterval -> IO VideoTimeCodeInterval
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr VideoTimeCodeInterval -> VideoTimeCodeInterval
VideoTimeCodeInterval

instance tag ~ 'AttrSet => Constructible VideoTimeCodeInterval tag where
    new :: (ManagedPtr VideoTimeCodeInterval -> VideoTimeCodeInterval)
-> [AttrOp VideoTimeCodeInterval tag] -> m VideoTimeCodeInterval
new _ attrs :: [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 (m :: * -> *) a. Monad m => a -> m a
return VideoTimeCodeInterval
o


-- | A convenience alias for `Nothing` :: `Maybe` `VideoTimeCodeInterval`.
noVideoTimeCodeInterval :: Maybe VideoTimeCodeInterval
noVideoTimeCodeInterval :: Maybe VideoTimeCodeInterval
noVideoTimeCodeInterval = Maybe VideoTimeCodeInterval
forall a. Maybe a
Nothing

-- | 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 :: VideoTimeCodeInterval -> m Word32
getVideoTimeCodeIntervalHours s :: VideoTimeCodeInterval
s = IO Word32 -> m Word32
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 :: 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` 0) :: IO Word32
    Word32 -> IO Word32
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 :: VideoTimeCodeInterval -> Word32 -> m ()
setVideoTimeCodeIntervalHours s :: VideoTimeCodeInterval
s val :: Word32
val = IO () -> m ()
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 :: 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` 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

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 :: VideoTimeCodeInterval -> m Word32
getVideoTimeCodeIntervalMinutes s :: VideoTimeCodeInterval
s = IO Word32 -> m Word32
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 :: 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` 4) :: IO Word32
    Word32 -> IO Word32
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 :: VideoTimeCodeInterval -> Word32 -> m ()
setVideoTimeCodeIntervalMinutes s :: VideoTimeCodeInterval
s val :: Word32
val = IO () -> m ()
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 :: 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` 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

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 :: VideoTimeCodeInterval -> m Word32
getVideoTimeCodeIntervalSeconds s :: VideoTimeCodeInterval
s = IO Word32 -> m Word32
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 :: 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` 8) :: IO Word32
    Word32 -> IO Word32
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 :: VideoTimeCodeInterval -> Word32 -> m ()
setVideoTimeCodeIntervalSeconds s :: VideoTimeCodeInterval
s val :: Word32
val = IO () -> m ()
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 :: 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` 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

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 :: VideoTimeCodeInterval -> m Word32
getVideoTimeCodeIntervalFrames s :: VideoTimeCodeInterval
s = IO Word32 -> m Word32
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 :: 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` 12) :: IO Word32
    Word32 -> IO Word32
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 :: VideoTimeCodeInterval -> Word32 -> m ()
setVideoTimeCodeIntervalFrames s :: VideoTimeCodeInterval
s val :: Word32
val = IO () -> m ()
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 :: 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` 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

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, *)])
#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
--           , 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
--           , 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
--           , 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
--           , 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 :: Word32 -> Word32 -> Word32 -> Word32 -> m VideoTimeCodeInterval
videoTimeCodeIntervalNew hours :: Word32
hours minutes :: Word32
minutes seconds :: Word32
seconds frames :: Word32
frames = IO VideoTimeCodeInterval -> m VideoTimeCodeInterval
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 "videoTimeCodeIntervalNew" Ptr VideoTimeCodeInterval
result
    VideoTimeCodeInterval
result' <- ((ManagedPtr VideoTimeCodeInterval -> VideoTimeCodeInterval)
-> Ptr VideoTimeCodeInterval -> IO VideoTimeCodeInterval
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr VideoTimeCodeInterval -> VideoTimeCodeInterval
VideoTimeCodeInterval) Ptr VideoTimeCodeInterval
result
    VideoTimeCodeInterval -> IO VideoTimeCodeInterval
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
--           , 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 :: Text -> m (Maybe VideoTimeCodeInterval)
videoTimeCodeIntervalNewFromString tcInterStr :: Text
tcInterStr = IO (Maybe VideoTimeCodeInterval) -> m (Maybe VideoTimeCodeInterval)
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
$ \result' :: Ptr VideoTimeCodeInterval
result' -> do
        VideoTimeCodeInterval
result'' <- ((ManagedPtr VideoTimeCodeInterval -> VideoTimeCodeInterval)
-> Ptr VideoTimeCodeInterval -> IO VideoTimeCodeInterval
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr VideoTimeCodeInterval -> VideoTimeCodeInterval
VideoTimeCodeInterval) Ptr VideoTimeCodeInterval
result'
        VideoTimeCodeInterval -> IO VideoTimeCodeInterval
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 (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
--           , 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 :: VideoTimeCodeInterval -> m ()
videoTimeCodeIntervalClear tc :: VideoTimeCodeInterval
tc = IO () -> m ()
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 (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data VideoTimeCodeIntervalClearMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.MethodInfo VideoTimeCodeIntervalClearMethodInfo VideoTimeCodeInterval signature where
    overloadedMethod = 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
--           , 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 :: VideoTimeCodeInterval -> m VideoTimeCodeInterval
videoTimeCodeIntervalCopy tc :: VideoTimeCodeInterval
tc = IO VideoTimeCodeInterval -> m VideoTimeCodeInterval
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 "videoTimeCodeIntervalCopy" Ptr VideoTimeCodeInterval
result
    VideoTimeCodeInterval
result' <- ((ManagedPtr VideoTimeCodeInterval -> VideoTimeCodeInterval)
-> Ptr VideoTimeCodeInterval -> IO VideoTimeCodeInterval
forall a.
(HasCallStack, BoxedObject 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 (m :: * -> *) a. Monad m => a -> m a
return VideoTimeCodeInterval
result'

#if defined(ENABLE_OVERLOADING)
data VideoTimeCodeIntervalCopyMethodInfo
instance (signature ~ (m VideoTimeCodeInterval), MonadIO m) => O.MethodInfo VideoTimeCodeIntervalCopyMethodInfo VideoTimeCodeInterval signature where
    overloadedMethod = 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
--           , 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 :: VideoTimeCodeInterval -> m ()
videoTimeCodeIntervalFree tc :: VideoTimeCodeInterval
tc = IO () -> m ()
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 (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data VideoTimeCodeIntervalFreeMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.MethodInfo VideoTimeCodeIntervalFreeMethodInfo VideoTimeCodeInterval signature where
    overloadedMethod = 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
--           , 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
--           , 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
--           , 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
--           , 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
--           , 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 :: VideoTimeCodeInterval
-> Word32 -> Word32 -> Word32 -> Word32 -> m ()
videoTimeCodeIntervalInit tc :: VideoTimeCodeInterval
tc hours :: Word32
hours minutes :: Word32
minutes seconds :: Word32
seconds frames :: Word32
frames = IO () -> m ()
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 (m :: * -> *) a. Monad m => a -> m a
return ()

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

#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveVideoTimeCodeIntervalMethod (t :: Symbol) (o :: *) :: * 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.MethodInfo 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

#endif