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

module GI.WebKit.Objects.DOMTextTrack
    ( 

-- * Exported types
    DOMTextTrack(..)                        ,
    IsDOMTextTrack                          ,
    toDOMTextTrack                          ,
    noDOMTextTrack                          ,


 -- * Methods
-- ** addCue #method:addCue#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DOMTextTrackAddCueMethodInfo            ,
#endif
    dOMTextTrackAddCue                      ,


-- ** dispatchEvent #method:dispatchEvent#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DOMTextTrackDispatchEventMethodInfo     ,
#endif
    dOMTextTrackDispatchEvent               ,


-- ** getActiveCues #method:getActiveCues#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DOMTextTrackGetActiveCuesMethodInfo     ,
#endif
    dOMTextTrackGetActiveCues               ,


-- ** getCues #method:getCues#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DOMTextTrackGetCuesMethodInfo           ,
#endif
    dOMTextTrackGetCues                     ,


-- ** getId #method:getId#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DOMTextTrackGetIdMethodInfo             ,
#endif
    dOMTextTrackGetId                       ,


-- ** getKind #method:getKind#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DOMTextTrackGetKindMethodInfo           ,
#endif
    dOMTextTrackGetKind                     ,


-- ** getLabel #method:getLabel#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DOMTextTrackGetLabelMethodInfo          ,
#endif
    dOMTextTrackGetLabel                    ,


-- ** getLanguage #method:getLanguage#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DOMTextTrackGetLanguageMethodInfo       ,
#endif
    dOMTextTrackGetLanguage                 ,


-- ** getMode #method:getMode#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DOMTextTrackGetModeMethodInfo           ,
#endif
    dOMTextTrackGetMode                     ,


-- ** removeCue #method:removeCue#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DOMTextTrackRemoveCueMethodInfo         ,
#endif
    dOMTextTrackRemoveCue                   ,


-- ** setMode #method:setMode#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DOMTextTrackSetModeMethodInfo           ,
#endif
    dOMTextTrackSetMode                     ,




 -- * Properties
-- ** activeCues #attr:activeCues#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DOMTextTrackActiveCuesPropertyInfo      ,
#endif
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    dOMTextTrackActiveCues                  ,
#endif
    getDOMTextTrackActiveCues               ,


-- ** cues #attr:cues#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DOMTextTrackCuesPropertyInfo            ,
#endif
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    dOMTextTrackCues                        ,
#endif
    getDOMTextTrackCues                     ,


-- ** id #attr:id#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DOMTextTrackIdPropertyInfo              ,
#endif
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    dOMTextTrackId                          ,
#endif
    getDOMTextTrackId                       ,


-- ** kind #attr:kind#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DOMTextTrackKindPropertyInfo            ,
#endif
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    dOMTextTrackKind                        ,
#endif
    getDOMTextTrackKind                     ,


-- ** label #attr:label#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DOMTextTrackLabelPropertyInfo           ,
#endif
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    dOMTextTrackLabel                       ,
#endif
    getDOMTextTrackLabel                    ,


-- ** language #attr:language#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DOMTextTrackLanguagePropertyInfo        ,
#endif
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    dOMTextTrackLanguage                    ,
#endif
    getDOMTextTrackLanguage                 ,


-- ** mode #attr:mode#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    DOMTextTrackModePropertyInfo            ,
#endif
    constructDOMTextTrackMode               ,
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    dOMTextTrackMode                        ,
#endif
    getDOMTextTrackMode                     ,
    setDOMTextTrackMode                     ,




    ) 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.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.WebKit.Interfaces.DOMEventTarget as WebKit.DOMEventTarget
