{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)

All pending timeouts or periodic notifies are converted into
an entry.
Note that GstClockEntry should be treated as an opaque structure. It must
not be extended or allocated using a custom allocator.
-}

module GI.Gst.Structs.ClockEntry
    ( 

-- * Exported types
    ClockEntry(..)                          ,
    newZeroClockEntry                       ,
    noClockEntry                            ,


 -- * Properties
-- ** clock #attr:clock#
    clearClockEntryClock                    ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    clockEntry_clock                        ,
#endif
    getClockEntryClock                      ,
    setClockEntryClock                      ,


-- ** destroyData #attr:destroyData#
    clearClockEntryDestroyData              ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    clockEntry_destroyData                  ,
#endif
    getClockEntryDestroyData                ,
    setClockEntryDestroyData                ,


-- ** func #attr:func#
    clearClockEntryFunc                     ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    clockEntry_func                         ,
#endif
    getClockEntryFunc                       ,
    setClockEntryFunc                       ,


-- ** interval #attr:interval#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    clockEntry_interval                     ,
#endif
    getClockEntryInterval                   ,
    setClockEntryInterval                   ,


-- ** refcount #attr:refcount#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    clockEntry_refcount                     ,
#endif
    getClockEntryRefcount                   ,
    setClockEntryRefcount                   ,


-- ** status #attr:status#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    clockEntry_status                       ,
#endif
    getClockEntryStatus                     ,
    setClockEntryStatus                     ,


-- ** time #attr:time#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    clockEntry_time                         ,
#endif
    getClockEntryTime                       ,
    setClockEntryTime                       ,


-- ** type #attr:type#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    clockEntry_type                         ,
#endif
    getClockEntryType                       ,
    setClockEntryType                       ,


-- ** unscheduled #attr:unscheduled#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    clockEntry_unscheduled                  ,
#endif
    getClockEntryUnscheduled                ,
    setClockEntryUnscheduled                ,


-- ** userData #attr:userData#
    clearClockEntryUserData                 ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    clockEntry_userData                     ,
#endif
    getClockEntryUserData                   ,
    setClockEntryUserData                   ,


-- ** wokenUp #attr:wokenUp#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    clockEntry_wokenUp                      ,
#endif
    getClockEntryWokenUp                    ,
    setClockEntryWokenUp                    ,




    ) where

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

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

import qualified GI.GLib.Callbacks as GLib.Callbacks
import qualified GI.Gst.Callbacks as Gst.Callbacks
import {-# SOURCE #-} qualified GI.Gst.Enums as Gst.Enums
import {-# SOURCE #-} qualified GI.Gst.Objects.Clock as Gst.Clock

newtype ClockEntry = ClockEntry (ManagedPtr ClockEntry)
instance WrappedPtr ClockEntry where
    wrappedPtrCalloc = callocBytes 112
    wrappedPtrCopy = \p -> withManagedPtr p (copyBytes 112 >=> wrapPtr ClockEntry)
    wrappedPtrFree = Just ptr_to_g_free

-- | Construct a `ClockEntry` struct initialized to zero.
newZeroClockEntry :: MonadIO m => m ClockEntry
newZeroClockEntry = liftIO $ wrappedPtrCalloc >>= wrapPtr ClockEntry

instance tag ~ 'AttrSet => Constructible ClockEntry tag where
    new _ attrs = do
        o <- newZeroClockEntry
        GI.Attributes.set o attrs
        return o


noClockEntry :: Maybe ClockEntry
noClockEntry = Nothing

getClockEntryRefcount :: MonadIO m => ClockEntry -> m Int32
getClockEntryRefcount s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO Int32
    return val

setClockEntryRefcount :: MonadIO m => ClockEntry -> Int32 -> m ()
setClockEntryRefcount s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 0) (val :: Int32)

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data ClockEntryRefcountFieldInfo
instance AttrInfo ClockEntryRefcountFieldInfo where
    type AttrAllowedOps ClockEntryRefcountFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ClockEntryRefcountFieldInfo = (~) Int32
    type AttrBaseTypeConstraint ClockEntryRefcountFieldInfo = (~) ClockEntry
    type AttrGetType ClockEntryRefcountFieldInfo = Int32
    type AttrLabel ClockEntryRefcountFieldInfo = "refcount"
    type AttrOrigin ClockEntryRefcountFieldInfo = ClockEntry
    attrGet _ = getClockEntryRefcount
    attrSet _ = setClockEntryRefcount
    attrConstruct = undefined
    attrClear _ = undefined

clockEntry_refcount :: AttrLabelProxy "refcount"
clockEntry_refcount = AttrLabelProxy

#endif


getClockEntryClock :: MonadIO m => ClockEntry -> m (Maybe Gst.Clock.Clock)
getClockEntryClock s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 8) :: IO (Ptr Gst.Clock.Clock)
    result <- SP.convertIfNonNull val $ \val' -> do
        val'' <- (newObject Gst.Clock.Clock) val'
        return val''
    return result

