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

This is the base class for audio sinks. Subclasses need to implement the
::create_ringbuffer vmethod. This base class will then take care of
writing samples to the ringbuffer, synchronisation, clipping and flushing.
-}

module GI.GstAudio.Objects.AudioBaseSink
    ( 

-- * Exported types
    AudioBaseSink(..)                       ,
    IsAudioBaseSink                         ,
    toAudioBaseSink                         ,
    noAudioBaseSink                         ,


 -- * Methods
-- ** createRingbuffer #method:createRingbuffer#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    AudioBaseSinkCreateRingbufferMethodInfo ,
#endif
    audioBaseSinkCreateRingbuffer           ,


-- ** getAlignmentThreshold #method:getAlignmentThreshold#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    AudioBaseSinkGetAlignmentThresholdMethodInfo,
#endif
    audioBaseSinkGetAlignmentThreshold      ,


-- ** getDiscontWait #method:getDiscontWait#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    AudioBaseSinkGetDiscontWaitMethodInfo   ,
#endif
    audioBaseSinkGetDiscontWait             ,


-- ** getDriftTolerance #method:getDriftTolerance#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    AudioBaseSinkGetDriftToleranceMethodInfo,
#endif
    audioBaseSinkGetDriftTolerance          ,


-- ** getProvideClock #method:getProvideClock#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    AudioBaseSinkGetProvideClockMethodInfo  ,
#endif
    audioBaseSinkGetProvideClock            ,


-- ** getSlaveMethod #method:getSlaveMethod#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    AudioBaseSinkGetSlaveMethodMethodInfo   ,
#endif
    audioBaseSinkGetSlaveMethod             ,


-- ** reportDeviceFailure #method:reportDeviceFailure#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    AudioBaseSinkReportDeviceFailureMethodInfo,
#endif
    audioBaseSinkReportDeviceFailure        ,


-- ** setAlignmentThreshold #method:setAlignmentThreshold#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    AudioBaseSinkSetAlignmentThresholdMethodInfo,
#endif
    audioBaseSinkSetAlignmentThreshold      ,


-- ** setCustomSlavingCallback #method:setCustomSlavingCallback#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    AudioBaseSinkSetCustomSlavingCallbackMethodInfo,
#endif
    audioBaseSinkSetCustomSlavingCallback   ,


-- ** setDiscontWait #method:setDiscontWait#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    AudioBaseSinkSetDiscontWaitMethodInfo   ,
#endif
    audioBaseSinkSetDiscontWait             ,


-- ** setDriftTolerance #method:setDriftTolerance#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    AudioBaseSinkSetDriftToleranceMethodInfo,
#endif
    audioBaseSinkSetDriftTolerance          ,


-- ** setProvideClock #method:setProvideClock#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    AudioBaseSinkSetProvideClockMethodInfo  ,
#endif
    audioBaseSinkSetProvideClock            ,


-- ** setSlaveMethod #method:setSlaveMethod#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    AudioBaseSinkSetSlaveMethodMethodInfo   ,
#endif
    audioBaseSinkSetSlaveMethod             ,




 -- * Properties
-- ** alignmentThreshold #attr:alignmentThreshold#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    AudioBaseSinkAlignmentThresholdPropertyInfo,
#endif
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    audioBaseSinkAlignmentThreshold         ,
#endif
    constructAudioBaseSinkAlignmentThreshold,
    getAudioBaseSinkAlignmentThreshold      ,
    setAudioBaseSinkAlignmentThreshold      ,


-- ** bufferTime #attr:bufferTime#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    AudioBaseSinkBufferTimePropertyInfo     ,
#endif
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    audioBaseSinkBufferTime                 ,
#endif
    constructAudioBaseSinkBufferTime        ,
    getAudioBaseSinkBufferTime              ,
    setAudioBaseSinkBufferTime              ,


-- ** canActivatePull #attr:canActivatePull#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    AudioBaseSinkCanActivatePullPropertyInfo,
#endif
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    audioBaseSinkCanActivatePull            ,
#endif
    constructAudioBaseSinkCanActivatePull   ,
    getAudioBaseSinkCanActivatePull         ,
    setAudioBaseSinkCanActivatePull         ,


-- ** discontWait #attr:discontWait#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    AudioBaseSinkDiscontWaitPropertyInfo    ,
#endif
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    audioBaseSinkDiscontWait                ,
#endif
    constructAudioBaseSinkDiscontWait       ,
    getAudioBaseSinkDiscontWait             ,
    setAudioBaseSinkDiscontWait             ,


-- ** driftTolerance #attr:driftTolerance#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    AudioBaseSinkDriftTolerancePropertyInfo ,
#endif
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    audioBaseSinkDriftTolerance             ,
#endif
    constructAudioBaseSinkDriftTolerance    ,
    getAudioBaseSinkDriftTolerance          ,
    setAudioBaseSinkDriftTolerance          ,


-- ** latencyTime #attr:latencyTime#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    AudioBaseSinkLatencyTimePropertyInfo    ,
#endif
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    audioBaseSinkLatencyTime                ,
#endif
    constructAudioBaseSinkLatencyTime       ,
    getAudioBaseSinkLatencyTime             ,
    setAudioBaseSinkLatencyTime             ,


-- ** provideClock #attr:provideClock#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    AudioBaseSinkProvideClockPropertyInfo   ,
#endif
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    audioBaseSinkProvideClock               ,
#endif
    constructAudioBaseSinkProvideClock      ,
    getAudioBaseSinkProvideClock            ,
    setAudioBaseSinkProvideClock            ,


-- ** slaveMethod #attr:slaveMethod#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    AudioBaseSinkSlaveMethodPropertyInfo    ,
#endif
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    audioBaseSinkSlaveMethod                ,
#endif
    constructAudioBaseSinkSlaveMethod       ,
    getAudioBaseSinkSlaveMethod             ,
    setAudioBaseSinkSlaveMethod             ,




    ) 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.GObject.Objects.Object as GObject.Object