import {-# SOURCE #-} qualified GI.WebKit.Objects.DOMEvent as WebKit.DOMEvent
import {-# SOURCE #-} qualified GI.WebKit.Objects.DOMObject as WebKit.DOMObject
import {-# SOURCE #-} qualified GI.WebKit.Objects.DOMTextTrackCue as WebKit.DOMTextTrackCue
import {-# SOURCE #-} qualified GI.WebKit.Objects.DOMTextTrackCueList as WebKit.DOMTextTrackCueList

newtype DOMTextTrack = DOMTextTrack (ManagedPtr DOMTextTrack)
foreign import ccall "webkit_dom_text_track_get_type"
    c_webkit_dom_text_track_get_type :: IO GType

instance GObject DOMTextTrack where
    gobjectType _ = c_webkit_dom_text_track_get_type
    

class GObject o => IsDOMTextTrack o
#if MIN_VERSION_base(4,9,0)
instance {-# OVERLAPPABLE #-} (GObject a, O.UnknownAncestorError DOMTextTrack a) =>
    IsDOMTextTrack a
#endif
instance IsDOMTextTrack DOMTextTrack
instance WebKit.DOMObject.IsDOMObject DOMTextTrack
instance GObject.Object.IsObject DOMTextTrack
instance WebKit.DOMEventTarget.IsDOMEventTarget DOMTextTrack

toDOMTextTrack :: (MonadIO m, IsDOMTextTrack o) => o -> m DOMTextTrack
toDOMTextTrack = liftIO . unsafeCastTo DOMTextTrack

noDOMTextTrack :: Maybe DOMTextTrack
noDOMTextTrack = Nothing

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
type family ResolveDOMTextTrackMethod (t :: Symbol) (o :: *) :: * where
    ResolveDOMTextTrackMethod "addCue" o = DOMTextTrackAddCueMethodInfo
    ResolveDOMTextTrackMethod "addEventListener" o = WebKit.DOMEventTarget.DOMEventTargetAddEventListenerMethodInfo
    ResolveDOMTextTrackMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveDOMTextTrackMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveDOMTextTrackMethod "dispatchEvent" o = DOMTextTrackDispatchEventMethodInfo
    ResolveDOMTextTrackMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveDOMTextTrackMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveDOMTextTrackMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveDOMTextTrackMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveDOMTextTrackMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveDOMTextTrackMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveDOMTextTrackMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveDOMTextTrackMethod "removeCue" o = DOMTextTrackRemoveCueMethodInfo
    ResolveDOMTextTrackMethod "removeEventListener" o = WebKit.DOMEventTarget.DOMEventTargetRemoveEventListenerMethodInfo
    ResolveDOMTextTrackMethod "replaceData" o = GObject.Object.ObjectReplaceDataMethodInfo
    ResolveDOMTextTrackMethod "replaceQdata" o = GObject.Object.ObjectReplaceQdataMethodInfo
    ResolveDOMTextTrackMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveDOMTextTrackMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveDOMTextTrackMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveDOMTextTrackMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveDOMTextTrackMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveDOMTextTrackMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveDOMTextTrackMethod "getActiveCues" o = DOMTextTrackGetActiveCuesMethodInfo
    ResolveDOMTextTrackMethod "getCues" o = DOMTextTrackGetCuesMethodInfo
    ResolveDOMTextTrackMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveDOMTextTrackMethod "getId" o = DOMTextTrackGetIdMethodInfo
    ResolveDOMTextTrackMethod "getKind" o = DOMTextTrackGetKindMethodInfo
    ResolveDOMTextTrackMethod "getLabel" o = DOMTextTrackGetLabelMethodInfo
    ResolveDOMTextTrackMethod "getLanguage" o = DOMTextTrackGetLanguageMethodInfo
    ResolveDOMTextTrackMethod "getMode" o = DOMTextTrackGetModeMethodInfo
    ResolveDOMTextTrackMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveDOMTextTrackMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveDOMTextTrackMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveDOMTextTrackMethod "setMode" o = DOMTextTrackSetModeMethodInfo
    ResolveDOMTextTrackMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveDOMTextTrackMethod l o = O.MethodResolutionFailed l o

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

#if MIN_VERSION_base(4,9,0)
instance (info ~ ResolveDOMTextTrackMethod t DOMTextTrack, O.MethodInfo info DOMTextTrack p) => O.IsLabel t (DOMTextTrack -> 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 "active-cues"
   -- Type: TInterface (Name {namespace = "WebKit", name = "DOMTextTrackCueList"})
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

getDOMTextTrackActiveCues :: (MonadIO m, IsDOMTextTrack o) => o -> m (Maybe WebKit.DOMTextTrackCueList.DOMTextTrackCueList)
getDOMTextTrackActiveCues obj = liftIO $ getObjectPropertyObject obj "active-cues" WebKit.DOMTextTrackCueList.DOMTextTrackCueList

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DOMTextTrackActiveCuesPropertyInfo
instance AttrInfo DOMTextTrackActiveCuesPropertyInfo where
    type AttrAllowedOps DOMTextTrackActiveCuesPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint DOMTextTrackActiveCuesPropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMTextTrackActiveCuesPropertyInfo = IsDOMTextTrack
    type AttrGetType DOMTextTrackActiveCuesPropertyInfo = (Maybe WebKit.DOMTextTrackCueList.DOMTextTrackCueList)
    type AttrLabel DOMTextTrackActiveCuesPropertyInfo = "active-cues"
    type AttrOrigin DOMTextTrackActiveCuesPropertyInfo = DOMTextTrack
    attrGet _ = getDOMTextTrackActiveCues
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined
#endif

-- VVV Prop "cues"
   -- Type: TInterface (Name {namespace = "WebKit", name = "DOMTextTrackCueList"})
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

getDOMTextTrackCues :: (MonadIO m, IsDOMTextTrack o) => o -> m (Maybe WebKit.DOMTextTrackCueList.DOMTextTrackCueList)
getDOMTextTrackCues obj = liftIO $ getObjectPropertyObject obj "cues" WebKit.DOMTextTrackCueList.DOMTextTrackCueList

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DOMTextTrackCuesPropertyInfo
instance AttrInfo DOMTextTrackCuesPropertyInfo where
    type AttrAllowedOps DOMTextTrackCuesPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint DOMTextTrackCuesPropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMTextTrackCuesPropertyInfo = IsDOMTextTrack
    type AttrGetType DOMTextTrackCuesPropertyInfo = (Maybe WebKit.DOMTextTrackCueList.DOMTextTrackCueList)
    type AttrLabel DOMTextTrackCuesPropertyInfo = "cues"
    type AttrOrigin DOMTextTrackCuesPropertyInfo = DOMTextTrack
    attrGet _ = getDOMTextTrackCues
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined
#endif

-- VVV Prop "id"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

getDOMTextTrackId :: (MonadIO m, IsDOMTextTrack o) => o -> m (Maybe T.Text)
getDOMTextTrackId obj = liftIO $ getObjectPropertyString obj "id"

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DOMTextTrackIdPropertyInfo
instance AttrInfo DOMTextTrackIdPropertyInfo where
    type AttrAllowedOps DOMTextTrackIdPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint DOMTextTrackIdPropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMTextTrackIdPropertyInfo = IsDOMTextTrack
    type AttrGetType DOMTextTrackIdPropertyInfo = (Maybe T.Text)
    type AttrLabel DOMTextTrackIdPropertyInfo = "id"
    type AttrOrigin DOMTextTrackIdPropertyInfo = DOMTextTrack
    attrGet _ = getDOMTextTrackId
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined
#endif

-- VVV Prop "kind"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

getDOMTextTrackKind :: (MonadIO m, IsDOMTextTrack o) => o -> m (Maybe T.Text)
getDOMTextTrackKind obj = liftIO $ getObjectPropertyString obj "kind"

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DOMTextTrackKindPropertyInfo
instance AttrInfo DOMTextTrackKindPropertyInfo where
    type AttrAllowedOps DOMTextTrackKindPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint DOMTextTrackKindPropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMTextTrackKindPropertyInfo = IsDOMTextTrack
    type AttrGetType DOMTextTrackKindPropertyInfo = (Maybe T.Text)
    type AttrLabel DOMTextTrackKindPropertyInfo = "kind"
    type AttrOrigin DOMTextTrackKindPropertyInfo = DOMTextTrack
    attrGet _ = getDOMTextTrackKind
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined
#endif

-- VVV Prop "label"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

getDOMTextTrackLabel :: (MonadIO m, IsDOMTextTrack o) => o -> m (Maybe T.Text)
getDOMTextTrackLabel obj = liftIO $ getObjectPropertyString obj "label"

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DOMTextTrackLabelPropertyInfo
instance AttrInfo DOMTextTrackLabelPropertyInfo where
    type AttrAllowedOps DOMTextTrackLabelPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint DOMTextTrackLabelPropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMTextTrackLabelPropertyInfo = IsDOMTextTrack
    type AttrGetType DOMTextTrackLabelPropertyInfo = (Maybe T.Text)
    type AttrLabel DOMTextTrackLabelPropertyInfo = "label"
    type AttrOrigin DOMTextTrackLabelPropertyInfo = DOMTextTrack
    attrGet _ = getDOMTextTrackLabel
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined
#endif

-- VVV Prop "language"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

getDOMTextTrackLanguage :: (MonadIO m, IsDOMTextTrack o) => o -> m (Maybe T.Text)
getDOMTextTrackLanguage obj = liftIO $ getObjectPropertyString obj "language"

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DOMTextTrackLanguagePropertyInfo
instance AttrInfo DOMTextTrackLanguagePropertyInfo where
    type AttrAllowedOps DOMTextTrackLanguagePropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint DOMTextTrackLanguagePropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMTextTrackLanguagePropertyInfo = IsDOMTextTrack
    type AttrGetType DOMTextTrackLanguagePropertyInfo = (Maybe T.Text)
    type AttrLabel DOMTextTrackLanguagePropertyInfo = "language"
    type AttrOrigin DOMTextTrackLanguagePropertyInfo = DOMTextTrack
    attrGet _ = getDOMTextTrackLanguage
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined
#endif

-- VVV Prop "mode"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Nothing,Just False)

getDOMTextTrackMode :: (MonadIO m, IsDOMTextTrack o) => o -> m (Maybe T.Text)
getDOMTextTrackMode obj = liftIO $ getObjectPropertyString obj "mode"

setDOMTextTrackMode :: (MonadIO m, IsDOMTextTrack o) => o -> T.Text -> m ()
setDOMTextTrackMode obj val = liftIO $ setObjectPropertyString obj "mode" (Just val)

constructDOMTextTrackMode :: (IsDOMTextTrack o) => T.Text -> IO (GValueConstruct o)
constructDOMTextTrackMode val = constructObjectPropertyString "mode" (Just val)

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DOMTextTrackModePropertyInfo
instance AttrInfo DOMTextTrackModePropertyInfo where
    type AttrAllowedOps DOMTextTrackModePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint DOMTextTrackModePropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint DOMTextTrackModePropertyInfo = IsDOMTextTrack
    type AttrGetType DOMTextTrackModePropertyInfo = (Maybe T.Text)
    type AttrLabel DOMTextTrackModePropertyInfo = "mode"
    type AttrOrigin DOMTextTrackModePropertyInfo = DOMTextTrack
    attrGet _ = getDOMTextTrackMode
    attrSet _ = setDOMTextTrackMode
    attrConstruct _ = constructDOMTextTrackMode
    attrClear _ = undefined
#endif

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
instance O.HasAttributeList DOMTextTrack
type instance O.AttributeList DOMTextTrack = DOMTextTrackAttributeList
type DOMTextTrackAttributeList = ('[ '("activeCues", DOMTextTrackActiveCuesPropertyInfo), '("coreObject", WebKit.DOMObject.DOMObjectCoreObjectPropertyInfo), '("cues", DOMTextTrackCuesPropertyInfo), '("id", DOMTextTrackIdPropertyInfo), '("kind", DOMTextTrackKindPropertyInfo), '("label", DOMTextTrackLabelPropertyInfo), '("language", DOMTextTrackLanguagePropertyInfo), '("mode", DOMTextTrackModePropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
dOMTextTrackActiveCues :: AttrLabelProxy "activeCues"
dOMTextTrackActiveCues = AttrLabelProxy

dOMTextTrackCues :: AttrLabelProxy "cues"
dOMTextTrackCues = AttrLabelProxy

dOMTextTrackId :: AttrLabelProxy "id"
dOMTextTrackId = AttrLabelProxy

dOMTextTrackKind :: AttrLabelProxy "kind"
dOMTextTrackKind = AttrLabelProxy

dOMTextTrackLabel :: AttrLabelProxy "label"
dOMTextTrackLabel = AttrLabelProxy

dOMTextTrackLanguage :: AttrLabelProxy "language"
dOMTextTrackLanguage = AttrLabelProxy

dOMTextTrackMode :: AttrLabelProxy "mode"
dOMTextTrackMode = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
type instance O.SignalList DOMTextTrack = DOMTextTrackSignalList
type DOMTextTrackSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

#endif

-- method DOMTextTrack::add_cue
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMTextTrack"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMTextTrack", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cue", argType = TInterface (Name {namespace = "WebKit", name = "DOMTextTrackCue"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMTextTrackCue", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_text_track_add_cue" webkit_dom_text_track_add_cue :: 
    Ptr DOMTextTrack ->                     -- self : TInterface (Name {namespace = "WebKit", name = "DOMTextTrack"})
    Ptr WebKit.DOMTextTrackCue.DOMTextTrackCue -> -- cue : TInterface (Name {namespace = "WebKit", name = "DOMTextTrackCue"})
    IO ()

{- |
/No description available in the introspection data./
-}
dOMTextTrackAddCue ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMTextTrack a, WebKit.DOMTextTrackCue.IsDOMTextTrackCue b) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMTextTrack.DOMTextTrack' -}
    -> b
    {- ^ /@cue@/: A 'GI.WebKit.Objects.DOMTextTrackCue.DOMTextTrackCue' -}
    -> m ()
dOMTextTrackAddCue self cue = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    cue' <- unsafeManagedPtrCastPtr cue
    webkit_dom_text_track_add_cue self' cue'
    touchManagedPtr self
    touchManagedPtr cue
    return ()

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DOMTextTrackAddCueMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsDOMTextTrack a, WebKit.DOMTextTrackCue.IsDOMTextTrackCue b) => O.MethodInfo DOMTextTrackAddCueMethodInfo a signature where
    overloadedMethod _ = dOMTextTrackAddCue

#endif

-- method DOMTextTrack::dispatch_event
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMTextTrack"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMTextTrack", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "evt", argType = TInterface (Name {namespace = "WebKit", name = "DOMEvent"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMEvent", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "webkit_dom_text_track_dispatch_event" webkit_dom_text_track_dispatch_event :: 
    Ptr DOMTextTrack ->                     -- self : TInterface (Name {namespace = "WebKit", name = "DOMTextTrack"})
    Ptr WebKit.DOMEvent.DOMEvent ->         -- evt : TInterface (Name {namespace = "WebKit", name = "DOMEvent"})
    Ptr (Ptr GError) ->                     -- error
    IO CInt

{-# DEPRECATED dOMTextTrackDispatchEvent ["(Since version 2.4)","Use 'GI.WebKit.Interfaces.DOMEventTarget.dOMEventTargetDispatchEvent' instead."] #-}
{- |
/No description available in the introspection data./
-}
dOMTextTrackDispatchEvent ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMTextTrack a, WebKit.DOMEvent.IsDOMEvent b) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMTextTrack.DOMTextTrack' -}
    -> b
    {- ^ /@evt@/: A 'GI.WebKit.Objects.DOMEvent.DOMEvent' -}
    -> m ()
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
dOMTextTrackDispatchEvent self evt = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    evt' <- unsafeManagedPtrCastPtr evt
    onException (do
        _ <- propagateGError $ webkit_dom_text_track_dispatch_event self' evt'
        touchManagedPtr self
        touchManagedPtr evt
        return ()
     ) (do
        return ()
     )

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DOMTextTrackDispatchEventMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsDOMTextTrack a, WebKit.DOMEvent.IsDOMEvent b) => O.MethodInfo DOMTextTrackDispatchEventMethodInfo a signature where
    overloadedMethod _ = dOMTextTrackDispatchEvent

#endif

-- method DOMTextTrack::get_active_cues
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMTextTrack"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMTextTrack", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit", name = "DOMTextTrackCueList"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_text_track_get_active_cues" webkit_dom_text_track_get_active_cues :: 
    Ptr DOMTextTrack ->                     -- self : TInterface (Name {namespace = "WebKit", name = "DOMTextTrack"})
    IO (Ptr WebKit.DOMTextTrackCueList.DOMTextTrackCueList)

{- |
/No description available in the introspection data./
-}
dOMTextTrackGetActiveCues ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMTextTrack a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMTextTrack.DOMTextTrack' -}
    -> m WebKit.DOMTextTrackCueList.DOMTextTrackCueList
    {- ^ __Returns:__ A 'GI.WebKit.Objects.DOMTextTrackCueList.DOMTextTrackCueList' -}
dOMTextTrackGetActiveCues self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_text_track_get_active_cues self'
    checkUnexpectedReturnNULL "dOMTextTrackGetActiveCues" result
    result' <- (wrapObject WebKit.DOMTextTrackCueList.DOMTextTrackCueList) result
    touchManagedPtr self
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DOMTextTrackGetActiveCuesMethodInfo
instance (signature ~ (m WebKit.DOMTextTrackCueList.DOMTextTrackCueList), MonadIO m, IsDOMTextTrack a) => O.MethodInfo DOMTextTrackGetActiveCuesMethodInfo a signature where
    overloadedMethod _ = dOMTextTrackGetActiveCues

#endif

-- method DOMTextTrack::get_cues
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMTextTrack"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMTextTrack", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit", name = "DOMTextTrackCueList"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_text_track_get_cues" webkit_dom_text_track_get_cues :: 
    Ptr DOMTextTrack ->                     -- self : TInterface (Name {namespace = "WebKit", name = "DOMTextTrack"})
    IO (Ptr WebKit.DOMTextTrackCueList.DOMTextTrackCueList)

{- |
/No description available in the introspection data./
-}
dOMTextTrackGetCues ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMTextTrack a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMTextTrack.DOMTextTrack' -}
    -> m WebKit.DOMTextTrackCueList.DOMTextTrackCueList
    {- ^ __Returns:__ A 'GI.WebKit.Objects.DOMTextTrackCueList.DOMTextTrackCueList' -}
dOMTextTrackGetCues self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_text_track_get_cues self'
    checkUnexpectedReturnNULL "dOMTextTrackGetCues" result
    result' <- (wrapObject WebKit.DOMTextTrackCueList.DOMTextTrackCueList) result
    touchManagedPtr self
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DOMTextTrackGetCuesMethodInfo
instance (signature ~ (m WebKit.DOMTextTrackCueList.DOMTextTrackCueList), MonadIO m, IsDOMTextTrack a) => O.MethodInfo DOMTextTrackGetCuesMethodInfo a signature where
    overloadedMethod _ = dOMTextTrackGetCues

#endif

-- method DOMTextTrack::get_id
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMTextTrack"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMTextTrack", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_text_track_get_id" webkit_dom_text_track_get_id :: 
    Ptr DOMTextTrack ->                     -- self : TInterface (Name {namespace = "WebKit", name = "DOMTextTrack"})
    IO CString

{- |
/No description available in the introspection data./
-}
dOMTextTrackGetId ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMTextTrack a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMTextTrack.DOMTextTrack' -}
    -> m T.Text
    {- ^ __Returns:__ A @/gchar/@ -}
dOMTextTrackGetId self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_text_track_get_id self'
    checkUnexpectedReturnNULL "dOMTextTrackGetId" result
    result' <- cstringToText result
    freeMem result
    touchManagedPtr self
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DOMTextTrackGetIdMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsDOMTextTrack a) => O.MethodInfo DOMTextTrackGetIdMethodInfo a signature where
    overloadedMethod _ = dOMTextTrackGetId

#endif

-- method DOMTextTrack::get_kind
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMTextTrack"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMTextTrack", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_text_track_get_kind" webkit_dom_text_track_get_kind :: 
    Ptr DOMTextTrack ->                     -- self : TInterface (Name {namespace = "WebKit", name = "DOMTextTrack"})
    IO CString

{- |
/No description available in the introspection data./
-}
dOMTextTrackGetKind ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMTextTrack a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMTextTrack.DOMTextTrack' -}
    -> m T.Text
    {- ^ __Returns:__ A @/gchar/@ -}
dOMTextTrackGetKind self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_text_track_get_kind self'
    checkUnexpectedReturnNULL "dOMTextTrackGetKind" result
    result' <- cstringToText result
    freeMem result
    touchManagedPtr self
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DOMTextTrackGetKindMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsDOMTextTrack a) => O.MethodInfo DOMTextTrackGetKindMethodInfo a signature where
    overloadedMethod _ = dOMTextTrackGetKind

#endif

-- method DOMTextTrack::get_label
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMTextTrack"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMTextTrack", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_text_track_get_label" webkit_dom_text_track_get_label :: 
    Ptr DOMTextTrack ->                     -- self : TInterface (Name {namespace = "WebKit", name = "DOMTextTrack"})
    IO CString

{- |
/No description available in the introspection data./
-}
dOMTextTrackGetLabel ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMTextTrack a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMTextTrack.DOMTextTrack' -}
    -> m T.Text
    {- ^ __Returns:__ A @/gchar/@ -}
dOMTextTrackGetLabel self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_text_track_get_label self'
    checkUnexpectedReturnNULL "dOMTextTrackGetLabel" result
    result' <- cstringToText result
    freeMem result
    touchManagedPtr self
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DOMTextTrackGetLabelMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsDOMTextTrack a) => O.MethodInfo DOMTextTrackGetLabelMethodInfo a signature where
    overloadedMethod _ = dOMTextTrackGetLabel

#endif

-- method DOMTextTrack::get_language
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMTextTrack"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMTextTrack", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_text_track_get_language" webkit_dom_text_track_get_language :: 
    Ptr DOMTextTrack ->                     -- self : TInterface (Name {namespace = "WebKit", name = "DOMTextTrack"})
    IO CString

{- |
/No description available in the introspection data./
-}
dOMTextTrackGetLanguage ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMTextTrack a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMTextTrack.DOMTextTrack' -}
    -> m T.Text
    {- ^ __Returns:__ A @/gchar/@ -}
dOMTextTrackGetLanguage self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_text_track_get_language self'
    checkUnexpectedReturnNULL "dOMTextTrackGetLanguage" result
    result' <- cstringToText result
    freeMem result
    touchManagedPtr self
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DOMTextTrackGetLanguageMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsDOMTextTrack a) => O.MethodInfo DOMTextTrackGetLanguageMethodInfo a signature where
    overloadedMethod _ = dOMTextTrackGetLanguage

#endif

-- method DOMTextTrack::get_mode
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMTextTrack"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMTextTrack", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_text_track_get_mode" webkit_dom_text_track_get_mode :: 
    Ptr DOMTextTrack ->                     -- self : TInterface (Name {namespace = "WebKit", name = "DOMTextTrack"})
    IO CString

{- |
/No description available in the introspection data./
-}
dOMTextTrackGetMode ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMTextTrack a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMTextTrack.DOMTextTrack' -}
    -> m T.Text
    {- ^ __Returns:__ A @/gchar/@ -}
dOMTextTrackGetMode self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_text_track_get_mode self'
    checkUnexpectedReturnNULL "dOMTextTrackGetMode" result
    result' <- cstringToText result
    freeMem result
    touchManagedPtr self
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DOMTextTrackGetModeMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsDOMTextTrack a) => O.MethodInfo DOMTextTrackGetModeMethodInfo a signature where
    overloadedMethod _ = dOMTextTrackGetMode