setClockEntryClock :: MonadIO m => ClockEntry -> Ptr Gst.Clock.Clock -> m ()
setClockEntryClock s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 8) (val :: Ptr Gst.Clock.Clock)

clearClockEntryClock :: MonadIO m => ClockEntry -> m ()
clearClockEntryClock s = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 8) (FP.nullPtr :: Ptr Gst.Clock.Clock)

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data ClockEntryClockFieldInfo
instance AttrInfo ClockEntryClockFieldInfo where
    type AttrAllowedOps ClockEntryClockFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ClockEntryClockFieldInfo = (~) (Ptr Gst.Clock.Clock)
    type AttrBaseTypeConstraint ClockEntryClockFieldInfo = (~) ClockEntry
    type AttrGetType ClockEntryClockFieldInfo = Maybe Gst.Clock.Clock
    type AttrLabel ClockEntryClockFieldInfo = "clock"
    type AttrOrigin ClockEntryClockFieldInfo = ClockEntry
    attrGet _ = getClockEntryClock
    attrSet _ = setClockEntryClock
    attrConstruct = undefined
    attrClear _ = clearClockEntryClock

clockEntry_clock :: AttrLabelProxy "clock"
clockEntry_clock = AttrLabelProxy

#endif


getClockEntryType :: MonadIO m => ClockEntry -> m Gst.Enums.ClockEntryType
getClockEntryType s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 16) :: IO CUInt
    let val' = (toEnum . fromIntegral) val
    return val'

setClockEntryType :: MonadIO m => ClockEntry -> Gst.Enums.ClockEntryType -> m ()
setClockEntryType s val = liftIO $ withManagedPtr s $ \ptr -> do
    let val' = (fromIntegral . fromEnum) val
    poke (ptr `plusPtr` 16) (val' :: CUInt)

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data ClockEntryTypeFieldInfo
instance AttrInfo ClockEntryTypeFieldInfo where
    type AttrAllowedOps ClockEntryTypeFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ClockEntryTypeFieldInfo = (~) Gst.Enums.ClockEntryType
    type AttrBaseTypeConstraint ClockEntryTypeFieldInfo = (~) ClockEntry
    type AttrGetType ClockEntryTypeFieldInfo = Gst.Enums.ClockEntryType
    type AttrLabel ClockEntryTypeFieldInfo = "type"
    type AttrOrigin ClockEntryTypeFieldInfo = ClockEntry
    attrGet _ = getClockEntryType
    attrSet _ = setClockEntryType
    attrConstruct = undefined
    attrClear _ = undefined

clockEntry_type :: AttrLabelProxy "type"
clockEntry_type = AttrLabelProxy

#endif


getClockEntryTime :: MonadIO m => ClockEntry -> m Word64
getClockEntryTime s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 24) :: IO Word64
    return val