import qualified GI.Gst.Objects.Element as Gst.Element
import qualified GI.Gst.Objects.Object as Gst.Object
import qualified GI.GstAudio.Callbacks as GstAudio.Callbacks
import {-# SOURCE #-} qualified GI.GstAudio.Enums as GstAudio.Enums
import {-# SOURCE #-} qualified GI.GstAudio.Objects.AudioRingBuffer as GstAudio.AudioRingBuffer
import qualified GI.GstBase.Objects.BaseSink as GstBase.BaseSink

newtype AudioBaseSink = AudioBaseSink (ManagedPtr AudioBaseSink)
foreign import ccall "gst_audio_base_sink_get_type"
    c_gst_audio_base_sink_get_type :: IO GType

instance GObject AudioBaseSink where
    gobjectType _ = c_gst_audio_base_sink_get_type
    

class GObject o => IsAudioBaseSink o
#if MIN_VERSION_base(4,9,0)
instance {-# OVERLAPPABLE #-} (GObject a, O.UnknownAncestorError AudioBaseSink a) =>
    IsAudioBaseSink a
#endif
instance IsAudioBaseSink AudioBaseSink
instance GstBase.BaseSink.IsBaseSink AudioBaseSink
instance Gst.Element.IsElement AudioBaseSink
instance Gst.Object.IsObject AudioBaseSink
instance GObject.Object.IsObject AudioBaseSink

toAudioBaseSink :: (MonadIO m, IsAudioBaseSink o) => o -> m AudioBaseSink
toAudioBaseSink = liftIO . unsafeCastTo AudioBaseSink

noAudioBaseSink :: Maybe AudioBaseSink
noAudioBaseSink = Nothing

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
type family ResolveAudioBaseSinkMethod (t :: Symbol) (o :: *) :: * where
    ResolveAudioBaseSinkMethod "abortState" o = Gst.Element.ElementAbortStateMethodInfo
    ResolveAudioBaseSinkMethod "addControlBinding" o = Gst.Object.ObjectAddControlBindingMethodInfo
    ResolveAudioBaseSinkMethod "addPad" o = Gst.Element.ElementAddPadMethodInfo
    ResolveAudioBaseSinkMethod "addPropertyDeepNotifyWatch" o = Gst.Element.ElementAddPropertyDeepNotifyWatchMethodInfo
    ResolveAudioBaseSinkMethod "addPropertyNotifyWatch" o = Gst.Element.ElementAddPropertyNotifyWatchMethodInfo
    ResolveAudioBaseSinkMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveAudioBaseSinkMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveAudioBaseSinkMethod "callAsync" o = Gst.Element.ElementCallAsyncMethodInfo
    ResolveAudioBaseSinkMethod "changeState" o = Gst.Element.ElementChangeStateMethodInfo
    ResolveAudioBaseSinkMethod "continueState" o = Gst.Element.ElementContinueStateMethodInfo
    ResolveAudioBaseSinkMethod "createAllPads" o = Gst.Element.ElementCreateAllPadsMethodInfo
    ResolveAudioBaseSinkMethod "createRingbuffer" o = AudioBaseSinkCreateRingbufferMethodInfo
    ResolveAudioBaseSinkMethod "defaultError" o = Gst.Object.ObjectDefaultErrorMethodInfo
    ResolveAudioBaseSinkMethod "doPreroll" o = GstBase.BaseSink.BaseSinkDoPrerollMethodInfo
    ResolveAudioBaseSinkMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveAudioBaseSinkMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveAudioBaseSinkMethod "hasActiveControlBindings" o = Gst.Object.ObjectHasActiveControlBindingsMethodInfo
    ResolveAudioBaseSinkMethod "hasAncestor" o = Gst.Object.ObjectHasAncestorMethodInfo
    ResolveAudioBaseSinkMethod "hasAsAncestor" o = Gst.Object.ObjectHasAsAncestorMethodInfo
    ResolveAudioBaseSinkMethod "hasAsParent" o = Gst.Object.ObjectHasAsParentMethodInfo
    ResolveAudioBaseSinkMethod "isAsyncEnabled" o = GstBase.BaseSink.BaseSinkIsAsyncEnabledMethodInfo
    ResolveAudioBaseSinkMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveAudioBaseSinkMethod "isLastSampleEnabled" o = GstBase.BaseSink.BaseSinkIsLastSampleEnabledMethodInfo
    ResolveAudioBaseSinkMethod "isLockedState" o = Gst.Element.ElementIsLockedStateMethodInfo
    ResolveAudioBaseSinkMethod "isQosEnabled" o = GstBase.BaseSink.BaseSinkIsQosEnabledMethodInfo
    ResolveAudioBaseSinkMethod "iteratePads" o = Gst.Element.ElementIteratePadsMethodInfo
    ResolveAudioBaseSinkMethod "iterateSinkPads" o = Gst.Element.ElementIterateSinkPadsMethodInfo
    ResolveAudioBaseSinkMethod "iterateSrcPads" o = Gst.Element.ElementIterateSrcPadsMethodInfo
    ResolveAudioBaseSinkMethod "link" o = Gst.Element.ElementLinkMethodInfo
    ResolveAudioBaseSinkMethod "linkFiltered" o = Gst.Element.ElementLinkFilteredMethodInfo
    ResolveAudioBaseSinkMethod "linkPads" o = Gst.Element.ElementLinkPadsMethodInfo
    ResolveAudioBaseSinkMethod "linkPadsFiltered" o = Gst.Element.ElementLinkPadsFilteredMethodInfo
    ResolveAudioBaseSinkMethod "linkPadsFull" o = Gst.Element.ElementLinkPadsFullMethodInfo
    ResolveAudioBaseSinkMethod "lostState" o = Gst.Element.ElementLostStateMethodInfo
    ResolveAudioBaseSinkMethod "messageFull" o = Gst.Element.ElementMessageFullMethodInfo
    ResolveAudioBaseSinkMethod "messageFullWithDetails" o = Gst.Element.ElementMessageFullWithDetailsMethodInfo
    ResolveAudioBaseSinkMethod "noMorePads" o = Gst.Element.ElementNoMorePadsMethodInfo
    ResolveAudioBaseSinkMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveAudioBaseSinkMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveAudioBaseSinkMethod "postMessage" o = Gst.Element.ElementPostMessageMethodInfo
    ResolveAudioBaseSinkMethod "provideClock" o = Gst.Element.ElementProvideClockMethodInfo
    ResolveAudioBaseSinkMethod "query" o = Gst.Element.ElementQueryMethodInfo
    ResolveAudioBaseSinkMethod "queryConvert" o = Gst.Element.ElementQueryConvertMethodInfo
    ResolveAudioBaseSinkMethod "queryDuration" o = Gst.Element.ElementQueryDurationMethodInfo
    ResolveAudioBaseSinkMethod "queryLatency" o = GstBase.BaseSink.BaseSinkQueryLatencyMethodInfo
    ResolveAudioBaseSinkMethod "queryPosition" o = Gst.Element.ElementQueryPositionMethodInfo
    ResolveAudioBaseSinkMethod "ref" o = Gst.Object.ObjectRefMethodInfo
    ResolveAudioBaseSinkMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveAudioBaseSinkMethod "releaseRequestPad" o = Gst.Element.ElementReleaseRequestPadMethodInfo
    ResolveAudioBaseSinkMethod "removeControlBinding" o = Gst.Object.ObjectRemoveControlBindingMethodInfo
    ResolveAudioBaseSinkMethod "removePad" o = Gst.Element.ElementRemovePadMethodInfo
    ResolveAudioBaseSinkMethod "removePropertyNotifyWatch" o = Gst.Element.ElementRemovePropertyNotifyWatchMethodInfo
    ResolveAudioBaseSinkMethod "replaceData" o = GObject.Object.ObjectReplaceDataMethodInfo
    ResolveAudioBaseSinkMethod "replaceQdata" o = GObject.Object.ObjectReplaceQdataMethodInfo
    ResolveAudioBaseSinkMethod "reportDeviceFailure" o = AudioBaseSinkReportDeviceFailureMethodInfo
    ResolveAudioBaseSinkMethod "requestPad" o = Gst.Element.ElementRequestPadMethodInfo
    ResolveAudioBaseSinkMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveAudioBaseSinkMethod "seek" o = Gst.Element.ElementSeekMethodInfo
    ResolveAudioBaseSinkMethod "seekSimple" o = Gst.Element.ElementSeekSimpleMethodInfo
    ResolveAudioBaseSinkMethod "sendEvent" o = Gst.Element.ElementSendEventMethodInfo
    ResolveAudioBaseSinkMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveAudioBaseSinkMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveAudioBaseSinkMethod "suggestNextSync" o = Gst.Object.ObjectSuggestNextSyncMethodInfo
    ResolveAudioBaseSinkMethod "syncStateWithParent" o = Gst.Element.ElementSyncStateWithParentMethodInfo
    ResolveAudioBaseSinkMethod "syncValues" o = Gst.Object.ObjectSyncValuesMethodInfo
    ResolveAudioBaseSinkMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveAudioBaseSinkMethod "unlink" o = Gst.Element.ElementUnlinkMethodInfo
    ResolveAudioBaseSinkMethod "unlinkPads" o = Gst.Element.ElementUnlinkPadsMethodInfo
    ResolveAudioBaseSinkMethod "unparent" o = Gst.Object.ObjectUnparentMethodInfo
    ResolveAudioBaseSinkMethod "unref" o = Gst.Object.ObjectUnrefMethodInfo
    ResolveAudioBaseSinkMethod "wait" o = GstBase.BaseSink.BaseSinkWaitMethodInfo
    ResolveAudioBaseSinkMethod "waitClock" o = GstBase.BaseSink.BaseSinkWaitClockMethodInfo
    ResolveAudioBaseSinkMethod "waitPreroll" o = GstBase.BaseSink.BaseSinkWaitPrerollMethodInfo
    ResolveAudioBaseSinkMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveAudioBaseSinkMethod "getAlignmentThreshold" o = AudioBaseSinkGetAlignmentThresholdMethodInfo
    ResolveAudioBaseSinkMethod "getBaseTime" o = Gst.Element.ElementGetBaseTimeMethodInfo
    ResolveAudioBaseSinkMethod "getBlocksize" o = GstBase.BaseSink.BaseSinkGetBlocksizeMethodInfo
    ResolveAudioBaseSinkMethod "getBus" o = Gst.Element.ElementGetBusMethodInfo
    ResolveAudioBaseSinkMethod "getClock" o = Gst.Element.ElementGetClockMethodInfo
    ResolveAudioBaseSinkMethod "getCompatiblePad" o = Gst.Element.ElementGetCompatiblePadMethodInfo
    ResolveAudioBaseSinkMethod "getCompatiblePadTemplate" o = Gst.Element.ElementGetCompatiblePadTemplateMethodInfo
    ResolveAudioBaseSinkMethod "getContext" o = Gst.Element.ElementGetContextMethodInfo
    ResolveAudioBaseSinkMethod "getContextUnlocked" o = Gst.Element.ElementGetContextUnlockedMethodInfo
    ResolveAudioBaseSinkMethod "getContexts" o = Gst.Element.ElementGetContextsMethodInfo
    ResolveAudioBaseSinkMethod "getControlBinding" o = Gst.Object.ObjectGetControlBindingMethodInfo
    ResolveAudioBaseSinkMethod "getControlRate" o = Gst.Object.ObjectGetControlRateMethodInfo
    ResolveAudioBaseSinkMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveAudioBaseSinkMethod "getDiscontWait" o = AudioBaseSinkGetDiscontWaitMethodInfo
    ResolveAudioBaseSinkMethod "getDriftTolerance" o = AudioBaseSinkGetDriftToleranceMethodInfo
    ResolveAudioBaseSinkMethod "getDropOutOfSegment" o = GstBase.BaseSink.BaseSinkGetDropOutOfSegmentMethodInfo
    ResolveAudioBaseSinkMethod "getFactory" o = Gst.Element.ElementGetFactoryMethodInfo
    ResolveAudioBaseSinkMethod "getGValueArray" o = Gst.Object.ObjectGetGValueArrayMethodInfo
    ResolveAudioBaseSinkMethod "getLastSample" o = GstBase.BaseSink.BaseSinkGetLastSampleMethodInfo
    ResolveAudioBaseSinkMethod "getLatency" o = GstBase.BaseSink.BaseSinkGetLatencyMethodInfo
    ResolveAudioBaseSinkMethod "getMaxBitrate" o = GstBase.BaseSink.BaseSinkGetMaxBitrateMethodInfo
    ResolveAudioBaseSinkMethod "getMaxLateness" o = GstBase.BaseSink.BaseSinkGetMaxLatenessMethodInfo
    ResolveAudioBaseSinkMethod "getName" o = Gst.Object.ObjectGetNameMethodInfo
    ResolveAudioBaseSinkMethod "getParent" o = Gst.Object.ObjectGetParentMethodInfo
    ResolveAudioBaseSinkMethod "getPathString" o = Gst.Object.ObjectGetPathStringMethodInfo
    ResolveAudioBaseSinkMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveAudioBaseSinkMethod "getProvideClock" o = AudioBaseSinkGetProvideClockMethodInfo
    ResolveAudioBaseSinkMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveAudioBaseSinkMethod "getRenderDelay" o = GstBase.BaseSink.BaseSinkGetRenderDelayMethodInfo
    ResolveAudioBaseSinkMethod "getRequestPad" o = Gst.Element.ElementGetRequestPadMethodInfo
    ResolveAudioBaseSinkMethod "getSlaveMethod" o = AudioBaseSinkGetSlaveMethodMethodInfo
    ResolveAudioBaseSinkMethod "getStartTime" o = Gst.Element.ElementGetStartTimeMethodInfo
    ResolveAudioBaseSinkMethod "getState" o = Gst.Element.ElementGetStateMethodInfo
    ResolveAudioBaseSinkMethod "getStaticPad" o = Gst.Element.ElementGetStaticPadMethodInfo
    ResolveAudioBaseSinkMethod "getSync" o = GstBase.BaseSink.BaseSinkGetSyncMethodInfo
    ResolveAudioBaseSinkMethod "getThrottleTime" o = GstBase.BaseSink.BaseSinkGetThrottleTimeMethodInfo
    ResolveAudioBaseSinkMethod "getTsOffset" o = GstBase.BaseSink.BaseSinkGetTsOffsetMethodInfo
    ResolveAudioBaseSinkMethod "getValue" o = Gst.Object.ObjectGetValueMethodInfo
    ResolveAudioBaseSinkMethod "setAlignmentThreshold" o = AudioBaseSinkSetAlignmentThresholdMethodInfo
    ResolveAudioBaseSinkMethod "setAsyncEnabled" o = GstBase.BaseSink.BaseSinkSetAsyncEnabledMethodInfo
    ResolveAudioBaseSinkMethod "setBaseTime" o = Gst.Element.ElementSetBaseTimeMethodInfo
    ResolveAudioBaseSinkMethod "setBlocksize" o = GstBase.BaseSink.BaseSinkSetBlocksizeMethodInfo
    ResolveAudioBaseSinkMethod "setBus" o = Gst.Element.ElementSetBusMethodInfo
    ResolveAudioBaseSinkMethod "setClock" o = Gst.Element.ElementSetClockMethodInfo
    ResolveAudioBaseSinkMethod "setContext" o = Gst.Element.ElementSetContextMethodInfo
    ResolveAudioBaseSinkMethod "setControlBindingDisabled" o = Gst.Object.ObjectSetControlBindingDisabledMethodInfo
    ResolveAudioBaseSinkMethod "setControlBindingsDisabled" o = Gst.Object.ObjectSetControlBindingsDisabledMethodInfo
    ResolveAudioBaseSinkMethod "setControlRate" o = Gst.Object.ObjectSetControlRateMethodInfo
    ResolveAudioBaseSinkMethod "setCustomSlavingCallback" o = AudioBaseSinkSetCustomSlavingCallbackMethodInfo
    ResolveAudioBaseSinkMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveAudioBaseSinkMethod "setDiscontWait" o = AudioBaseSinkSetDiscontWaitMethodInfo
    ResolveAudioBaseSinkMethod "setDriftTolerance" o = AudioBaseSinkSetDriftToleranceMethodInfo
    ResolveAudioBaseSinkMethod "setDropOutOfSegment" o = GstBase.BaseSink.BaseSinkSetDropOutOfSegmentMethodInfo
    ResolveAudioBaseSinkMethod "setLastSampleEnabled" o = GstBase.BaseSink.BaseSinkSetLastSampleEnabledMethodInfo
    ResolveAudioBaseSinkMethod "setLockedState" o = Gst.Element.ElementSetLockedStateMethodInfo
    ResolveAudioBaseSinkMethod "setMaxBitrate" o = GstBase.BaseSink.BaseSinkSetMaxBitrateMethodInfo
    ResolveAudioBaseSinkMethod "setMaxLateness" o = GstBase.BaseSink.BaseSinkSetMaxLatenessMethodInfo
    ResolveAudioBaseSinkMethod "setName" o = Gst.Object.ObjectSetNameMethodInfo
    ResolveAudioBaseSinkMethod "setParent" o = Gst.Object.ObjectSetParentMethodInfo
    ResolveAudioBaseSinkMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveAudioBaseSinkMethod "setProvideClock" o = AudioBaseSinkSetProvideClockMethodInfo
    ResolveAudioBaseSinkMethod "setQosEnabled" o = GstBase.BaseSink.BaseSinkSetQosEnabledMethodInfo
    ResolveAudioBaseSinkMethod "setRenderDelay" o = GstBase.BaseSink.BaseSinkSetRenderDelayMethodInfo
    ResolveAudioBaseSinkMethod "setSlaveMethod" o = AudioBaseSinkSetSlaveMethodMethodInfo
    ResolveAudioBaseSinkMethod "setStartTime" o = Gst.Element.ElementSetStartTimeMethodInfo
    ResolveAudioBaseSinkMethod "setState" o = Gst.Element.ElementSetStateMethodInfo
    ResolveAudioBaseSinkMethod "setSync" o = GstBase.BaseSink.BaseSinkSetSyncMethodInfo
    ResolveAudioBaseSinkMethod "setThrottleTime" o = GstBase.BaseSink.BaseSinkSetThrottleTimeMethodInfo
    ResolveAudioBaseSinkMethod "setTsOffset" o = GstBase.BaseSink.BaseSinkSetTsOffsetMethodInfo
    ResolveAudioBaseSinkMethod l o = O.MethodResolutionFailed l o

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

#if MIN_VERSION_base(4,9,0)
instance (info ~ ResolveAudioBaseSinkMethod t AudioBaseSink, O.MethodInfo info AudioBaseSink p) => O.IsLabel t (AudioBaseSink -> 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

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

getAudioBaseSinkAlignmentThreshold :: (MonadIO m, IsAudioBaseSink o) => o -> m Word64
getAudioBaseSinkAlignmentThreshold obj = liftIO $ getObjectPropertyUInt64 obj "alignment-threshold"

setAudioBaseSinkAlignmentThreshold :: (MonadIO m, IsAudioBaseSink o) => o -> Word64 -> m ()
setAudioBaseSinkAlignmentThreshold obj val = liftIO $ setObjectPropertyUInt64 obj "alignment-threshold" val

constructAudioBaseSinkAlignmentThreshold :: (IsAudioBaseSink o) => Word64 -> IO (GValueConstruct o)
constructAudioBaseSinkAlignmentThreshold val = constructObjectPropertyUInt64 "alignment-threshold" val

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data AudioBaseSinkAlignmentThresholdPropertyInfo
instance AttrInfo AudioBaseSinkAlignmentThresholdPropertyInfo where
    type AttrAllowedOps AudioBaseSinkAlignmentThresholdPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint AudioBaseSinkAlignmentThresholdPropertyInfo = (~) Word64
    type AttrBaseTypeConstraint AudioBaseSinkAlignmentThresholdPropertyInfo = IsAudioBaseSink
    type AttrGetType AudioBaseSinkAlignmentThresholdPropertyInfo = Word64
    type AttrLabel AudioBaseSinkAlignmentThresholdPropertyInfo = "alignment-threshold"
    type AttrOrigin AudioBaseSinkAlignmentThresholdPropertyInfo = AudioBaseSink
    attrGet _ = getAudioBaseSinkAlignmentThreshold
    attrSet _ = setAudioBaseSinkAlignmentThreshold
    attrConstruct _ = constructAudioBaseSinkAlignmentThreshold
    attrClear _ = undefined
#endif

-- VVV Prop "buffer-time"
   -- Type: TBasicType TInt64
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

getAudioBaseSinkBufferTime :: (MonadIO m, IsAudioBaseSink o) => o -> m Int64
getAudioBaseSinkBufferTime obj = liftIO $ getObjectPropertyInt64 obj "buffer-time"

setAudioBaseSinkBufferTime :: (MonadIO m, IsAudioBaseSink o) => o -> Int64 -> m ()
setAudioBaseSinkBufferTime obj val = liftIO $ setObjectPropertyInt64 obj "buffer-time" val

constructAudioBaseSinkBufferTime :: (IsAudioBaseSink o) => Int64 -> IO (GValueConstruct o)
constructAudioBaseSinkBufferTime val = constructObjectPropertyInt64 "buffer-time" val

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data AudioBaseSinkBufferTimePropertyInfo
instance AttrInfo AudioBaseSinkBufferTimePropertyInfo where
    type AttrAllowedOps AudioBaseSinkBufferTimePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint AudioBaseSinkBufferTimePropertyInfo = (~) Int64
    type AttrBaseTypeConstraint AudioBaseSinkBufferTimePropertyInfo = IsAudioBaseSink
    type AttrGetType AudioBaseSinkBufferTimePropertyInfo = Int64
    type AttrLabel AudioBaseSinkBufferTimePropertyInfo = "buffer-time"
    type AttrOrigin AudioBaseSinkBufferTimePropertyInfo = AudioBaseSink
    attrGet _ = getAudioBaseSinkBufferTime
    attrSet _ = setAudioBaseSinkBufferTime
    attrConstruct _ = constructAudioBaseSinkBufferTime
    attrClear _ = undefined
#endif

-- VVV Prop "can-activate-pull"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

getAudioBaseSinkCanActivatePull :: (MonadIO m, IsAudioBaseSink o) => o -> m Bool
getAudioBaseSinkCanActivatePull obj = liftIO $ getObjectPropertyBool obj "can-activate-pull"

setAudioBaseSinkCanActivatePull :: (MonadIO m, IsAudioBaseSink o) => o -> Bool -> m ()
setAudioBaseSinkCanActivatePull obj val = liftIO $ setObjectPropertyBool obj "can-activate-pull" val

constructAudioBaseSinkCanActivatePull :: (IsAudioBaseSink o) => Bool -> IO (GValueConstruct o)
constructAudioBaseSinkCanActivatePull val = constructObjectPropertyBool "can-activate-pull" val

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data AudioBaseSinkCanActivatePullPropertyInfo
instance AttrInfo AudioBaseSinkCanActivatePullPropertyInfo where
    type AttrAllowedOps AudioBaseSinkCanActivatePullPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint AudioBaseSinkCanActivatePullPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint AudioBaseSinkCanActivatePullPropertyInfo = IsAudioBaseSink
    type AttrGetType AudioBaseSinkCanActivatePullPropertyInfo = Bool
    type AttrLabel AudioBaseSinkCanActivatePullPropertyInfo = "can-activate-pull"
    type AttrOrigin AudioBaseSinkCanActivatePullPropertyInfo = AudioBaseSink
    attrGet _ = getAudioBaseSinkCanActivatePull
    attrSet _ = setAudioBaseSinkCanActivatePull
    attrConstruct _ = constructAudioBaseSinkCanActivatePull
    attrClear _ = undefined
#endif

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

getAudioBaseSinkDiscontWait :: (MonadIO m, IsAudioBaseSink o) => o -> m Word64
getAudioBaseSinkDiscontWait obj = liftIO $ getObjectPropertyUInt64 obj "discont-wait"

setAudioBaseSinkDiscontWait :: (MonadIO m, IsAudioBaseSink o) => o -> Word64 -> m ()
setAudioBaseSinkDiscontWait obj val = liftIO $ setObjectPropertyUInt64 obj "discont-wait" val

constructAudioBaseSinkDiscontWait :: (IsAudioBaseSink o) => Word64 -> IO (GValueConstruct o)
constructAudioBaseSinkDiscontWait val = constructObjectPropertyUInt64 "discont-wait" val

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data AudioBaseSinkDiscontWaitPropertyInfo
instance AttrInfo AudioBaseSinkDiscontWaitPropertyInfo where
    type AttrAllowedOps AudioBaseSinkDiscontWaitPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint AudioBaseSinkDiscontWaitPropertyInfo = (~) Word64
    type AttrBaseTypeConstraint AudioBaseSinkDiscontWaitPropertyInfo = IsAudioBaseSink
    type AttrGetType AudioBaseSinkDiscontWaitPropertyInfo = Word64
    type AttrLabel AudioBaseSinkDiscontWaitPropertyInfo = "discont-wait"
    type AttrOrigin AudioBaseSinkDiscontWaitPropertyInfo = AudioBaseSink
    attrGet _ = getAudioBaseSinkDiscontWait
    attrSet _ = setAudioBaseSinkDiscontWait
    attrConstruct _ = constructAudioBaseSinkDiscontWait
    attrClear _ = undefined
#endif

-- VVV Prop "drift-tolerance"
   -- Type: TBasicType TInt64
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getAudioBaseSinkDriftTolerance :: (MonadIO m, IsAudioBaseSink o) => o -> m Int64
getAudioBaseSinkDriftTolerance obj = liftIO $ getObjectPropertyInt64 obj "drift-tolerance"

setAudioBaseSinkDriftTolerance :: (MonadIO m, IsAudioBaseSink o) => o -> Int64 -> m ()
setAudioBaseSinkDriftTolerance obj val = liftIO $ setObjectPropertyInt64 obj "drift-tolerance" val

constructAudioBaseSinkDriftTolerance :: (IsAudioBaseSink o) => Int64 -> IO (GValueConstruct o)
constructAudioBaseSinkDriftTolerance val = constructObjectPropertyInt64 "drift-tolerance" val

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data AudioBaseSinkDriftTolerancePropertyInfo
instance AttrInfo AudioBaseSinkDriftTolerancePropertyInfo where
    type AttrAllowedOps AudioBaseSinkDriftTolerancePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint AudioBaseSinkDriftTolerancePropertyInfo = (~) Int64
    type AttrBaseTypeConstraint AudioBaseSinkDriftTolerancePropertyInfo = IsAudioBaseSink
    type AttrGetType AudioBaseSinkDriftTolerancePropertyInfo = Int64
    type AttrLabel AudioBaseSinkDriftTolerancePropertyInfo = "drift-tolerance"
    type AttrOrigin AudioBaseSinkDriftTolerancePropertyInfo = AudioBaseSink
    attrGet _ = getAudioBaseSinkDriftTolerance
    attrSet _ = setAudioBaseSinkDriftTolerance
    attrConstruct _ = constructAudioBaseSinkDriftTolerance
    attrClear _ = undefined
#endif

-- VVV Prop "latency-time"
   -- Type: TBasicType TInt64
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Nothing)

getAudioBaseSinkLatencyTime :: (MonadIO m, IsAudioBaseSink o) => o -> m Int64
getAudioBaseSinkLatencyTime obj = liftIO $ getObjectPropertyInt64 obj "latency-time"

setAudioBaseSinkLatencyTime :: (MonadIO m, IsAudioBaseSink o) => o -> Int64 -> m ()
setAudioBaseSinkLatencyTime obj val = liftIO $ setObjectPropertyInt64 obj "latency-time" val

constructAudioBaseSinkLatencyTime :: (IsAudioBaseSink o) => Int64 -> IO (GValueConstruct o)
constructAudioBaseSinkLatencyTime val = constructObjectPropertyInt64 "latency-time" val

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data AudioBaseSinkLatencyTimePropertyInfo
instance AttrInfo AudioBaseSinkLatencyTimePropertyInfo where
    type AttrAllowedOps AudioBaseSinkLatencyTimePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint AudioBaseSinkLatencyTimePropertyInfo = (~) Int64
    type AttrBaseTypeConstraint AudioBaseSinkLatencyTimePropertyInfo = IsAudioBaseSink
    type AttrGetType AudioBaseSinkLatencyTimePropertyInfo = Int64
    type AttrLabel AudioBaseSinkLatencyTimePropertyInfo = "latency-time"
    type AttrOrigin AudioBaseSinkLatencyTimePropertyInfo = AudioBaseSink
    attrGet _ = getAudioBaseSinkLatencyTime
    attrSet _ = setAudioBaseSinkLatencyTime
    attrConstruct _ = constructAudioBaseSinkLatencyTime
    attrClear _ = undefined
#endif

-- VVV Prop "provide-clock"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getAudioBaseSinkProvideClock :: (MonadIO m, IsAudioBaseSink o) => o -> m Bool
getAudioBaseSinkProvideClock obj = liftIO $ getObjectPropertyBool obj "provide-clock"

setAudioBaseSinkProvideClock :: (MonadIO m, IsAudioBaseSink o) => o -> Bool -> m ()
setAudioBaseSinkProvideClock obj val = liftIO $ setObjectPropertyBool obj "provide-clock" val

constructAudioBaseSinkProvideClock :: (IsAudioBaseSink o) => Bool -> IO (GValueConstruct o)
constructAudioBaseSinkProvideClock val = constructObjectPropertyBool "provide-clock" val

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data AudioBaseSinkProvideClockPropertyInfo
instance AttrInfo AudioBaseSinkProvideClockPropertyInfo where
    type AttrAllowedOps AudioBaseSinkProvideClockPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint AudioBaseSinkProvideClockPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint AudioBaseSinkProvideClockPropertyInfo = IsAudioBaseSink
    type AttrGetType AudioBaseSinkProvideClockPropertyInfo = Bool
    type AttrLabel AudioBaseSinkProvideClockPropertyInfo = "provide-clock"
    type AttrOrigin AudioBaseSinkProvideClockPropertyInfo = AudioBaseSink
    attrGet _ = getAudioBaseSinkProvideClock
    attrSet _ = setAudioBaseSinkProvideClock
    attrConstruct _ = constructAudioBaseSinkProvideClock
    attrClear _ = undefined
#endif

-- VVV Prop "slave-method"
   -- Type: TInterface (Name {namespace = "GstAudio", name = "AudioBaseSinkSlaveMethod"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getAudioBaseSinkSlaveMethod :: (MonadIO m, IsAudioBaseSink o) => o -> m GstAudio.Enums.AudioBaseSinkSlaveMethod
getAudioBaseSinkSlaveMethod obj = liftIO $ getObjectPropertyEnum obj "slave-method"

setAudioBaseSinkSlaveMethod :: (MonadIO m, IsAudioBaseSink o) => o -> GstAudio.Enums.AudioBaseSinkSlaveMethod -> m ()
setAudioBaseSinkSlaveMethod obj val = liftIO $ setObjectPropertyEnum obj "slave-method" val

constructAudioBaseSinkSlaveMethod :: (IsAudioBaseSink o) => GstAudio.Enums.AudioBaseSinkSlaveMethod -> IO (GValueConstruct o)
constructAudioBaseSinkSlaveMethod val = constructObjectPropertyEnum "slave-method" val

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data AudioBaseSinkSlaveMethodPropertyInfo
instance AttrInfo AudioBaseSinkSlaveMethodPropertyInfo where
    type AttrAllowedOps AudioBaseSinkSlaveMethodPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint AudioBaseSinkSlaveMethodPropertyInfo = (~) GstAudio.Enums.AudioBaseSinkSlaveMethod
    type AttrBaseTypeConstraint AudioBaseSinkSlaveMethodPropertyInfo = IsAudioBaseSink
    type AttrGetType AudioBaseSinkSlaveMethodPropertyInfo = GstAudio.Enums.AudioBaseSinkSlaveMethod
    type AttrLabel AudioBaseSinkSlaveMethodPropertyInfo = "slave-method"
    type AttrOrigin AudioBaseSinkSlaveMethodPropertyInfo = AudioBaseSink
    attrGet _ = getAudioBaseSinkSlaveMethod
    attrSet _ = setAudioBaseSinkSlaveMethod
    attrConstruct _ = constructAudioBaseSinkSlaveMethod
    attrClear _ = undefined
#endif

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
instance O.HasAttributeList AudioBaseSink
type instance O.AttributeList AudioBaseSink = AudioBaseSinkAttributeList
type AudioBaseSinkAttributeList = ('[ '("alignmentThreshold", AudioBaseSinkAlignmentThresholdPropertyInfo), '("async", GstBase.BaseSink.BaseSinkAsyncPropertyInfo), '("blocksize", GstBase.BaseSink.BaseSinkBlocksizePropertyInfo), '("bufferTime", AudioBaseSinkBufferTimePropertyInfo), '("canActivatePull", AudioBaseSinkCanActivatePullPropertyInfo), '("discontWait", AudioBaseSinkDiscontWaitPropertyInfo), '("driftTolerance", AudioBaseSinkDriftTolerancePropertyInfo), '("enableLastSample", GstBase.BaseSink.BaseSinkEnableLastSamplePropertyInfo), '("lastSample", GstBase.BaseSink.BaseSinkLastSamplePropertyInfo), '("latencyTime", AudioBaseSinkLatencyTimePropertyInfo), '("maxBitrate", GstBase.BaseSink.BaseSinkMaxBitratePropertyInfo), '("maxLateness", GstBase.BaseSink.BaseSinkMaxLatenessPropertyInfo), '("name", Gst.Object.ObjectNamePropertyInfo), '("parent", Gst.Object.ObjectParentPropertyInfo), '("provideClock", AudioBaseSinkProvideClockPropertyInfo), '("qos", GstBase.BaseSink.BaseSinkQosPropertyInfo), '("renderDelay", GstBase.BaseSink.BaseSinkRenderDelayPropertyInfo), '("slaveMethod", AudioBaseSinkSlaveMethodPropertyInfo), '("sync", GstBase.BaseSink.BaseSinkSyncPropertyInfo), '("throttleTime", GstBase.BaseSink.BaseSinkThrottleTimePropertyInfo), '("tsOffset", GstBase.BaseSink.BaseSinkTsOffsetPropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
audioBaseSinkAlignmentThreshold :: AttrLabelProxy "alignmentThreshold"
audioBaseSinkAlignmentThreshold = AttrLabelProxy

audioBaseSinkBufferTime :: AttrLabelProxy "bufferTime"
audioBaseSinkBufferTime = AttrLabelProxy

audioBaseSinkCanActivatePull :: AttrLabelProxy "canActivatePull"
audioBaseSinkCanActivatePull = AttrLabelProxy

audioBaseSinkDiscontWait :: AttrLabelProxy "discontWait"
audioBaseSinkDiscontWait = AttrLabelProxy

audioBaseSinkDriftTolerance :: AttrLabelProxy "driftTolerance"
audioBaseSinkDriftTolerance = AttrLabelProxy

audioBaseSinkLatencyTime :: AttrLabelProxy "latencyTime"
audioBaseSinkLatencyTime = AttrLabelProxy

audioBaseSinkProvideClock :: AttrLabelProxy "provideClock"
audioBaseSinkProvideClock = AttrLabelProxy

audioBaseSinkSlaveMethod :: AttrLabelProxy "slaveMethod"
audioBaseSinkSlaveMethod = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
type instance O.SignalList AudioBaseSink = AudioBaseSinkSignalList
type AudioBaseSinkSignalList = ('[ '("deepNotify", Gst.Object.ObjectDeepNotifySignalInfo), '("noMorePads", Gst.Element.ElementNoMorePadsSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("padAdded", Gst.Element.ElementPadAddedSignalInfo), '("padRemoved", Gst.Element.ElementPadRemovedSignalInfo)] :: [(Symbol, *)])

#endif

-- method AudioBaseSink::create_ringbuffer
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "sink", argType = TInterface (Name {namespace = "GstAudio", name = "AudioBaseSink"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstAudioBaseSink.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "GstAudio", name = "AudioRingBuffer"}))
-- throws : False
-- Skip return : False

foreign import ccall "gst_audio_base_sink_create_ringbuffer" gst_audio_base_sink_create_ringbuffer :: 
    Ptr AudioBaseSink ->                    -- sink : TInterface (Name {namespace = "GstAudio", name = "AudioBaseSink"})
    IO (Ptr GstAudio.AudioRingBuffer.AudioRingBuffer)

{- |
Create and return the 'GI.GstAudio.Objects.AudioRingBuffer.AudioRingBuffer' for /@sink@/. This function will
call the ::create_ringbuffer vmethod and will set /@sink@/ as the parent of
the returned buffer (see 'GI.Gst.Objects.Object.objectSetParent').
-}
audioBaseSinkCreateRingbuffer ::
    (B.CallStack.HasCallStack, MonadIO m, IsAudioBaseSink a) =>
    a
    {- ^ /@sink@/: a 'GI.GstAudio.Objects.AudioBaseSink.AudioBaseSink'. -}
    -> m GstAudio.AudioRingBuffer.AudioRingBuffer
    {- ^ __Returns:__ The new ringbuffer of /@sink@/. -}
audioBaseSinkCreateRingbuffer sink = liftIO $ do
    sink' <- unsafeManagedPtrCastPtr sink
    result <- gst_audio_base_sink_create_ringbuffer sink'
    checkUnexpectedReturnNULL "audioBaseSinkCreateRingbuffer" result
    result' <- (newObject GstAudio.AudioRingBuffer.AudioRingBuffer) result
    touchManagedPtr sink
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data AudioBaseSinkCreateRingbufferMethodInfo
instance (signature ~ (m GstAudio.AudioRingBuffer.AudioRingBuffer), MonadIO m, IsAudioBaseSink a) => O.MethodInfo AudioBaseSinkCreateRingbufferMethodInfo a signature where
    overloadedMethod _ = audioBaseSinkCreateRingbuffer

#endif

-- method AudioBaseSink::get_alignment_threshold
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "sink", argType = TInterface (Name {namespace = "GstAudio", name = "AudioBaseSink"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstAudioBaseSink", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUInt64)
-- throws : False
-- Skip return : False

foreign import ccall "gst_audio_base_sink_get_alignment_threshold" gst_audio_base_sink_get_alignment_threshold :: 
    Ptr AudioBaseSink ->                    -- sink : TInterface (Name {namespace = "GstAudio", name = "AudioBaseSink"})
    IO Word64

{- |
Get the current alignment threshold, in nanoseconds, used by /@sink@/.
-}
audioBaseSinkGetAlignmentThreshold ::
    (B.CallStack.HasCallStack, MonadIO m, IsAudioBaseSink a) =>
    a
    {- ^ /@sink@/: a 'GI.GstAudio.Objects.AudioBaseSink.AudioBaseSink' -}
    -> m Word64
    {- ^ __Returns:__ The current alignment threshold used by /@sink@/. -}
audioBaseSinkGetAlignmentThreshold sink = liftIO $ do
    sink' <- unsafeManagedPtrCastPtr sink
    result <- gst_audio_base_sink_get_alignment_threshold sink'
    touchManagedPtr sink
    return result

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data AudioBaseSinkGetAlignmentThresholdMethodInfo
instance (signature ~ (m Word64), MonadIO m, IsAudioBaseSink a) => O.MethodInfo AudioBaseSinkGetAlignmentThresholdMethodInfo a signature where
    overloadedMethod _ = audioBaseSinkGetAlignmentThreshold

#endif

-- method AudioBaseSink::get_discont_wait
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "sink", argType = TInterface (Name {namespace = "GstAudio", name = "AudioBaseSink"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstAudioBaseSink", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUInt64)
-- throws : False
-- Skip return : False

foreign import ccall "gst_audio_base_sink_get_discont_wait" gst_audio_base_sink_get_discont_wait :: 
    Ptr AudioBaseSink ->                    -- sink : TInterface (Name {namespace = "GstAudio", name = "AudioBaseSink"})
    IO Word64

{- |
Get the current discont wait, in nanoseconds, used by /@sink@/.
-}
audioBaseSinkGetDiscontWait ::
    (B.CallStack.HasCallStack, MonadIO m, IsAudioBaseSink a) =>
    a
    {- ^ /@sink@/: a 'GI.GstAudio.Objects.AudioBaseSink.AudioBaseSink' -}
    -> m Word64
    {- ^ __Returns:__ The current discont wait used by /@sink@/. -}
audioBaseSinkGetDiscontWait sink = liftIO $ do
    sink' <- unsafeManagedPtrCastPtr sink
    result <- gst_audio_base_sink_get_discont_wait sink'
    touchManagedPtr sink
    return result

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data AudioBaseSinkGetDiscontWaitMethodInfo
instance (signature ~ (m Word64), MonadIO m, IsAudioBaseSink a) => O.MethodInfo AudioBaseSinkGetDiscontWaitMethodInfo a signature where
    overloadedMethod _ = audioBaseSinkGetDiscontWait

#endif

-- method AudioBaseSink::get_drift_tolerance
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "sink", argType = TInterface (Name {namespace = "GstAudio", name = "AudioBaseSink"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstAudioBaseSink", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TInt64)
-- throws : False
-- Skip return : False

foreign import ccall "gst_audio_base_sink_get_drift_tolerance" gst_audio_base_sink_get_drift_tolerance :: 
    Ptr AudioBaseSink ->                    -- sink : TInterface (Name {namespace = "GstAudio", name = "AudioBaseSink"})
    IO Int64

{- |
Get the current drift tolerance, in microseconds, used by /@sink@/.
-}
audioBaseSinkGetDriftTolerance ::
    (B.CallStack.HasCallStack, MonadIO m, IsAudioBaseSink a) =>
    a
    {- ^ /@sink@/: a 'GI.GstAudio.Objects.AudioBaseSink.AudioBaseSink' -}
    -> m Int64
    {- ^ __Returns:__ The current drift tolerance used by /@sink@/. -}
audioBaseSinkGetDriftTolerance sink = liftIO $ do
    sink' <- unsafeManagedPtrCastPtr sink
    result <- gst_audio_base_sink_get_drift_tolerance sink'
    touchManagedPtr sink
    return result

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data AudioBaseSinkGetDriftToleranceMethodInfo
instance (signature ~ (m Int64), MonadIO m, IsAudioBaseSink a) => O.MethodInfo AudioBaseSinkGetDriftToleranceMethodInfo a signature where
    overloadedMethod _ = audioBaseSinkGetDriftTolerance

#endif

-- method AudioBaseSink::get_provide_clock
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "sink", argType = TInterface (Name {namespace = "GstAudio", name = "AudioBaseSink"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstAudioBaseSink", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gst_audio_base_sink_get_provide_clock" gst_audio_base_sink_get_provide_clock :: 
    Ptr AudioBaseSink ->                    -- sink : TInterface (Name {namespace = "GstAudio", name = "AudioBaseSink"})
    IO CInt

{- |
Queries whether /@sink@/ will provide a clock or not. See also
gst_audio_base_sink_set_provide_clock.
-}
audioBaseSinkGetProvideClock ::
    (B.CallStack.HasCallStack, MonadIO m, IsAudioBaseSink a) =>
    a
    {- ^ /@sink@/: a 'GI.GstAudio.Objects.AudioBaseSink.AudioBaseSink' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if /@sink@/ will provide a clock. -}
audioBaseSinkGetProvideClock sink = liftIO $ do
    sink' <- unsafeManagedPtrCastPtr sink
    result <- gst_audio_base_sink_get_provide_clock sink'
    let result' = (/= 0) result
    touchManagedPtr sink
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data AudioBaseSinkGetProvideClockMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsAudioBaseSink a) => O.MethodInfo AudioBaseSinkGetProvideClockMethodInfo a signature where
    overloadedMethod _ = audioBaseSinkGetProvideClock

#endif

-- method AudioBaseSink::get_slave_method
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "sink", argType = TInterface (Name {namespace = "GstAudio", name = "AudioBaseSink"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstAudioBaseSink", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "GstAudio", name = "AudioBaseSinkSlaveMethod"}))
-- throws : False
-- Skip return : False

foreign import ccall "gst_audio_base_sink_get_slave_method" gst_audio_base_sink_get_slave_method :: 
    Ptr AudioBaseSink ->                    -- sink : TInterface (Name {namespace = "GstAudio", name = "AudioBaseSink"})
    IO CUInt

{- |
Get the current slave method used by /@sink@/.
-}
audioBaseSinkGetSlaveMethod ::
    (B.CallStack.HasCallStack, MonadIO m, IsAudioBaseSink a) =>
    a
    {- ^ /@sink@/: a 'GI.GstAudio.Objects.AudioBaseSink.AudioBaseSink' -}
    -> m GstAudio.Enums.AudioBaseSinkSlaveMethod
    {- ^ __Returns:__ The current slave method used by /@sink@/. -}
audioBaseSinkGetSlaveMethod sink = liftIO $ do
    sink' <- unsafeManagedPtrCastPtr sink
    result <- gst_audio_base_sink_get_slave_method sink'
    let result' = (toEnum . fromIntegral) result
    touchManagedPtr sink
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data AudioBaseSinkGetSlaveMethodMethodInfo
instance (signature ~ (m GstAudio.Enums.AudioBaseSinkSlaveMethod), MonadIO m, IsAudioBaseSink a) => O.MethodInfo AudioBaseSinkGetSlaveMethodMethodInfo a signature where
    overloadedMethod _ = audioBaseSinkGetSlaveMethod

#endif

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

foreign import ccall "gst_audio_base_sink_report_device_failure" gst_audio_base_sink_report_device_failure :: 
    Ptr AudioBaseSink ->                    -- sink : TInterface (Name {namespace = "GstAudio", name = "AudioBaseSink"})
    IO ()

{- |
Informs this base class that the audio output device has failed for
some reason, causing a discontinuity (for example, because the device
recovered from the error, but lost all contents of its ring buffer).
This function is typically called by derived classes, and is useful
for the custom slave method.

@since 1.6
-}
audioBaseSinkReportDeviceFailure ::
    (B.CallStack.HasCallStack, MonadIO m, IsAudioBaseSink a) =>
    a
    {- ^ /@sink@/: a 'GI.GstAudio.Objects.AudioBaseSink.AudioBaseSink' -}
    -> m ()
audioBaseSinkReportDeviceFailure sink = liftIO $ do
    sink' <- unsafeManagedPtrCastPtr sink
    gst_audio_base_sink_report_device_failure sink'
    touchManagedPtr sink
    return ()

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data AudioBaseSinkReportDeviceFailureMethodInfo
instance (signature ~ (m ()), MonadIO m, IsAudioBaseSink a) => O.MethodInfo AudioBaseSinkReportDeviceFailureMethodInfo a signature where
    overloadedMethod _ = audioBaseSinkReportDeviceFailure

#endif

-- method AudioBaseSink::set_alignment_threshold
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "sink", argType = TInterface (Name {namespace = "GstAudio", name = "AudioBaseSink"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstAudioBaseSink", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "alignment_threshold", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new alignment threshold in nanoseconds", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gst_audio_base_sink_set_alignment_threshold" gst_audio_base_sink_set_alignment_threshold :: 
    Ptr AudioBaseSink ->                    -- sink : TInterface (Name {namespace = "GstAudio", name = "AudioBaseSink"})
    Word64 ->                               -- alignment_threshold : TBasicType TUInt64
    IO ()

{- |
Controls the sink\'s alignment threshold.
-}
audioBaseSinkSetAlignmentThreshold ::
    (B.CallStack.HasCallStack, MonadIO m, IsAudioBaseSink a) =>
    a
    {- ^ /@sink@/: a 'GI.GstAudio.Objects.AudioBaseSink.AudioBaseSink' -}
    -> Word64
    {- ^ /@alignmentThreshold@/: the new alignment threshold in nanoseconds -}
    -> m ()
audioBaseSinkSetAlignmentThreshold sink alignmentThreshold = liftIO $ do
    sink' <- unsafeManagedPtrCastPtr sink
    gst_audio_base_sink_set_alignment_threshold sink' alignmentThreshold
    touchManagedPtr sink
    return ()

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data AudioBaseSinkSetAlignmentThresholdMethodInfo
instance (signature ~ (Word64 -> m ()), MonadIO m, IsAudioBaseSink a) => O.MethodInfo AudioBaseSinkSetAlignmentThresholdMethodInfo a signature where
    overloadedMethod _ = audioBaseSinkSetAlignmentThreshold

#endif

-- method AudioBaseSink::set_custom_slaving_callback
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "sink", argType = TInterface (Name {namespace = "GstAudio", name = "AudioBaseSink"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstAudioBaseSink", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "GstAudio", name = "AudioBaseSinkCustomSlavingCallback"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstAudioBaseSinkCustomSlavingCallback", sinceVersion = Nothing}, argScope = ScopeTypeNotified, argClosure = 2, argDestroy = 3, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data passed to the callback", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "notify", argType = TInterface (Name {namespace = "GLib", name = "DestroyNotify"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "called when user_data becomes unused", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gst_audio_base_sink_set_custom_slaving_callback" gst_audio_base_sink_set_custom_slaving_callback :: 
    Ptr AudioBaseSink ->                    -- sink : TInterface (Name {namespace = "GstAudio", name = "AudioBaseSink"})
    FunPtr GstAudio.Callbacks.C_AudioBaseSinkCustomSlavingCallback -> -- callback : TInterface (Name {namespace = "GstAudio", name = "AudioBaseSinkCustomSlavingCallback"})
    Ptr () ->                               -- user_data : TBasicType TPtr
    FunPtr GLib.Callbacks.C_DestroyNotify -> -- notify : TInterface (Name {namespace = "GLib", name = "DestroyNotify"})
    IO ()

{- |
Sets the custom slaving callback. This callback will
be invoked if the slave-method property is set to
GST_AUDIO_BASE_SINK_SLAVE_CUSTOM and the audio sink
receives and plays samples.

Setting the callback to NULL causes the sink to
behave as if the GST_AUDIO_BASE_SINK_SLAVE_NONE
method were used.

@since 1.6
-}
audioBaseSinkSetCustomSlavingCallback ::
    (B.CallStack.HasCallStack, MonadIO m, IsAudioBaseSink a) =>
    a
    {- ^ /@sink@/: a 'GI.GstAudio.Objects.AudioBaseSink.AudioBaseSink' -}
    -> GstAudio.Callbacks.AudioBaseSinkCustomSlavingCallback
    {- ^ /@callback@/: a 'GI.GstAudio.Callbacks.AudioBaseSinkCustomSlavingCallback' -}
    -> m ()
audioBaseSinkSetCustomSlavingCallback sink callback = liftIO $ do
    sink' <- unsafeManagedPtrCastPtr sink
    callback' <- GstAudio.Callbacks.mk_AudioBaseSinkCustomSlavingCallback (GstAudio.Callbacks.wrap_AudioBaseSinkCustomSlavingCallback Nothing (GstAudio.Callbacks.drop_closures_AudioBaseSinkCustomSlavingCallback callback))
    let userData = castFunPtrToPtr callback'
    let notify = safeFreeFunPtrPtr
    gst_audio_base_sink_set_custom_slaving_callback sink' callback' userData notify
    touchManagedPtr sink
    return ()

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data AudioBaseSinkSetCustomSlavingCallbackMethodInfo
instance (signature ~ (GstAudio.Callbacks.AudioBaseSinkCustomSlavingCallback -> m ()), MonadIO m, IsAudioBaseSink a) => O.MethodInfo AudioBaseSinkSetCustomSlavingCallbackMethodInfo a signature where
    overloadedMethod _ = audioBaseSinkSetCustomSlavingCallback

#endif

-- method AudioBaseSink::set_discont_wait
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "sink", argType = TInterface (Name {namespace = "GstAudio", name = "AudioBaseSink"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstAudioBaseSink", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "discont_wait", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new discont wait in nanoseconds", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gst_audio_base_sink_set_discont_wait" gst_audio_base_sink_set_discont_wait :: 
    Ptr AudioBaseSink ->                    -- sink : TInterface (Name {namespace = "GstAudio", name = "AudioBaseSink"})
    Word64 ->                               -- discont_wait : TBasicType TUInt64
    IO ()

{- |
Controls how long the sink will wait before creating a discontinuity.
-}
audioBaseSinkSetDiscontWait ::
    (B.CallStack.HasCallStack, MonadIO m, IsAudioBaseSink a) =>
    a
    {- ^ /@sink@/: a 'GI.GstAudio.Objects.AudioBaseSink.AudioBaseSink' -}
    -> Word64
    {- ^ /@discontWait@/: the new discont wait in nanoseconds -}
    -> m ()
audioBaseSinkSetDiscontWait sink discontWait = liftIO $ do
    sink' <- unsafeManagedPtrCastPtr sink
    gst_audio_base_sink_set_discont_wait sink' discontWait
    touchManagedPtr sink
    return ()

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data AudioBaseSinkSetDiscontWaitMethodInfo
instance (signature ~ (Word64 -> m ()), MonadIO m, IsAudioBaseSink a) => O.MethodInfo AudioBaseSinkSetDiscontWaitMethodInfo a signature where
    overloadedMethod _ = audioBaseSinkSetDiscontWait

#endif

-- method AudioBaseSink::set_drift_tolerance
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "sink", argType = TInterface (Name {namespace = "GstAudio", name = "AudioBaseSink"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstAudioBaseSink", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "drift_tolerance", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new drift tolerance in microseconds", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gst_audio_base_sink_set_drift_tolerance" gst_audio_base_sink_set_drift_tolerance :: 
    Ptr AudioBaseSink ->                    -- sink : TInterface (Name {namespace = "GstAudio", name = "AudioBaseSink"})
    Int64 ->                                -- drift_tolerance : TBasicType TInt64
    IO ()

{- |
Controls the sink\'s drift tolerance.
-}
audioBaseSinkSetDriftTolerance ::
    (B.CallStack.HasCallStack, MonadIO m, IsAudioBaseSink a) =>
    a
    {- ^ /@sink@/: a 'GI.GstAudio.Objects.AudioBaseSink.AudioBaseSink' -}
    -> Int64
    {- ^ /@driftTolerance@/: the new drift tolerance in microseconds -}
    -> m ()
audioBaseSinkSetDriftTolerance sink driftTolerance = liftIO $ do
    sink' <- unsafeManagedPtrCastPtr sink
    gst_audio_base_sink_set_drift_tolerance sink' driftTolerance
    touchManagedPtr sink
    return ()

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data AudioBaseSinkSetDriftToleranceMethodInfo
instance (signature ~ (Int64 -> m ()), MonadIO m, IsAudioBaseSink a) => O.MethodInfo AudioBaseSinkSetDriftToleranceMethodInfo a signature where
    overloadedMethod _ = audioBaseSinkSetDriftTolerance

#endif

-- method AudioBaseSink::set_provide_clock
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "sink", argType = TInterface (Name {namespace = "GstAudio", name = "AudioBaseSink"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstAudioBaseSink", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "provide", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "new state", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gst_audio_base_sink_set_provide_clock" gst_audio_base_sink_set_provide_clock :: 
    Ptr AudioBaseSink ->                    -- sink : TInterface (Name {namespace = "GstAudio", name = "AudioBaseSink"})
    CInt ->                                 -- provide : TBasicType TBoolean
    IO ()

{- |
Controls whether /@sink@/ will provide a clock or not. If /@provide@/ is 'True',
'GI.Gst.Objects.Element.elementProvideClock' will return a clock that reflects the datarate
of /@sink@/. If /@provide@/ is 'False', 'GI.Gst.Objects.Element.elementProvideClock' will return
NULL.
-}
audioBaseSinkSetProvideClock ::
    (B.CallStack.HasCallStack, MonadIO m, IsAudioBaseSink a) =>
    a
    {- ^ /@sink@/: a 'GI.GstAudio.Objects.AudioBaseSink.AudioBaseSink' -}
    -> Bool
    {- ^ /@provide@/: new state -}
    -> m ()
audioBaseSinkSetProvideClock sink provide = liftIO $ do
    sink' <- unsafeManagedPtrCastPtr sink
    let provide' = (fromIntegral . fromEnum) provide
    gst_audio_base_sink_set_provide_clock sink' provide'
    touchManagedPtr sink
    return ()

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data AudioBaseSinkSetProvideClockMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsAudioBaseSink a) => O.MethodInfo AudioBaseSinkSetProvideClockMethodInfo a signature where
    overloadedMethod _ = audioBaseSinkSetProvideClock

#endif

-- method AudioBaseSink::set_slave_method
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "sink", argType = TInterface (Name {namespace = "GstAudio", name = "AudioBaseSink"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GstAudioBaseSink", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "method", argType = TInterface (Name {namespace = "GstAudio", name = "AudioBaseSinkSlaveMethod"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new slave method", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gst_audio_base_sink_set_slave_method" gst_audio_base_sink_set_slave_method :: 
    Ptr AudioBaseSink ->                    -- sink : TInterface (Name {namespace = "GstAudio", name = "AudioBaseSink"})
    CUInt ->                                -- method : TInterface (Name {namespace = "GstAudio", name = "AudioBaseSinkSlaveMethod"})
    IO ()

{- |
Controls how clock slaving will be performed in /@sink@/.
-}
audioBaseSinkSetSlaveMethod ::
    (B.CallStack.HasCallStack, MonadIO m, IsAudioBaseSink a) =>
    a
    {- ^ /@sink@/: a 'GI.GstAudio.Objects.AudioBaseSink.AudioBaseSink' -}
    -> GstAudio.Enums.AudioBaseSinkSlaveMethod
    {- ^ /@method@/: the new slave method -}
    -> m ()
audioBaseSinkSetSlaveMethod sink method = liftIO $ do
    sink' <- unsafeManagedPtrCastPtr sink
    let method' = (fromIntegral . fromEnum) method
    gst_audio_base_sink_set_slave_method sink' method'
    touchManagedPtr sink
    return ()

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data AudioBaseSinkSetSlaveMethodMethodInfo
instance (signature ~ (GstAudio.Enums.AudioBaseSinkSlaveMethod -> m ()), MonadIO m, IsAudioBaseSink a) => O.MethodInfo AudioBaseSinkSetSlaveMethodMethodInfo a signature where
    overloadedMethod _ = audioBaseSinkSetSlaveMethod

#endif