#endif

-- method DOMTextTrack::remove_cue
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMTextTrack"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMTextTrack", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cue", argType = TInterface (Name {namespace = "WebKit", name = "DOMTextTrackCue"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMTextTrackCue", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : True
-- Skip return : False

foreign import ccall "webkit_dom_text_track_remove_cue" webkit_dom_text_track_remove_cue :: 
    Ptr DOMTextTrack ->                     -- self : TInterface (Name {namespace = "WebKit", name = "DOMTextTrack"})
    Ptr WebKit.DOMTextTrackCue.DOMTextTrackCue -> -- cue : TInterface (Name {namespace = "WebKit", name = "DOMTextTrackCue"})
    Ptr (Ptr GError) ->                     -- error
    IO ()

{- |
/No description available in the introspection data./
-}
dOMTextTrackRemoveCue ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMTextTrack a, WebKit.DOMTextTrackCue.IsDOMTextTrackCue b) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMTextTrack.DOMTextTrack' -}
    -> b
    {- ^ /@cue@/: A 'GI.WebKit.Objects.DOMTextTrackCue.DOMTextTrackCue' -}
    -> m ()
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
dOMTextTrackRemoveCue self cue = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    cue' <- unsafeManagedPtrCastPtr cue
    onException (do
        propagateGError $ webkit_dom_text_track_remove_cue self' cue'
        touchManagedPtr self
        touchManagedPtr cue
        return ()
     ) (do
        return ()
     )

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DOMTextTrackRemoveCueMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsDOMTextTrack a, WebKit.DOMTextTrackCue.IsDOMTextTrackCue b) => O.MethodInfo DOMTextTrackRemoveCueMethodInfo a signature where
    overloadedMethod _ = dOMTextTrackRemoveCue

#endif

-- method DOMTextTrack::set_mode
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMTextTrack"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMTextTrack", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #gchar", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "webkit_dom_text_track_set_mode" webkit_dom_text_track_set_mode :: 
    Ptr DOMTextTrack ->                     -- self : TInterface (Name {namespace = "WebKit", name = "DOMTextTrack"})
    CString ->                              -- value : TBasicType TUTF8
    IO ()

{- |
/No description available in the introspection data./
-}
dOMTextTrackSetMode ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMTextTrack a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMTextTrack.DOMTextTrack' -}
    -> T.Text
    {- ^ /@value@/: A @/gchar/@ -}
    -> m ()
dOMTextTrackSetMode self value = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    value' <- textToCString value
    webkit_dom_text_track_set_mode self' value'
    touchManagedPtr self
    freeMem value'
    return ()

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
data DOMTextTrackSetModeMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsDOMTextTrack a) => O.MethodInfo DOMTextTrackSetModeMethodInfo a signature where
    overloadedMethod _ = dOMTextTrackSetMode

#endif