setClockEntryTime :: MonadIO m => ClockEntry -> Word64 -> m ()
setClockEntryTime s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 24) (val :: Word64)

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data ClockEntryTimeFieldInfo
instance AttrInfo ClockEntryTimeFieldInfo where
    type AttrAllowedOps ClockEntryTimeFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ClockEntryTimeFieldInfo = (~) Word64
    type AttrBaseTypeConstraint ClockEntryTimeFieldInfo = (~) ClockEntry
    type AttrGetType ClockEntryTimeFieldInfo = Word64
    type AttrLabel ClockEntryTimeFieldInfo = "time"
    type AttrOrigin ClockEntryTimeFieldInfo = ClockEntry
    attrGet _ = getClockEntryTime
    attrSet _ = setClockEntryTime
    attrConstruct = undefined
    attrClear _ = undefined

clockEntry_time :: AttrLabelProxy "time"
clockEntry_time = AttrLabelProxy

#endif


getClockEntryInterval :: MonadIO m => ClockEntry -> m Word64
getClockEntryInterval s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 32) :: IO Word64
    return val

setClockEntryInterval :: MonadIO m => ClockEntry -> Word64 -> m ()
setClockEntryInterval s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 32) (val :: Word64)

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data ClockEntryIntervalFieldInfo
instance AttrInfo ClockEntryIntervalFieldInfo where
    type AttrAllowedOps ClockEntryIntervalFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ClockEntryIntervalFieldInfo = (~) Word64
    type AttrBaseTypeConstraint ClockEntryIntervalFieldInfo = (~) ClockEntry
    type AttrGetType ClockEntryIntervalFieldInfo = Word64
    type AttrLabel ClockEntryIntervalFieldInfo = "interval"
    type AttrOrigin ClockEntryIntervalFieldInfo = ClockEntry
    attrGet _ = getClockEntryInterval
    attrSet _ = setClockEntryInterval
    attrConstruct = undefined
    attrClear _ = undefined

clockEntry_interval :: AttrLabelProxy "interval"
clockEntry_interval = AttrLabelProxy

#endif


getClockEntryStatus :: MonadIO m => ClockEntry -> m Gst.Enums.ClockReturn
getClockEntryStatus s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 40) :: IO CUInt
    let val' = (toEnum . fromIntegral) val
    return val'

setClockEntryStatus :: MonadIO m => ClockEntry -> Gst.Enums.ClockReturn -> m ()
setClockEntryStatus s val = liftIO $ withManagedPtr s $ \ptr -> do
    let val' = (fromIntegral . fromEnum) val
    poke (ptr `plusPtr` 40) (val' :: CUInt)

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data ClockEntryStatusFieldInfo
instance AttrInfo ClockEntryStatusFieldInfo where
    type AttrAllowedOps ClockEntryStatusFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ClockEntryStatusFieldInfo = (~) Gst.Enums.ClockReturn
    type AttrBaseTypeConstraint ClockEntryStatusFieldInfo = (~) ClockEntry
    type AttrGetType ClockEntryStatusFieldInfo = Gst.Enums.ClockReturn
    type AttrLabel ClockEntryStatusFieldInfo = "status"
    type AttrOrigin ClockEntryStatusFieldInfo = ClockEntry
    attrGet _ = getClockEntryStatus
    attrSet _ = setClockEntryStatus
    attrConstruct = undefined
    attrClear _ = undefined

clockEntry_status :: AttrLabelProxy "status"
clockEntry_status = AttrLabelProxy

#endif


getClockEntryFunc :: MonadIO m => ClockEntry -> m (Maybe Gst.Callbacks.ClockCallback_WithClosures)
getClockEntryFunc s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 48) :: IO (FunPtr Gst.Callbacks.C_ClockCallback)
    result <- SP.convertFunPtrIfNonNull val $ \val' -> do
        let val'' = Gst.Callbacks.dynamic_ClockCallback val'
        return val''
    return result

setClockEntryFunc :: MonadIO m => ClockEntry -> FunPtr Gst.Callbacks.C_ClockCallback -> m ()
setClockEntryFunc s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 48) (val :: FunPtr Gst.Callbacks.C_ClockCallback)

clearClockEntryFunc :: MonadIO m => ClockEntry -> m ()
clearClockEntryFunc s = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 48) (FP.nullFunPtr :: FunPtr Gst.Callbacks.C_ClockCallback)

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data ClockEntryFuncFieldInfo
instance AttrInfo ClockEntryFuncFieldInfo where
    type AttrAllowedOps ClockEntryFuncFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ClockEntryFuncFieldInfo = (~) (FunPtr Gst.Callbacks.C_ClockCallback)
    type AttrBaseTypeConstraint ClockEntryFuncFieldInfo = (~) ClockEntry
    type AttrGetType ClockEntryFuncFieldInfo = Maybe Gst.Callbacks.ClockCallback_WithClosures
    type AttrLabel ClockEntryFuncFieldInfo = "func"
    type AttrOrigin ClockEntryFuncFieldInfo = ClockEntry
    attrGet _ = getClockEntryFunc
    attrSet _ = setClockEntryFunc
    attrConstruct = undefined
    attrClear _ = clearClockEntryFunc

clockEntry_func :: AttrLabelProxy "func"
clockEntry_func = AttrLabelProxy

#endif


getClockEntryUserData :: MonadIO m => ClockEntry -> m (Ptr ())
getClockEntryUserData s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 56) :: IO (Ptr ())
    return val

setClockEntryUserData :: MonadIO m => ClockEntry -> Ptr () -> m ()
setClockEntryUserData s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 56) (val :: Ptr ())

clearClockEntryUserData :: MonadIO m => ClockEntry -> m ()
clearClockEntryUserData s = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 56) (FP.nullPtr :: Ptr ())

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data ClockEntryUserDataFieldInfo
instance AttrInfo ClockEntryUserDataFieldInfo where
    type AttrAllowedOps ClockEntryUserDataFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ClockEntryUserDataFieldInfo = (~) (Ptr ())
    type AttrBaseTypeConstraint ClockEntryUserDataFieldInfo = (~) ClockEntry
    type AttrGetType ClockEntryUserDataFieldInfo = Ptr ()
    type AttrLabel ClockEntryUserDataFieldInfo = "user_data"
    type AttrOrigin ClockEntryUserDataFieldInfo = ClockEntry
    attrGet _ = getClockEntryUserData
    attrSet _ = setClockEntryUserData
    attrConstruct = undefined
    attrClear _ = clearClockEntryUserData

clockEntry_userData :: AttrLabelProxy "userData"
clockEntry_userData = AttrLabelProxy

#endif


getClockEntryDestroyData :: MonadIO m => ClockEntry -> m (Maybe GLib.Callbacks.DestroyNotify)
getClockEntryDestroyData s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 64) :: IO (FunPtr GLib.Callbacks.C_DestroyNotify)
    result <- SP.convertFunPtrIfNonNull val $ \val' -> do
        let val'' = GLib.Callbacks.dynamic_DestroyNotify val'
        return val''
    return result

setClockEntryDestroyData :: MonadIO m => ClockEntry -> FunPtr GLib.Callbacks.C_DestroyNotify -> m ()
setClockEntryDestroyData s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 64) (val :: FunPtr GLib.Callbacks.C_DestroyNotify)

clearClockEntryDestroyData :: MonadIO m => ClockEntry -> m ()
clearClockEntryDestroyData s = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 64) (FP.nullFunPtr :: FunPtr GLib.Callbacks.C_DestroyNotify)

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data ClockEntryDestroyDataFieldInfo
instance AttrInfo ClockEntryDestroyDataFieldInfo where
    type AttrAllowedOps ClockEntryDestroyDataFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint ClockEntryDestroyDataFieldInfo = (~) (FunPtr GLib.Callbacks.C_DestroyNotify)
    type AttrBaseTypeConstraint ClockEntryDestroyDataFieldInfo = (~) ClockEntry
    type AttrGetType ClockEntryDestroyDataFieldInfo = Maybe GLib.Callbacks.DestroyNotify
    type AttrLabel ClockEntryDestroyDataFieldInfo = "destroy_data"
    type AttrOrigin ClockEntryDestroyDataFieldInfo = ClockEntry
    attrGet _ = getClockEntryDestroyData
    attrSet _ = setClockEntryDestroyData
    attrConstruct = undefined
    attrClear _ = clearClockEntryDestroyData

clockEntry_destroyData :: AttrLabelProxy "destroyData"
clockEntry_destroyData = AttrLabelProxy

#endif


getClockEntryUnscheduled :: MonadIO m => ClockEntry -> m Bool
getClockEntryUnscheduled s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 72) :: IO CInt
    let val' = (/= 0) val
    return val'

setClockEntryUnscheduled :: MonadIO m => ClockEntry -> Bool -> m ()
setClockEntryUnscheduled s val = liftIO $ withManagedPtr s $ \ptr -> do
    let val' = (fromIntegral . fromEnum) val
    poke (ptr `plusPtr` 72) (val' :: CInt)

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data ClockEntryUnscheduledFieldInfo
instance AttrInfo ClockEntryUnscheduledFieldInfo where
    type AttrAllowedOps ClockEntryUnscheduledFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ClockEntryUnscheduledFieldInfo = (~) Bool
    type AttrBaseTypeConstraint ClockEntryUnscheduledFieldInfo = (~) ClockEntry
    type AttrGetType ClockEntryUnscheduledFieldInfo = Bool
    type AttrLabel ClockEntryUnscheduledFieldInfo = "unscheduled"
    type AttrOrigin ClockEntryUnscheduledFieldInfo = ClockEntry
    attrGet _ = getClockEntryUnscheduled
    attrSet _ = setClockEntryUnscheduled
    attrConstruct = undefined
    attrClear _ = undefined

clockEntry_unscheduled :: AttrLabelProxy "unscheduled"
clockEntry_unscheduled = AttrLabelProxy

#endif


getClockEntryWokenUp :: MonadIO m => ClockEntry -> m Bool
getClockEntryWokenUp s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 76) :: IO CInt
    let val' = (/= 0) val
    return val'

setClockEntryWokenUp :: MonadIO m => ClockEntry -> Bool -> m ()
setClockEntryWokenUp s val = liftIO $ withManagedPtr s $ \ptr -> do
    let val' = (fromIntegral . fromEnum) val
    poke (ptr `plusPtr` 76) (val' :: CInt)

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data ClockEntryWokenUpFieldInfo
instance AttrInfo ClockEntryWokenUpFieldInfo where
    type AttrAllowedOps ClockEntryWokenUpFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint ClockEntryWokenUpFieldInfo = (~) Bool
    type AttrBaseTypeConstraint ClockEntryWokenUpFieldInfo = (~) ClockEntry
    type AttrGetType ClockEntryWokenUpFieldInfo = Bool
    type AttrLabel ClockEntryWokenUpFieldInfo = "woken_up"
    type AttrOrigin ClockEntryWokenUpFieldInfo = ClockEntry
    attrGet _ = getClockEntryWokenUp
    attrSet _ = setClockEntryWokenUp
    attrConstruct = undefined
    attrClear _ = undefined

clockEntry_wokenUp :: AttrLabelProxy "wokenUp"
clockEntry_wokenUp = AttrLabelProxy

#endif



#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
instance O.HasAttributeList ClockEntry
type instance O.AttributeList ClockEntry = ClockEntryAttributeList
type ClockEntryAttributeList = ('[ '("refcount", ClockEntryRefcountFieldInfo), '("clock", ClockEntryClockFieldInfo), '("type", ClockEntryTypeFieldInfo), '("time", ClockEntryTimeFieldInfo), '("interval", ClockEntryIntervalFieldInfo), '("status", ClockEntryStatusFieldInfo), '("func", ClockEntryFuncFieldInfo), '("userData", ClockEntryUserDataFieldInfo), '("destroyData", ClockEntryDestroyDataFieldInfo), '("unscheduled", ClockEntryUnscheduledFieldInfo), '("wokenUp", ClockEntryWokenUpFieldInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
type family ResolveClockEntryMethod (t :: Symbol) (o :: *) :: * where
    ResolveClockEntryMethod l o = O.MethodResolutionFailed l o

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

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

#endif