{- |
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.DOMHTMLMediaElement
    ( 

-- * Exported types
    DOMHTMLMediaElement(..)                 ,
    IsDOMHTMLMediaElement                   ,
    toDOMHTMLMediaElement                   ,
    noDOMHTMLMediaElement                   ,


 -- * Methods
-- ** addTextTrack #method:addTextTrack#
    DOMHTMLMediaElementAddTextTrackMethodInfo,
    dOMHTMLMediaElementAddTextTrack         ,


-- ** canPlayType #method:canPlayType#
    DOMHTMLMediaElementCanPlayTypeMethodInfo,
    dOMHTMLMediaElementCanPlayType          ,


-- ** fastSeek #method:fastSeek#
    DOMHTMLMediaElementFastSeekMethodInfo   ,
    dOMHTMLMediaElementFastSeek             ,


-- ** getAudioTracks #method:getAudioTracks#
    DOMHTMLMediaElementGetAudioTracksMethodInfo,
    dOMHTMLMediaElementGetAudioTracks       ,


-- ** getAutoplay #method:getAutoplay#
    DOMHTMLMediaElementGetAutoplayMethodInfo,
    dOMHTMLMediaElementGetAutoplay          ,


-- ** getBuffered #method:getBuffered#
    DOMHTMLMediaElementGetBufferedMethodInfo,
    dOMHTMLMediaElementGetBuffered          ,


-- ** getController #method:getController#
    DOMHTMLMediaElementGetControllerMethodInfo,
    dOMHTMLMediaElementGetController        ,


-- ** getControls #method:getControls#
    DOMHTMLMediaElementGetControlsMethodInfo,
    dOMHTMLMediaElementGetControls          ,


-- ** getCurrentSrc #method:getCurrentSrc#
    DOMHTMLMediaElementGetCurrentSrcMethodInfo,
    dOMHTMLMediaElementGetCurrentSrc        ,


-- ** getCurrentTime #method:getCurrentTime#
    DOMHTMLMediaElementGetCurrentTimeMethodInfo,
    dOMHTMLMediaElementGetCurrentTime       ,


-- ** getDefaultMuted #method:getDefaultMuted#
    DOMHTMLMediaElementGetDefaultMutedMethodInfo,
    dOMHTMLMediaElementGetDefaultMuted      ,


-- ** getDefaultPlaybackRate #method:getDefaultPlaybackRate#
    DOMHTMLMediaElementGetDefaultPlaybackRateMethodInfo,
    dOMHTMLMediaElementGetDefaultPlaybackRate,


-- ** getDuration #method:getDuration#
    DOMHTMLMediaElementGetDurationMethodInfo,
    dOMHTMLMediaElementGetDuration          ,


-- ** getEnded #method:getEnded#
    DOMHTMLMediaElementGetEndedMethodInfo   ,
    dOMHTMLMediaElementGetEnded             ,


-- ** getError #method:getError#
    DOMHTMLMediaElementGetErrorMethodInfo   ,
    dOMHTMLMediaElementGetError             ,


-- ** getInitialTime #method:getInitialTime#
    DOMHTMLMediaElementGetInitialTimeMethodInfo,
    dOMHTMLMediaElementGetInitialTime       ,


-- ** getLoop #method:getLoop#
    DOMHTMLMediaElementGetLoopMethodInfo    ,
    dOMHTMLMediaElementGetLoop              ,


-- ** getMediaGroup #method:getMediaGroup#
    DOMHTMLMediaElementGetMediaGroupMethodInfo,
    dOMHTMLMediaElementGetMediaGroup        ,


-- ** getMuted #method:getMuted#
    DOMHTMLMediaElementGetMutedMethodInfo   ,
    dOMHTMLMediaElementGetMuted             ,


-- ** getNetworkState #method:getNetworkState#
    DOMHTMLMediaElementGetNetworkStateMethodInfo,
    dOMHTMLMediaElementGetNetworkState      ,


-- ** getPaused #method:getPaused#
    DOMHTMLMediaElementGetPausedMethodInfo  ,
    dOMHTMLMediaElementGetPaused            ,


-- ** getPlaybackRate #method:getPlaybackRate#
    DOMHTMLMediaElementGetPlaybackRateMethodInfo,
    dOMHTMLMediaElementGetPlaybackRate      ,


-- ** getPlayed #method:getPlayed#
    DOMHTMLMediaElementGetPlayedMethodInfo  ,
    dOMHTMLMediaElementGetPlayed            ,


-- ** getPreload #method:getPreload#
    DOMHTMLMediaElementGetPreloadMethodInfo ,
    dOMHTMLMediaElementGetPreload           ,


-- ** getReadyState #method:getReadyState#
    DOMHTMLMediaElementGetReadyStateMethodInfo,
    dOMHTMLMediaElementGetReadyState        ,


-- ** getSeekable #method:getSeekable#
    DOMHTMLMediaElementGetSeekableMethodInfo,
    dOMHTMLMediaElementGetSeekable          ,


-- ** getSeeking #method:getSeeking#
    DOMHTMLMediaElementGetSeekingMethodInfo ,
    dOMHTMLMediaElementGetSeeking           ,


-- ** getSrc #method:getSrc#
    DOMHTMLMediaElementGetSrcMethodInfo     ,
    dOMHTMLMediaElementGetSrc               ,


-- ** getStartTime #method:getStartTime#
    DOMHTMLMediaElementGetStartTimeMethodInfo,
    dOMHTMLMediaElementGetStartTime         ,


-- ** getTextTracks #method:getTextTracks#
    DOMHTMLMediaElementGetTextTracksMethodInfo,
    dOMHTMLMediaElementGetTextTracks        ,


-- ** getVideoTracks #method:getVideoTracks#
    DOMHTMLMediaElementGetVideoTracksMethodInfo,
    dOMHTMLMediaElementGetVideoTracks       ,


-- ** getVolume #method:getVolume#
    DOMHTMLMediaElementGetVolumeMethodInfo  ,
    dOMHTMLMediaElementGetVolume            ,


-- ** getWebkitAudioDecodedByteCount #method:getWebkitAudioDecodedByteCount#
    DOMHTMLMediaElementGetWebkitAudioDecodedByteCountMethodInfo,
    dOMHTMLMediaElementGetWebkitAudioDecodedByteCount,


-- ** getWebkitClosedCaptionsVisible #method:getWebkitClosedCaptionsVisible#
    DOMHTMLMediaElementGetWebkitClosedCaptionsVisibleMethodInfo,
    dOMHTMLMediaElementGetWebkitClosedCaptionsVisible,


-- ** getWebkitCurrentPlaybackTargetIsWireless #method:getWebkitCurrentPlaybackTargetIsWireless#
    DOMHTMLMediaElementGetWebkitCurrentPlaybackTargetIsWirelessMethodInfo,
    dOMHTMLMediaElementGetWebkitCurrentPlaybackTargetIsWireless,


-- ** getWebkitHasClosedCaptions #method:getWebkitHasClosedCaptions#
    DOMHTMLMediaElementGetWebkitHasClosedCaptionsMethodInfo,
    dOMHTMLMediaElementGetWebkitHasClosedCaptions,


-- ** getWebkitPreservesPitch #method:getWebkitPreservesPitch#
    DOMHTMLMediaElementGetWebkitPreservesPitchMethodInfo,
    dOMHTMLMediaElementGetWebkitPreservesPitch,


-- ** getWebkitVideoDecodedByteCount #method:getWebkitVideoDecodedByteCount#
    DOMHTMLMediaElementGetWebkitVideoDecodedByteCountMethodInfo,
    dOMHTMLMediaElementGetWebkitVideoDecodedByteCount,


-- ** load #method:load#
    DOMHTMLMediaElementLoadMethodInfo       ,
    dOMHTMLMediaElementLoad                 ,


-- ** pause #method:pause#
    DOMHTMLMediaElementPauseMethodInfo      ,
    dOMHTMLMediaElementPause                ,


-- ** play #method:play#
    DOMHTMLMediaElementPlayMethodInfo       ,
    dOMHTMLMediaElementPlay                 ,


-- ** setAutoplay #method:setAutoplay#
    DOMHTMLMediaElementSetAutoplayMethodInfo,
    dOMHTMLMediaElementSetAutoplay          ,


-- ** setControls #method:setControls#
    DOMHTMLMediaElementSetControlsMethodInfo,
    dOMHTMLMediaElementSetControls          ,


-- ** setCurrentTime #method:setCurrentTime#
    DOMHTMLMediaElementSetCurrentTimeMethodInfo,
    dOMHTMLMediaElementSetCurrentTime       ,


-- ** setDefaultMuted #method:setDefaultMuted#
    DOMHTMLMediaElementSetDefaultMutedMethodInfo,
    dOMHTMLMediaElementSetDefaultMuted      ,


-- ** setDefaultPlaybackRate #method:setDefaultPlaybackRate#
    DOMHTMLMediaElementSetDefaultPlaybackRateMethodInfo,
    dOMHTMLMediaElementSetDefaultPlaybackRate,


-- ** setLoop #method:setLoop#
    DOMHTMLMediaElementSetLoopMethodInfo    ,
    dOMHTMLMediaElementSetLoop              ,


-- ** setMediaGroup #method:setMediaGroup#
    DOMHTMLMediaElementSetMediaGroupMethodInfo,
    dOMHTMLMediaElementSetMediaGroup        ,


-- ** setMuted #method:setMuted#
    DOMHTMLMediaElementSetMutedMethodInfo   ,
    dOMHTMLMediaElementSetMuted             ,


-- ** setPlaybackRate #method:setPlaybackRate#
    DOMHTMLMediaElementSetPlaybackRateMethodInfo,
    dOMHTMLMediaElementSetPlaybackRate      ,


-- ** setPreload #method:setPreload#
    DOMHTMLMediaElementSetPreloadMethodInfo ,
    dOMHTMLMediaElementSetPreload           ,


-- ** setSrc #method:setSrc#
    DOMHTMLMediaElementSetSrcMethodInfo     ,
    dOMHTMLMediaElementSetSrc               ,


-- ** setVolume #method:setVolume#
    DOMHTMLMediaElementSetVolumeMethodInfo  ,
    dOMHTMLMediaElementSetVolume            ,


-- ** setWebkitClosedCaptionsVisible #method:setWebkitClosedCaptionsVisible#
    DOMHTMLMediaElementSetWebkitClosedCaptionsVisibleMethodInfo,
    dOMHTMLMediaElementSetWebkitClosedCaptionsVisible,


-- ** setWebkitPreservesPitch #method:setWebkitPreservesPitch#
    DOMHTMLMediaElementSetWebkitPreservesPitchMethodInfo,
    dOMHTMLMediaElementSetWebkitPreservesPitch,


-- ** webkitShowPlaybackTargetPicker #method:webkitShowPlaybackTargetPicker#
    DOMHTMLMediaElementWebkitShowPlaybackTargetPickerMethodInfo,
    dOMHTMLMediaElementWebkitShowPlaybackTargetPicker,




 -- * Properties
-- ** audioTracks #attr:audioTracks#
    DOMHTMLMediaElementAudioTracksPropertyInfo,
    dOMHTMLMediaElementAudioTracks          ,
    getDOMHTMLMediaElementAudioTracks       ,


-- ** autoplay #attr:autoplay#
    DOMHTMLMediaElementAutoplayPropertyInfo ,
    constructDOMHTMLMediaElementAutoplay    ,
    dOMHTMLMediaElementAutoplay             ,
    getDOMHTMLMediaElementAutoplay          ,
    setDOMHTMLMediaElementAutoplay          ,


-- ** buffered #attr:buffered#
    DOMHTMLMediaElementBufferedPropertyInfo ,
    dOMHTMLMediaElementBuffered             ,
    getDOMHTMLMediaElementBuffered          ,


-- ** controller #attr:controller#
    DOMHTMLMediaElementControllerPropertyInfo,
    dOMHTMLMediaElementController           ,
    getDOMHTMLMediaElementController        ,


-- ** controls #attr:controls#
    DOMHTMLMediaElementControlsPropertyInfo ,
    constructDOMHTMLMediaElementControls    ,
    dOMHTMLMediaElementControls             ,
    getDOMHTMLMediaElementControls          ,
    setDOMHTMLMediaElementControls          ,


-- ** currentSrc #attr:currentSrc#
    DOMHTMLMediaElementCurrentSrcPropertyInfo,
    dOMHTMLMediaElementCurrentSrc           ,
    getDOMHTMLMediaElementCurrentSrc        ,


-- ** currentTime #attr:currentTime#
    DOMHTMLMediaElementCurrentTimePropertyInfo,
    constructDOMHTMLMediaElementCurrentTime ,
    dOMHTMLMediaElementCurrentTime          ,
    getDOMHTMLMediaElementCurrentTime       ,
    setDOMHTMLMediaElementCurrentTime       ,


-- ** defaultMuted #attr:defaultMuted#
    DOMHTMLMediaElementDefaultMutedPropertyInfo,
    constructDOMHTMLMediaElementDefaultMuted,
    dOMHTMLMediaElementDefaultMuted         ,
    getDOMHTMLMediaElementDefaultMuted      ,
    setDOMHTMLMediaElementDefaultMuted      ,


-- ** defaultPlaybackRate #attr:defaultPlaybackRate#
    DOMHTMLMediaElementDefaultPlaybackRatePropertyInfo,
    constructDOMHTMLMediaElementDefaultPlaybackRate,
    dOMHTMLMediaElementDefaultPlaybackRate  ,
    getDOMHTMLMediaElementDefaultPlaybackRate,
    setDOMHTMLMediaElementDefaultPlaybackRate,


-- ** duration #attr:duration#
    DOMHTMLMediaElementDurationPropertyInfo ,
    dOMHTMLMediaElementDuration             ,
    getDOMHTMLMediaElementDuration          ,


-- ** ended #attr:ended#
    DOMHTMLMediaElementEndedPropertyInfo    ,
    dOMHTMLMediaElementEnded                ,
    getDOMHTMLMediaElementEnded             ,


-- ** error #attr:error#
    DOMHTMLMediaElementErrorPropertyInfo    ,
    dOMHTMLMediaElementError                ,
    getDOMHTMLMediaElementError             ,


-- ** loop #attr:loop#
    DOMHTMLMediaElementLoopPropertyInfo     ,
    constructDOMHTMLMediaElementLoop        ,
    dOMHTMLMediaElementLoop                 ,
    getDOMHTMLMediaElementLoop              ,
    setDOMHTMLMediaElementLoop              ,


-- ** mediaGroup #attr:mediaGroup#
    DOMHTMLMediaElementMediaGroupPropertyInfo,
    constructDOMHTMLMediaElementMediaGroup  ,
    dOMHTMLMediaElementMediaGroup           ,
    getDOMHTMLMediaElementMediaGroup        ,
    setDOMHTMLMediaElementMediaGroup        ,


-- ** muted #attr:muted#
    DOMHTMLMediaElementMutedPropertyInfo    ,
    constructDOMHTMLMediaElementMuted       ,
    dOMHTMLMediaElementMuted                ,
    getDOMHTMLMediaElementMuted             ,
    setDOMHTMLMediaElementMuted             ,


-- ** networkState #attr:networkState#
    DOMHTMLMediaElementNetworkStatePropertyInfo,
    dOMHTMLMediaElementNetworkState         ,
    getDOMHTMLMediaElementNetworkState      ,


-- ** paused #attr:paused#
    DOMHTMLMediaElementPausedPropertyInfo   ,
    dOMHTMLMediaElementPaused               ,
    getDOMHTMLMediaElementPaused            ,


-- ** playbackRate #attr:playbackRate#
    DOMHTMLMediaElementPlaybackRatePropertyInfo,
    constructDOMHTMLMediaElementPlaybackRate,
    dOMHTMLMediaElementPlaybackRate         ,
    getDOMHTMLMediaElementPlaybackRate      ,
    setDOMHTMLMediaElementPlaybackRate      ,


-- ** played #attr:played#
    DOMHTMLMediaElementPlayedPropertyInfo   ,
    dOMHTMLMediaElementPlayed               ,
    getDOMHTMLMediaElementPlayed            ,


-- ** preload #attr:preload#
    DOMHTMLMediaElementPreloadPropertyInfo  ,
    constructDOMHTMLMediaElementPreload     ,
    dOMHTMLMediaElementPreload              ,
    getDOMHTMLMediaElementPreload           ,
    setDOMHTMLMediaElementPreload           ,


-- ** readyState #attr:readyState#
    DOMHTMLMediaElementReadyStatePropertyInfo,
    dOMHTMLMediaElementReadyState           ,
    getDOMHTMLMediaElementReadyState        ,


-- ** seekable #attr:seekable#
    DOMHTMLMediaElementSeekablePropertyInfo ,
    dOMHTMLMediaElementSeekable             ,
    getDOMHTMLMediaElementSeekable          ,


-- ** seeking #attr:seeking#
    DOMHTMLMediaElementSeekingPropertyInfo  ,
    dOMHTMLMediaElementSeeking              ,
    getDOMHTMLMediaElementSeeking           ,


-- ** src #attr:src#
    DOMHTMLMediaElementSrcPropertyInfo      ,
    constructDOMHTMLMediaElementSrc         ,
    dOMHTMLMediaElementSrc                  ,
    getDOMHTMLMediaElementSrc               ,
    setDOMHTMLMediaElementSrc               ,


-- ** textTracks #attr:textTracks#
    DOMHTMLMediaElementTextTracksPropertyInfo,
    dOMHTMLMediaElementTextTracks           ,
    getDOMHTMLMediaElementTextTracks        ,


-- ** videoTracks #attr:videoTracks#
    DOMHTMLMediaElementVideoTracksPropertyInfo,
    dOMHTMLMediaElementVideoTracks          ,
    getDOMHTMLMediaElementVideoTracks       ,


-- ** volume #attr:volume#
    DOMHTMLMediaElementVolumePropertyInfo   ,
    constructDOMHTMLMediaElementVolume      ,
    dOMHTMLMediaElementVolume               ,
    getDOMHTMLMediaElementVolume            ,
    setDOMHTMLMediaElementVolume            ,


-- ** webkitAudioDecodedByteCount #attr:webkitAudioDecodedByteCount#
    DOMHTMLMediaElementWebkitAudioDecodedByteCountPropertyInfo,
    dOMHTMLMediaElementWebkitAudioDecodedByteCount,
    getDOMHTMLMediaElementWebkitAudioDecodedByteCount,


-- ** webkitClosedCaptionsVisible #attr:webkitClosedCaptionsVisible#
    DOMHTMLMediaElementWebkitClosedCaptionsVisiblePropertyInfo,
    constructDOMHTMLMediaElementWebkitClosedCaptionsVisible,
    dOMHTMLMediaElementWebkitClosedCaptionsVisible,
    getDOMHTMLMediaElementWebkitClosedCaptionsVisible,
    setDOMHTMLMediaElementWebkitClosedCaptionsVisible,


-- ** webkitCurrentPlaybackTargetIsWireless #attr:webkitCurrentPlaybackTargetIsWireless#
    DOMHTMLMediaElementWebkitCurrentPlaybackTargetIsWirelessPropertyInfo,
    dOMHTMLMediaElementWebkitCurrentPlaybackTargetIsWireless,
    getDOMHTMLMediaElementWebkitCurrentPlaybackTargetIsWireless,


-- ** webkitHasClosedCaptions #attr:webkitHasClosedCaptions#
    DOMHTMLMediaElementWebkitHasClosedCaptionsPropertyInfo,
    dOMHTMLMediaElementWebkitHasClosedCaptions,
    getDOMHTMLMediaElementWebkitHasClosedCaptions,


-- ** webkitPreservesPitch #attr:webkitPreservesPitch#
    DOMHTMLMediaElementWebkitPreservesPitchPropertyInfo,
    constructDOMHTMLMediaElementWebkitPreservesPitch,
    dOMHTMLMediaElementWebkitPreservesPitch ,
    getDOMHTMLMediaElementWebkitPreservesPitch,
    setDOMHTMLMediaElementWebkitPreservesPitch,


-- ** webkitVideoDecodedByteCount #attr:webkitVideoDecodedByteCount#
    DOMHTMLMediaElementWebkitVideoDecodedByteCountPropertyInfo,
    dOMHTMLMediaElementWebkitVideoDecodedByteCount,
    getDOMHTMLMediaElementWebkitVideoDecodedByteCount,




    ) 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.DOMAudioTrackList as WebKit.DOMAudioTrackList
import {-# SOURCE #-} qualified GI.WebKit.Objects.DOMElement as WebKit.DOMElement
import {-# SOURCE #-} qualified GI.WebKit.Objects.DOMHTMLElement as WebKit.DOMHTMLElement
import {-# SOURCE #-} qualified GI.WebKit.Objects.DOMMediaController as WebKit.DOMMediaController
import {-# SOURCE #-} qualified GI.WebKit.Objects.DOMMediaError as WebKit.DOMMediaError
import {-# SOURCE #-} qualified GI.WebKit.Objects.DOMNode as WebKit.DOMNode
import {-# SOURCE #-} qualified GI.WebKit.Objects.DOMObject as WebKit.DOMObject
import {-# SOURCE #-} qualified GI.WebKit.Objects.DOMTextTrack as WebKit.DOMTextTrack
import {-# SOURCE #-} qualified GI.WebKit.Objects.DOMTextTrackList as WebKit.DOMTextTrackList
import {-# SOURCE #-} qualified GI.WebKit.Objects.DOMTimeRanges as WebKit.DOMTimeRanges
import {-# SOURCE #-} qualified GI.WebKit.Objects.DOMVideoTrackList as WebKit.DOMVideoTrackList

newtype DOMHTMLMediaElement = DOMHTMLMediaElement (ManagedPtr DOMHTMLMediaElement)
foreign import ccall "webkit_dom_html_media_element_get_type"
    c_webkit_dom_html_media_element_get_type :: IO GType

instance GObject DOMHTMLMediaElement where
    gobjectType _ = c_webkit_dom_html_media_element_get_type
    

class GObject o => IsDOMHTMLMediaElement o
#if MIN_VERSION_base(4,9,0)
instance {-# OVERLAPPABLE #-} (GObject a, O.UnknownAncestorError DOMHTMLMediaElement a) =>
    IsDOMHTMLMediaElement a
#endif
instance IsDOMHTMLMediaElement DOMHTMLMediaElement
instance WebKit.DOMHTMLElement.IsDOMHTMLElement DOMHTMLMediaElement
instance WebKit.DOMElement.IsDOMElement DOMHTMLMediaElement
instance WebKit.DOMNode.IsDOMNode DOMHTMLMediaElement
instance WebKit.DOMObject.IsDOMObject DOMHTMLMediaElement
instance GObject.Object.IsObject DOMHTMLMediaElement
instance WebKit.DOMEventTarget.IsDOMEventTarget DOMHTMLMediaElement

toDOMHTMLMediaElement :: IsDOMHTMLMediaElement o => o -> IO DOMHTMLMediaElement
toDOMHTMLMediaElement = unsafeCastTo DOMHTMLMediaElement

noDOMHTMLMediaElement :: Maybe DOMHTMLMediaElement
noDOMHTMLMediaElement = Nothing

type family ResolveDOMHTMLMediaElementMethod (t :: Symbol) (o :: *) :: * where
    ResolveDOMHTMLMediaElementMethod "addEventListener" o = WebKit.DOMEventTarget.DOMEventTargetAddEventListenerMethodInfo
    ResolveDOMHTMLMediaElementMethod "addTextTrack" o = DOMHTMLMediaElementAddTextTrackMethodInfo
    ResolveDOMHTMLMediaElementMethod "appendChild" o = WebKit.DOMNode.DOMNodeAppendChildMethodInfo
    ResolveDOMHTMLMediaElementMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveDOMHTMLMediaElementMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveDOMHTMLMediaElementMethod "blur" o = WebKit.DOMElement.DOMElementBlurMethodInfo
    ResolveDOMHTMLMediaElementMethod "canPlayType" o = DOMHTMLMediaElementCanPlayTypeMethodInfo
    ResolveDOMHTMLMediaElementMethod "click" o = WebKit.DOMHTMLElement.DOMHTMLElementClickMethodInfo
    ResolveDOMHTMLMediaElementMethod "cloneNode" o = WebKit.DOMNode.DOMNodeCloneNodeMethodInfo
    ResolveDOMHTMLMediaElementMethod "compareDocumentPosition" o = WebKit.DOMNode.DOMNodeCompareDocumentPositionMethodInfo
    ResolveDOMHTMLMediaElementMethod "contains" o = WebKit.DOMNode.DOMNodeContainsMethodInfo
    ResolveDOMHTMLMediaElementMethod "dispatchEvent" o = WebKit.DOMNode.DOMNodeDispatchEventMethodInfo
    ResolveDOMHTMLMediaElementMethod "fastSeek" o = DOMHTMLMediaElementFastSeekMethodInfo
    ResolveDOMHTMLMediaElementMethod "focus" o = WebKit.DOMElement.DOMElementFocusMethodInfo
    ResolveDOMHTMLMediaElementMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveDOMHTMLMediaElementMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveDOMHTMLMediaElementMethod "hasAttribute" o = WebKit.DOMElement.DOMElementHasAttributeMethodInfo
    ResolveDOMHTMLMediaElementMethod "hasAttributeNs" o = WebKit.DOMElement.DOMElementHasAttributeNsMethodInfo
    ResolveDOMHTMLMediaElementMethod "hasAttributes" o = WebKit.DOMElement.DOMElementHasAttributesMethodInfo
    ResolveDOMHTMLMediaElementMethod "hasChildNodes" o = WebKit.DOMNode.DOMNodeHasChildNodesMethodInfo
    ResolveDOMHTMLMediaElementMethod "insertAdjacentElement" o = WebKit.DOMHTMLElement.DOMHTMLElementInsertAdjacentElementMethodInfo
    ResolveDOMHTMLMediaElementMethod "insertAdjacentHtml" o = WebKit.DOMHTMLElement.DOMHTMLElementInsertAdjacentHtmlMethodInfo
    ResolveDOMHTMLMediaElementMethod "insertAdjacentText" o = WebKit.DOMHTMLElement.DOMHTMLElementInsertAdjacentTextMethodInfo
    ResolveDOMHTMLMediaElementMethod "insertBefore" o = WebKit.DOMNode.DOMNodeInsertBeforeMethodInfo
    ResolveDOMHTMLMediaElementMethod "isDefaultNamespace" o = WebKit.DOMNode.DOMNodeIsDefaultNamespaceMethodInfo
    ResolveDOMHTMLMediaElementMethod "isEqualNode" o = WebKit.DOMNode.DOMNodeIsEqualNodeMethodInfo
    ResolveDOMHTMLMediaElementMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveDOMHTMLMediaElementMethod "isSameNode" o = WebKit.DOMNode.DOMNodeIsSameNodeMethodInfo
    ResolveDOMHTMLMediaElementMethod "isSupported" o = WebKit.DOMNode.DOMNodeIsSupportedMethodInfo
    ResolveDOMHTMLMediaElementMethod "load" o = DOMHTMLMediaElementLoadMethodInfo
    ResolveDOMHTMLMediaElementMethod "lookupNamespaceUri" o = WebKit.DOMNode.DOMNodeLookupNamespaceUriMethodInfo
    ResolveDOMHTMLMediaElementMethod "lookupPrefix" o = WebKit.DOMNode.DOMNodeLookupPrefixMethodInfo
    ResolveDOMHTMLMediaElementMethod "normalize" o = WebKit.DOMNode.DOMNodeNormalizeMethodInfo
    ResolveDOMHTMLMediaElementMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveDOMHTMLMediaElementMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveDOMHTMLMediaElementMethod "pause" o = DOMHTMLMediaElementPauseMethodInfo
    ResolveDOMHTMLMediaElementMethod "play" o = DOMHTMLMediaElementPlayMethodInfo
    ResolveDOMHTMLMediaElementMethod "querySelector" o = WebKit.DOMElement.DOMElementQuerySelectorMethodInfo
    ResolveDOMHTMLMediaElementMethod "querySelectorAll" o = WebKit.DOMElement.DOMElementQuerySelectorAllMethodInfo
    ResolveDOMHTMLMediaElementMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveDOMHTMLMediaElementMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveDOMHTMLMediaElementMethod "remove" o = WebKit.DOMElement.DOMElementRemoveMethodInfo
    ResolveDOMHTMLMediaElementMethod "removeAttribute" o = WebKit.DOMElement.DOMElementRemoveAttributeMethodInfo
    ResolveDOMHTMLMediaElementMethod "removeAttributeNode" o = WebKit.DOMElement.DOMElementRemoveAttributeNodeMethodInfo
    ResolveDOMHTMLMediaElementMethod "removeAttributeNs" o = WebKit.DOMElement.DOMElementRemoveAttributeNsMethodInfo
    ResolveDOMHTMLMediaElementMethod "removeChild" o = WebKit.DOMNode.DOMNodeRemoveChildMethodInfo
    ResolveDOMHTMLMediaElementMethod "removeEventListener" o = WebKit.DOMEventTarget.DOMEventTargetRemoveEventListenerMethodInfo
    ResolveDOMHTMLMediaElementMethod "replaceChild" o = WebKit.DOMNode.DOMNodeReplaceChildMethodInfo
    ResolveDOMHTMLMediaElementMethod "replaceData" o = GObject.Object.ObjectReplaceDataMethodInfo
    ResolveDOMHTMLMediaElementMethod "replaceQdata" o = GObject.Object.ObjectReplaceQdataMethodInfo
    ResolveDOMHTMLMediaElementMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveDOMHTMLMediaElementMethod "scrollByLines" o = WebKit.DOMElement.DOMElementScrollByLinesMethodInfo
    ResolveDOMHTMLMediaElementMethod "scrollByPages" o = WebKit.DOMElement.DOMElementScrollByPagesMethodInfo
    ResolveDOMHTMLMediaElementMethod "scrollIntoView" o = WebKit.DOMElement.DOMElementScrollIntoViewMethodInfo
    ResolveDOMHTMLMediaElementMethod "scrollIntoViewIfNeeded" o = WebKit.DOMElement.DOMElementScrollIntoViewIfNeededMethodInfo
    ResolveDOMHTMLMediaElementMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveDOMHTMLMediaElementMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveDOMHTMLMediaElementMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveDOMHTMLMediaElementMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveDOMHTMLMediaElementMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveDOMHTMLMediaElementMethod "webkitMatchesSelector" o = WebKit.DOMElement.DOMElementWebkitMatchesSelectorMethodInfo
    ResolveDOMHTMLMediaElementMethod "webkitRequestFullScreen" o = WebKit.DOMElement.DOMElementWebkitRequestFullScreenMethodInfo
    ResolveDOMHTMLMediaElementMethod "webkitRequestFullscreen" o = WebKit.DOMElement.DOMElementWebkitRequestFullscreenMethodInfo
    ResolveDOMHTMLMediaElementMethod "webkitRequestPointerLock" o = WebKit.DOMElement.DOMElementWebkitRequestPointerLockMethodInfo
    ResolveDOMHTMLMediaElementMethod "webkitShowPlaybackTargetPicker" o = DOMHTMLMediaElementWebkitShowPlaybackTargetPickerMethodInfo
    ResolveDOMHTMLMediaElementMethod "getAccessKey" o = WebKit.DOMHTMLElement.DOMHTMLElementGetAccessKeyMethodInfo
    ResolveDOMHTMLMediaElementMethod "getAttribute" o = WebKit.DOMElement.DOMElementGetAttributeMethodInfo
    ResolveDOMHTMLMediaElementMethod "getAttributeNode" o = WebKit.DOMElement.DOMElementGetAttributeNodeMethodInfo
    ResolveDOMHTMLMediaElementMethod "getAttributeNodeNs" o = WebKit.DOMElement.DOMElementGetAttributeNodeNsMethodInfo
    ResolveDOMHTMLMediaElementMethod "getAttributeNs" o = WebKit.DOMElement.DOMElementGetAttributeNsMethodInfo
    ResolveDOMHTMLMediaElementMethod "getAttributes" o = WebKit.DOMElement.DOMElementGetAttributesMethodInfo
    ResolveDOMHTMLMediaElementMethod "getAudioTracks" o = DOMHTMLMediaElementGetAudioTracksMethodInfo
    ResolveDOMHTMLMediaElementMethod "getAutoplay" o = DOMHTMLMediaElementGetAutoplayMethodInfo
    ResolveDOMHTMLMediaElementMethod "getBaseUri" o = WebKit.DOMNode.DOMNodeGetBaseUriMethodInfo
    ResolveDOMHTMLMediaElementMethod "getBuffered" o = DOMHTMLMediaElementGetBufferedMethodInfo
    ResolveDOMHTMLMediaElementMethod "getChildElementCount" o = WebKit.DOMElement.DOMElementGetChildElementCountMethodInfo
    ResolveDOMHTMLMediaElementMethod "getChildNodes" o = WebKit.DOMNode.DOMNodeGetChildNodesMethodInfo
    ResolveDOMHTMLMediaElementMethod "getChildren" o = WebKit.DOMHTMLElement.DOMHTMLElementGetChildrenMethodInfo
    ResolveDOMHTMLMediaElementMethod "getClassList" o = WebKit.DOMHTMLElement.DOMHTMLElementGetClassListMethodInfo
    ResolveDOMHTMLMediaElementMethod "getClassName" o = WebKit.DOMHTMLElement.DOMHTMLElementGetClassNameMethodInfo
    ResolveDOMHTMLMediaElementMethod "getClientHeight" o = WebKit.DOMElement.DOMElementGetClientHeightMethodInfo
    ResolveDOMHTMLMediaElementMethod "getClientLeft" o = WebKit.DOMElement.DOMElementGetClientLeftMethodInfo
    ResolveDOMHTMLMediaElementMethod "getClientTop" o = WebKit.DOMElement.DOMElementGetClientTopMethodInfo
    ResolveDOMHTMLMediaElementMethod "getClientWidth" o = WebKit.DOMElement.DOMElementGetClientWidthMethodInfo
    ResolveDOMHTMLMediaElementMethod "getContentEditable" o = WebKit.DOMHTMLElement.DOMHTMLElementGetContentEditableMethodInfo
    ResolveDOMHTMLMediaElementMethod "getController" o = DOMHTMLMediaElementGetControllerMethodInfo
    ResolveDOMHTMLMediaElementMethod "getControls" o = DOMHTMLMediaElementGetControlsMethodInfo
    ResolveDOMHTMLMediaElementMethod "getCurrentSrc" o = DOMHTMLMediaElementGetCurrentSrcMethodInfo
    ResolveDOMHTMLMediaElementMethod "getCurrentTime" o = DOMHTMLMediaElementGetCurrentTimeMethodInfo
    ResolveDOMHTMLMediaElementMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveDOMHTMLMediaElementMethod "getDefaultMuted" o = DOMHTMLMediaElementGetDefaultMutedMethodInfo
    ResolveDOMHTMLMediaElementMethod "getDefaultPlaybackRate" o = DOMHTMLMediaElementGetDefaultPlaybackRateMethodInfo
    ResolveDOMHTMLMediaElementMethod "getDir" o = WebKit.DOMHTMLElement.DOMHTMLElementGetDirMethodInfo
    ResolveDOMHTMLMediaElementMethod "getDraggable" o = WebKit.DOMHTMLElement.DOMHTMLElementGetDraggableMethodInfo
    ResolveDOMHTMLMediaElementMethod "getDuration" o = DOMHTMLMediaElementGetDurationMethodInfo
    ResolveDOMHTMLMediaElementMethod "getElementsByClassName" o = WebKit.DOMElement.DOMElementGetElementsByClassNameMethodInfo
    ResolveDOMHTMLMediaElementMethod "getElementsByTagName" o = WebKit.DOMElement.DOMElementGetElementsByTagNameMethodInfo
    ResolveDOMHTMLMediaElementMethod "getElementsByTagNameNs" o = WebKit.DOMElement.DOMElementGetElementsByTagNameNsMethodInfo
    ResolveDOMHTMLMediaElementMethod "getEnded" o = DOMHTMLMediaElementGetEndedMethodInfo
    ResolveDOMHTMLMediaElementMethod "getError" o = DOMHTMLMediaElementGetErrorMethodInfo
    ResolveDOMHTMLMediaElementMethod "getFirstChild" o = WebKit.DOMNode.DOMNodeGetFirstChildMethodInfo
    ResolveDOMHTMLMediaElementMethod "getFirstElementChild" o = WebKit.DOMElement.DOMElementGetFirstElementChildMethodInfo
    ResolveDOMHTMLMediaElementMethod "getHidden" o = WebKit.DOMHTMLElement.DOMHTMLElementGetHiddenMethodInfo
    ResolveDOMHTMLMediaElementMethod "getId" o = WebKit.DOMHTMLElement.DOMHTMLElementGetIdMethodInfo
    ResolveDOMHTMLMediaElementMethod "getInitialTime" o = DOMHTMLMediaElementGetInitialTimeMethodInfo
    ResolveDOMHTMLMediaElementMethod "getInnerHtml" o = WebKit.DOMHTMLElement.DOMHTMLElementGetInnerHtmlMethodInfo
    ResolveDOMHTMLMediaElementMethod "getInnerText" o = WebKit.DOMHTMLElement.DOMHTMLElementGetInnerTextMethodInfo
    ResolveDOMHTMLMediaElementMethod "getIsContentEditable" o = WebKit.DOMHTMLElement.DOMHTMLElementGetIsContentEditableMethodInfo
    ResolveDOMHTMLMediaElementMethod "getItemId" o = WebKit.DOMHTMLElement.DOMHTMLElementGetItemIdMethodInfo
    ResolveDOMHTMLMediaElementMethod "getItemProp" o = WebKit.DOMHTMLElement.DOMHTMLElementGetItemPropMethodInfo
    ResolveDOMHTMLMediaElementMethod "getItemRef" o = WebKit.DOMHTMLElement.DOMHTMLElementGetItemRefMethodInfo
    ResolveDOMHTMLMediaElementMethod "getItemScope" o = WebKit.DOMHTMLElement.DOMHTMLElementGetItemScopeMethodInfo
    ResolveDOMHTMLMediaElementMethod "getItemType" o = WebKit.DOMHTMLElement.DOMHTMLElementGetItemTypeMethodInfo
    ResolveDOMHTMLMediaElementMethod "getLang" o = WebKit.DOMHTMLElement.DOMHTMLElementGetLangMethodInfo
    ResolveDOMHTMLMediaElementMethod "getLastChild" o = WebKit.DOMNode.DOMNodeGetLastChildMethodInfo
    ResolveDOMHTMLMediaElementMethod "getLastElementChild" o = WebKit.DOMElement.DOMElementGetLastElementChildMethodInfo
    ResolveDOMHTMLMediaElementMethod "getLocalName" o = WebKit.DOMNode.DOMNodeGetLocalNameMethodInfo
    ResolveDOMHTMLMediaElementMethod "getLoop" o = DOMHTMLMediaElementGetLoopMethodInfo
    ResolveDOMHTMLMediaElementMethod "getMediaGroup" o = DOMHTMLMediaElementGetMediaGroupMethodInfo
    ResolveDOMHTMLMediaElementMethod "getMuted" o = DOMHTMLMediaElementGetMutedMethodInfo
    ResolveDOMHTMLMediaElementMethod "getNamespaceUri" o = WebKit.DOMNode.DOMNodeGetNamespaceUriMethodInfo
    ResolveDOMHTMLMediaElementMethod "getNetworkState" o = DOMHTMLMediaElementGetNetworkStateMethodInfo
    ResolveDOMHTMLMediaElementMethod "getNextElementSibling" o = WebKit.DOMElement.DOMElementGetNextElementSiblingMethodInfo
    ResolveDOMHTMLMediaElementMethod "getNextSibling" o = WebKit.DOMNode.DOMNodeGetNextSiblingMethodInfo
    ResolveDOMHTMLMediaElementMethod "getNodeName" o = WebKit.DOMNode.DOMNodeGetNodeNameMethodInfo
    ResolveDOMHTMLMediaElementMethod "getNodeType" o = WebKit.DOMNode.DOMNodeGetNodeTypeMethodInfo
    ResolveDOMHTMLMediaElementMethod "getNodeValue" o = WebKit.DOMNode.DOMNodeGetNodeValueMethodInfo
    ResolveDOMHTMLMediaElementMethod "getOffsetHeight" o = WebKit.DOMElement.DOMElementGetOffsetHeightMethodInfo
    ResolveDOMHTMLMediaElementMethod "getOffsetLeft" o = WebKit.DOMElement.DOMElementGetOffsetLeftMethodInfo
    ResolveDOMHTMLMediaElementMethod "getOffsetParent" o = WebKit.DOMElement.DOMElementGetOffsetParentMethodInfo
    ResolveDOMHTMLMediaElementMethod "getOffsetTop" o = WebKit.DOMElement.DOMElementGetOffsetTopMethodInfo
    ResolveDOMHTMLMediaElementMethod "getOffsetWidth" o = WebKit.DOMElement.DOMElementGetOffsetWidthMethodInfo
    ResolveDOMHTMLMediaElementMethod "getOuterHtml" o = WebKit.DOMHTMLElement.DOMHTMLElementGetOuterHtmlMethodInfo
    ResolveDOMHTMLMediaElementMethod "getOuterText" o = WebKit.DOMHTMLElement.DOMHTMLElementGetOuterTextMethodInfo
    ResolveDOMHTMLMediaElementMethod "getOwnerDocument" o = WebKit.DOMNode.DOMNodeGetOwnerDocumentMethodInfo
    ResolveDOMHTMLMediaElementMethod "getParentElement" o = WebKit.DOMNode.DOMNodeGetParentElementMethodInfo
    ResolveDOMHTMLMediaElementMethod "getParentNode" o = WebKit.DOMNode.DOMNodeGetParentNodeMethodInfo
    ResolveDOMHTMLMediaElementMethod "getPaused" o = DOMHTMLMediaElementGetPausedMethodInfo
    ResolveDOMHTMLMediaElementMethod "getPlaybackRate" o = DOMHTMLMediaElementGetPlaybackRateMethodInfo
    ResolveDOMHTMLMediaElementMethod "getPlayed" o = DOMHTMLMediaElementGetPlayedMethodInfo
    ResolveDOMHTMLMediaElementMethod "getPrefix" o = WebKit.DOMNode.DOMNodeGetPrefixMethodInfo
    ResolveDOMHTMLMediaElementMethod "getPreload" o = DOMHTMLMediaElementGetPreloadMethodInfo
    ResolveDOMHTMLMediaElementMethod "getPreviousElementSibling" o = WebKit.DOMElement.DOMElementGetPreviousElementSiblingMethodInfo
    ResolveDOMHTMLMediaElementMethod "getPreviousSibling" o = WebKit.DOMNode.DOMNodeGetPreviousSiblingMethodInfo
    ResolveDOMHTMLMediaElementMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveDOMHTMLMediaElementMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveDOMHTMLMediaElementMethod "getReadyState" o = DOMHTMLMediaElementGetReadyStateMethodInfo
    ResolveDOMHTMLMediaElementMethod "getScrollHeight" o = WebKit.DOMElement.DOMElementGetScrollHeightMethodInfo
    ResolveDOMHTMLMediaElementMethod "getScrollLeft" o = WebKit.DOMElement.DOMElementGetScrollLeftMethodInfo
    ResolveDOMHTMLMediaElementMethod "getScrollTop" o = WebKit.DOMElement.DOMElementGetScrollTopMethodInfo
    ResolveDOMHTMLMediaElementMethod "getScrollWidth" o = WebKit.DOMElement.DOMElementGetScrollWidthMethodInfo
    ResolveDOMHTMLMediaElementMethod "getSeekable" o = DOMHTMLMediaElementGetSeekableMethodInfo
    ResolveDOMHTMLMediaElementMethod "getSeeking" o = DOMHTMLMediaElementGetSeekingMethodInfo
    ResolveDOMHTMLMediaElementMethod "getSpellcheck" o = WebKit.DOMHTMLElement.DOMHTMLElementGetSpellcheckMethodInfo
    ResolveDOMHTMLMediaElementMethod "getSrc" o = DOMHTMLMediaElementGetSrcMethodInfo
    ResolveDOMHTMLMediaElementMethod "getStartTime" o = DOMHTMLMediaElementGetStartTimeMethodInfo
    ResolveDOMHTMLMediaElementMethod "getStyle" o = WebKit.DOMElement.DOMElementGetStyleMethodInfo
    ResolveDOMHTMLMediaElementMethod "getTabIndex" o = WebKit.DOMHTMLElement.DOMHTMLElementGetTabIndexMethodInfo
    ResolveDOMHTMLMediaElementMethod "getTagName" o = WebKit.DOMElement.DOMElementGetTagNameMethodInfo
    ResolveDOMHTMLMediaElementMethod "getTextContent" o = WebKit.DOMNode.DOMNodeGetTextContentMethodInfo
    ResolveDOMHTMLMediaElementMethod "getTextTracks" o = DOMHTMLMediaElementGetTextTracksMethodInfo
    ResolveDOMHTMLMediaElementMethod "getTitle" o = WebKit.DOMHTMLElement.DOMHTMLElementGetTitleMethodInfo
    ResolveDOMHTMLMediaElementMethod "getTranslate" o = WebKit.DOMHTMLElement.DOMHTMLElementGetTranslateMethodInfo
    ResolveDOMHTMLMediaElementMethod "getVideoTracks" o = DOMHTMLMediaElementGetVideoTracksMethodInfo
    ResolveDOMHTMLMediaElementMethod "getVolume" o = DOMHTMLMediaElementGetVolumeMethodInfo
    ResolveDOMHTMLMediaElementMethod "getWebkitAudioDecodedByteCount" o = DOMHTMLMediaElementGetWebkitAudioDecodedByteCountMethodInfo
    ResolveDOMHTMLMediaElementMethod "getWebkitClosedCaptionsVisible" o = DOMHTMLMediaElementGetWebkitClosedCaptionsVisibleMethodInfo
    ResolveDOMHTMLMediaElementMethod "getWebkitCurrentPlaybackTargetIsWireless" o = DOMHTMLMediaElementGetWebkitCurrentPlaybackTargetIsWirelessMethodInfo
    ResolveDOMHTMLMediaElementMethod "getWebkitHasClosedCaptions" o = DOMHTMLMediaElementGetWebkitHasClosedCaptionsMethodInfo
    ResolveDOMHTMLMediaElementMethod "getWebkitPreservesPitch" o = DOMHTMLMediaElementGetWebkitPreservesPitchMethodInfo
    ResolveDOMHTMLMediaElementMethod "getWebkitRegionOverflow" o = WebKit.DOMElement.DOMElementGetWebkitRegionOverflowMethodInfo
    ResolveDOMHTMLMediaElementMethod "getWebkitRegionOverset" o = WebKit.DOMElement.DOMElementGetWebkitRegionOversetMethodInfo
    ResolveDOMHTMLMediaElementMethod "getWebkitVideoDecodedByteCount" o = DOMHTMLMediaElementGetWebkitVideoDecodedByteCountMethodInfo
    ResolveDOMHTMLMediaElementMethod "getWebkitdropzone" o = WebKit.DOMHTMLElement.DOMHTMLElementGetWebkitdropzoneMethodInfo
    ResolveDOMHTMLMediaElementMethod "setAccessKey" o = WebKit.DOMHTMLElement.DOMHTMLElementSetAccessKeyMethodInfo
    ResolveDOMHTMLMediaElementMethod "setAttribute" o = WebKit.DOMElement.DOMElementSetAttributeMethodInfo
    ResolveDOMHTMLMediaElementMethod "setAttributeNode" o = WebKit.DOMElement.DOMElementSetAttributeNodeMethodInfo
    ResolveDOMHTMLMediaElementMethod "setAttributeNodeNs" o = WebKit.DOMElement.DOMElementSetAttributeNodeNsMethodInfo
    ResolveDOMHTMLMediaElementMethod "setAttributeNs" o = WebKit.DOMElement.DOMElementSetAttributeNsMethodInfo
    ResolveDOMHTMLMediaElementMethod "setAutoplay" o = DOMHTMLMediaElementSetAutoplayMethodInfo
    ResolveDOMHTMLMediaElementMethod "setClassName" o = WebKit.DOMHTMLElement.DOMHTMLElementSetClassNameMethodInfo
    ResolveDOMHTMLMediaElementMethod "setContentEditable" o = WebKit.DOMHTMLElement.DOMHTMLElementSetContentEditableMethodInfo
    ResolveDOMHTMLMediaElementMethod "setControls" o = DOMHTMLMediaElementSetControlsMethodInfo
    ResolveDOMHTMLMediaElementMethod "setCurrentTime" o = DOMHTMLMediaElementSetCurrentTimeMethodInfo
    ResolveDOMHTMLMediaElementMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveDOMHTMLMediaElementMethod "setDefaultMuted" o = DOMHTMLMediaElementSetDefaultMutedMethodInfo
    ResolveDOMHTMLMediaElementMethod "setDefaultPlaybackRate" o = DOMHTMLMediaElementSetDefaultPlaybackRateMethodInfo
    ResolveDOMHTMLMediaElementMethod "setDir" o = WebKit.DOMHTMLElement.DOMHTMLElementSetDirMethodInfo
    ResolveDOMHTMLMediaElementMethod "setDraggable" o = WebKit.DOMHTMLElement.DOMHTMLElementSetDraggableMethodInfo
    ResolveDOMHTMLMediaElementMethod "setHidden" o = WebKit.DOMHTMLElement.DOMHTMLElementSetHiddenMethodInfo
    ResolveDOMHTMLMediaElementMethod "setId" o = WebKit.DOMHTMLElement.DOMHTMLElementSetIdMethodInfo
    ResolveDOMHTMLMediaElementMethod "setInnerHtml" o = WebKit.DOMHTMLElement.DOMHTMLElementSetInnerHtmlMethodInfo
    ResolveDOMHTMLMediaElementMethod "setInnerText" o = WebKit.DOMHTMLElement.DOMHTMLElementSetInnerTextMethodInfo
    ResolveDOMHTMLMediaElementMethod "setItemId" o = WebKit.DOMHTMLElement.DOMHTMLElementSetItemIdMethodInfo
    ResolveDOMHTMLMediaElementMethod "setItemScope" o = WebKit.DOMHTMLElement.DOMHTMLElementSetItemScopeMethodInfo
    ResolveDOMHTMLMediaElementMethod "setLang" o = WebKit.DOMHTMLElement.DOMHTMLElementSetLangMethodInfo
    ResolveDOMHTMLMediaElementMethod "setLoop" o = DOMHTMLMediaElementSetLoopMethodInfo
    ResolveDOMHTMLMediaElementMethod "setMediaGroup" o = DOMHTMLMediaElementSetMediaGroupMethodInfo
    ResolveDOMHTMLMediaElementMethod "setMuted" o = DOMHTMLMediaElementSetMutedMethodInfo
    ResolveDOMHTMLMediaElementMethod "setNodeValue" o = WebKit.DOMNode.DOMNodeSetNodeValueMethodInfo
    ResolveDOMHTMLMediaElementMethod "setOuterHtml" o = WebKit.DOMHTMLElement.DOMHTMLElementSetOuterHtmlMethodInfo
    ResolveDOMHTMLMediaElementMethod "setOuterText" o = WebKit.DOMHTMLElement.DOMHTMLElementSetOuterTextMethodInfo
    ResolveDOMHTMLMediaElementMethod "setPlaybackRate" o = DOMHTMLMediaElementSetPlaybackRateMethodInfo
    ResolveDOMHTMLMediaElementMethod "setPrefix" o = WebKit.DOMNode.DOMNodeSetPrefixMethodInfo
    ResolveDOMHTMLMediaElementMethod "setPreload" o = DOMHTMLMediaElementSetPreloadMethodInfo
    ResolveDOMHTMLMediaElementMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveDOMHTMLMediaElementMethod "setScrollLeft" o = WebKit.DOMElement.DOMElementSetScrollLeftMethodInfo
    ResolveDOMHTMLMediaElementMethod "setScrollTop" o = WebKit.DOMElement.DOMElementSetScrollTopMethodInfo
    ResolveDOMHTMLMediaElementMethod "setSpellcheck" o = WebKit.DOMHTMLElement.DOMHTMLElementSetSpellcheckMethodInfo
    ResolveDOMHTMLMediaElementMethod "setSrc" o = DOMHTMLMediaElementSetSrcMethodInfo
    ResolveDOMHTMLMediaElementMethod "setTabIndex" o = WebKit.DOMHTMLElement.DOMHTMLElementSetTabIndexMethodInfo
    ResolveDOMHTMLMediaElementMethod "setTextContent" o = WebKit.DOMNode.DOMNodeSetTextContentMethodInfo
    ResolveDOMHTMLMediaElementMethod "setTitle" o = WebKit.DOMHTMLElement.DOMHTMLElementSetTitleMethodInfo
    ResolveDOMHTMLMediaElementMethod "setTranslate" o = WebKit.DOMHTMLElement.DOMHTMLElementSetTranslateMethodInfo
    ResolveDOMHTMLMediaElementMethod "setVolume" o = DOMHTMLMediaElementSetVolumeMethodInfo
    ResolveDOMHTMLMediaElementMethod "setWebkitClosedCaptionsVisible" o = DOMHTMLMediaElementSetWebkitClosedCaptionsVisibleMethodInfo
    ResolveDOMHTMLMediaElementMethod "setWebkitPreservesPitch" o = DOMHTMLMediaElementSetWebkitPreservesPitchMethodInfo
    ResolveDOMHTMLMediaElementMethod "setWebkitdropzone" o = WebKit.DOMHTMLElement.DOMHTMLElementSetWebkitdropzoneMethodInfo
    ResolveDOMHTMLMediaElementMethod l o = O.MethodResolutionFailed l o

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

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

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

getDOMHTMLMediaElementAudioTracks :: (MonadIO m, IsDOMHTMLMediaElement o) => o -> m (Maybe WebKit.DOMAudioTrackList.DOMAudioTrackList)
getDOMHTMLMediaElementAudioTracks obj = liftIO $ getObjectPropertyObject obj "audio-tracks" WebKit.DOMAudioTrackList.DOMAudioTrackList

data DOMHTMLMediaElementAudioTracksPropertyInfo
instance AttrInfo DOMHTMLMediaElementAudioTracksPropertyInfo where
    type AttrAllowedOps DOMHTMLMediaElementAudioTracksPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint DOMHTMLMediaElementAudioTracksPropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMHTMLMediaElementAudioTracksPropertyInfo = IsDOMHTMLMediaElement
    type AttrGetType DOMHTMLMediaElementAudioTracksPropertyInfo = (Maybe WebKit.DOMAudioTrackList.DOMAudioTrackList)
    type AttrLabel DOMHTMLMediaElementAudioTracksPropertyInfo = "audio-tracks"
    type AttrOrigin DOMHTMLMediaElementAudioTracksPropertyInfo = DOMHTMLMediaElement
    attrGet _ = getDOMHTMLMediaElementAudioTracks
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

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

getDOMHTMLMediaElementAutoplay :: (MonadIO m, IsDOMHTMLMediaElement o) => o -> m Bool
getDOMHTMLMediaElementAutoplay obj = liftIO $ getObjectPropertyBool obj "autoplay"

setDOMHTMLMediaElementAutoplay :: (MonadIO m, IsDOMHTMLMediaElement o) => o -> Bool -> m ()
setDOMHTMLMediaElementAutoplay obj val = liftIO $ setObjectPropertyBool obj "autoplay" val

constructDOMHTMLMediaElementAutoplay :: (IsDOMHTMLMediaElement o) => Bool -> IO (GValueConstruct o)
constructDOMHTMLMediaElementAutoplay val = constructObjectPropertyBool "autoplay" val

data DOMHTMLMediaElementAutoplayPropertyInfo
instance AttrInfo DOMHTMLMediaElementAutoplayPropertyInfo where
    type AttrAllowedOps DOMHTMLMediaElementAutoplayPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint DOMHTMLMediaElementAutoplayPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint DOMHTMLMediaElementAutoplayPropertyInfo = IsDOMHTMLMediaElement
    type AttrGetType DOMHTMLMediaElementAutoplayPropertyInfo = Bool
    type AttrLabel DOMHTMLMediaElementAutoplayPropertyInfo = "autoplay"
    type AttrOrigin DOMHTMLMediaElementAutoplayPropertyInfo = DOMHTMLMediaElement
    attrGet _ = getDOMHTMLMediaElementAutoplay
    attrSet _ = setDOMHTMLMediaElementAutoplay
    attrConstruct _ = constructDOMHTMLMediaElementAutoplay
    attrClear _ = undefined

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

getDOMHTMLMediaElementBuffered :: (MonadIO m, IsDOMHTMLMediaElement o) => o -> m (Maybe WebKit.DOMTimeRanges.DOMTimeRanges)
getDOMHTMLMediaElementBuffered obj = liftIO $ getObjectPropertyObject obj "buffered" WebKit.DOMTimeRanges.DOMTimeRanges

data DOMHTMLMediaElementBufferedPropertyInfo
instance AttrInfo DOMHTMLMediaElementBufferedPropertyInfo where
    type AttrAllowedOps DOMHTMLMediaElementBufferedPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint DOMHTMLMediaElementBufferedPropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMHTMLMediaElementBufferedPropertyInfo = IsDOMHTMLMediaElement
    type AttrGetType DOMHTMLMediaElementBufferedPropertyInfo = (Maybe WebKit.DOMTimeRanges.DOMTimeRanges)
    type AttrLabel DOMHTMLMediaElementBufferedPropertyInfo = "buffered"
    type AttrOrigin DOMHTMLMediaElementBufferedPropertyInfo = DOMHTMLMediaElement
    attrGet _ = getDOMHTMLMediaElementBuffered
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

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

getDOMHTMLMediaElementController :: (MonadIO m, IsDOMHTMLMediaElement o) => o -> m (Maybe WebKit.DOMMediaController.DOMMediaController)
getDOMHTMLMediaElementController obj = liftIO $ getObjectPropertyObject obj "controller" WebKit.DOMMediaController.DOMMediaController

data DOMHTMLMediaElementControllerPropertyInfo
instance AttrInfo DOMHTMLMediaElementControllerPropertyInfo where
    type AttrAllowedOps DOMHTMLMediaElementControllerPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint DOMHTMLMediaElementControllerPropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMHTMLMediaElementControllerPropertyInfo = IsDOMHTMLMediaElement
    type AttrGetType DOMHTMLMediaElementControllerPropertyInfo = (Maybe WebKit.DOMMediaController.DOMMediaController)
    type AttrLabel DOMHTMLMediaElementControllerPropertyInfo = "controller"
    type AttrOrigin DOMHTMLMediaElementControllerPropertyInfo = DOMHTMLMediaElement
    attrGet _ = getDOMHTMLMediaElementController
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

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

getDOMHTMLMediaElementControls :: (MonadIO m, IsDOMHTMLMediaElement o) => o -> m Bool
getDOMHTMLMediaElementControls obj = liftIO $ getObjectPropertyBool obj "controls"

setDOMHTMLMediaElementControls :: (MonadIO m, IsDOMHTMLMediaElement o) => o -> Bool -> m ()
setDOMHTMLMediaElementControls obj val = liftIO $ setObjectPropertyBool obj "controls" val

constructDOMHTMLMediaElementControls :: (IsDOMHTMLMediaElement o) => Bool -> IO (GValueConstruct o)
constructDOMHTMLMediaElementControls val = constructObjectPropertyBool "controls" val

data DOMHTMLMediaElementControlsPropertyInfo
instance AttrInfo DOMHTMLMediaElementControlsPropertyInfo where
    type AttrAllowedOps DOMHTMLMediaElementControlsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint DOMHTMLMediaElementControlsPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint DOMHTMLMediaElementControlsPropertyInfo = IsDOMHTMLMediaElement
    type AttrGetType DOMHTMLMediaElementControlsPropertyInfo = Bool
    type AttrLabel DOMHTMLMediaElementControlsPropertyInfo = "controls"
    type AttrOrigin DOMHTMLMediaElementControlsPropertyInfo = DOMHTMLMediaElement
    attrGet _ = getDOMHTMLMediaElementControls
    attrSet _ = setDOMHTMLMediaElementControls
    attrConstruct _ = constructDOMHTMLMediaElementControls
    attrClear _ = undefined

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

getDOMHTMLMediaElementCurrentSrc :: (MonadIO m, IsDOMHTMLMediaElement o) => o -> m (Maybe T.Text)
getDOMHTMLMediaElementCurrentSrc obj = liftIO $ getObjectPropertyString obj "current-src"

data DOMHTMLMediaElementCurrentSrcPropertyInfo
instance AttrInfo DOMHTMLMediaElementCurrentSrcPropertyInfo where
    type AttrAllowedOps DOMHTMLMediaElementCurrentSrcPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint DOMHTMLMediaElementCurrentSrcPropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMHTMLMediaElementCurrentSrcPropertyInfo = IsDOMHTMLMediaElement
    type AttrGetType DOMHTMLMediaElementCurrentSrcPropertyInfo = (Maybe T.Text)
    type AttrLabel DOMHTMLMediaElementCurrentSrcPropertyInfo = "current-src"
    type AttrOrigin DOMHTMLMediaElementCurrentSrcPropertyInfo = DOMHTMLMediaElement
    attrGet _ = getDOMHTMLMediaElementCurrentSrc
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

-- VVV Prop "current-time"
   -- Type: TBasicType TDouble
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Nothing)

getDOMHTMLMediaElementCurrentTime :: (MonadIO m, IsDOMHTMLMediaElement o) => o -> m Double
getDOMHTMLMediaElementCurrentTime obj = liftIO $ getObjectPropertyDouble obj "current-time"

setDOMHTMLMediaElementCurrentTime :: (MonadIO m, IsDOMHTMLMediaElement o) => o -> Double -> m ()
setDOMHTMLMediaElementCurrentTime obj val = liftIO $ setObjectPropertyDouble obj "current-time" val

constructDOMHTMLMediaElementCurrentTime :: (IsDOMHTMLMediaElement o) => Double -> IO (GValueConstruct o)
constructDOMHTMLMediaElementCurrentTime val = constructObjectPropertyDouble "current-time" val

data DOMHTMLMediaElementCurrentTimePropertyInfo
instance AttrInfo DOMHTMLMediaElementCurrentTimePropertyInfo where
    type AttrAllowedOps DOMHTMLMediaElementCurrentTimePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint DOMHTMLMediaElementCurrentTimePropertyInfo = (~) Double
    type AttrBaseTypeConstraint DOMHTMLMediaElementCurrentTimePropertyInfo = IsDOMHTMLMediaElement
    type AttrGetType DOMHTMLMediaElementCurrentTimePropertyInfo = Double
    type AttrLabel DOMHTMLMediaElementCurrentTimePropertyInfo = "current-time"
    type AttrOrigin DOMHTMLMediaElementCurrentTimePropertyInfo = DOMHTMLMediaElement
    attrGet _ = getDOMHTMLMediaElementCurrentTime
    attrSet _ = setDOMHTMLMediaElementCurrentTime
    attrConstruct _ = constructDOMHTMLMediaElementCurrentTime
    attrClear _ = undefined

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

getDOMHTMLMediaElementDefaultMuted :: (MonadIO m, IsDOMHTMLMediaElement o) => o -> m Bool
getDOMHTMLMediaElementDefaultMuted obj = liftIO $ getObjectPropertyBool obj "default-muted"

setDOMHTMLMediaElementDefaultMuted :: (MonadIO m, IsDOMHTMLMediaElement o) => o -> Bool -> m ()
setDOMHTMLMediaElementDefaultMuted obj val = liftIO $ setObjectPropertyBool obj "default-muted" val

constructDOMHTMLMediaElementDefaultMuted :: (IsDOMHTMLMediaElement o) => Bool -> IO (GValueConstruct o)
constructDOMHTMLMediaElementDefaultMuted val = constructObjectPropertyBool "default-muted" val

data DOMHTMLMediaElementDefaultMutedPropertyInfo
instance AttrInfo DOMHTMLMediaElementDefaultMutedPropertyInfo where
    type AttrAllowedOps DOMHTMLMediaElementDefaultMutedPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint DOMHTMLMediaElementDefaultMutedPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint DOMHTMLMediaElementDefaultMutedPropertyInfo = IsDOMHTMLMediaElement
    type AttrGetType DOMHTMLMediaElementDefaultMutedPropertyInfo = Bool
    type AttrLabel DOMHTMLMediaElementDefaultMutedPropertyInfo = "default-muted"
    type AttrOrigin DOMHTMLMediaElementDefaultMutedPropertyInfo = DOMHTMLMediaElement
    attrGet _ = getDOMHTMLMediaElementDefaultMuted
    attrSet _ = setDOMHTMLMediaElementDefaultMuted
    attrConstruct _ = constructDOMHTMLMediaElementDefaultMuted
    attrClear _ = undefined

-- VVV Prop "default-playback-rate"
   -- Type: TBasicType TDouble
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getDOMHTMLMediaElementDefaultPlaybackRate :: (MonadIO m, IsDOMHTMLMediaElement o) => o -> m Double
getDOMHTMLMediaElementDefaultPlaybackRate obj = liftIO $ getObjectPropertyDouble obj "default-playback-rate"

setDOMHTMLMediaElementDefaultPlaybackRate :: (MonadIO m, IsDOMHTMLMediaElement o) => o -> Double -> m ()
setDOMHTMLMediaElementDefaultPlaybackRate obj val = liftIO $ setObjectPropertyDouble obj "default-playback-rate" val

constructDOMHTMLMediaElementDefaultPlaybackRate :: (IsDOMHTMLMediaElement o) => Double -> IO (GValueConstruct o)
constructDOMHTMLMediaElementDefaultPlaybackRate val = constructObjectPropertyDouble "default-playback-rate" val

data DOMHTMLMediaElementDefaultPlaybackRatePropertyInfo
instance AttrInfo DOMHTMLMediaElementDefaultPlaybackRatePropertyInfo where
    type AttrAllowedOps DOMHTMLMediaElementDefaultPlaybackRatePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint DOMHTMLMediaElementDefaultPlaybackRatePropertyInfo = (~) Double
    type AttrBaseTypeConstraint DOMHTMLMediaElementDefaultPlaybackRatePropertyInfo = IsDOMHTMLMediaElement
    type AttrGetType DOMHTMLMediaElementDefaultPlaybackRatePropertyInfo = Double
    type AttrLabel DOMHTMLMediaElementDefaultPlaybackRatePropertyInfo = "default-playback-rate"
    type AttrOrigin DOMHTMLMediaElementDefaultPlaybackRatePropertyInfo = DOMHTMLMediaElement
    attrGet _ = getDOMHTMLMediaElementDefaultPlaybackRate
    attrSet _ = setDOMHTMLMediaElementDefaultPlaybackRate
    attrConstruct _ = constructDOMHTMLMediaElementDefaultPlaybackRate
    attrClear _ = undefined

-- VVV Prop "duration"
   -- Type: TBasicType TDouble
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

getDOMHTMLMediaElementDuration :: (MonadIO m, IsDOMHTMLMediaElement o) => o -> m Double
getDOMHTMLMediaElementDuration obj = liftIO $ getObjectPropertyDouble obj "duration"

data DOMHTMLMediaElementDurationPropertyInfo
instance AttrInfo DOMHTMLMediaElementDurationPropertyInfo where
    type AttrAllowedOps DOMHTMLMediaElementDurationPropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint DOMHTMLMediaElementDurationPropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMHTMLMediaElementDurationPropertyInfo = IsDOMHTMLMediaElement
    type AttrGetType DOMHTMLMediaElementDurationPropertyInfo = Double
    type AttrLabel DOMHTMLMediaElementDurationPropertyInfo = "duration"
    type AttrOrigin DOMHTMLMediaElementDurationPropertyInfo = DOMHTMLMediaElement
    attrGet _ = getDOMHTMLMediaElementDuration
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

-- VVV Prop "ended"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

getDOMHTMLMediaElementEnded :: (MonadIO m, IsDOMHTMLMediaElement o) => o -> m Bool
getDOMHTMLMediaElementEnded obj = liftIO $ getObjectPropertyBool obj "ended"

data DOMHTMLMediaElementEndedPropertyInfo
instance AttrInfo DOMHTMLMediaElementEndedPropertyInfo where
    type AttrAllowedOps DOMHTMLMediaElementEndedPropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint DOMHTMLMediaElementEndedPropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMHTMLMediaElementEndedPropertyInfo = IsDOMHTMLMediaElement
    type AttrGetType DOMHTMLMediaElementEndedPropertyInfo = Bool
    type AttrLabel DOMHTMLMediaElementEndedPropertyInfo = "ended"
    type AttrOrigin DOMHTMLMediaElementEndedPropertyInfo = DOMHTMLMediaElement
    attrGet _ = getDOMHTMLMediaElementEnded
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

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

getDOMHTMLMediaElementError :: (MonadIO m, IsDOMHTMLMediaElement o) => o -> m (Maybe WebKit.DOMMediaError.DOMMediaError)
getDOMHTMLMediaElementError obj = liftIO $ getObjectPropertyObject obj "error" WebKit.DOMMediaError.DOMMediaError

data DOMHTMLMediaElementErrorPropertyInfo
instance AttrInfo DOMHTMLMediaElementErrorPropertyInfo where
    type AttrAllowedOps DOMHTMLMediaElementErrorPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint DOMHTMLMediaElementErrorPropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMHTMLMediaElementErrorPropertyInfo = IsDOMHTMLMediaElement
    type AttrGetType DOMHTMLMediaElementErrorPropertyInfo = (Maybe WebKit.DOMMediaError.DOMMediaError)
    type AttrLabel DOMHTMLMediaElementErrorPropertyInfo = "error"
    type AttrOrigin DOMHTMLMediaElementErrorPropertyInfo = DOMHTMLMediaElement
    attrGet _ = getDOMHTMLMediaElementError
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

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

getDOMHTMLMediaElementLoop :: (MonadIO m, IsDOMHTMLMediaElement o) => o -> m Bool
getDOMHTMLMediaElementLoop obj = liftIO $ getObjectPropertyBool obj "loop"

setDOMHTMLMediaElementLoop :: (MonadIO m, IsDOMHTMLMediaElement o) => o -> Bool -> m ()
setDOMHTMLMediaElementLoop obj val = liftIO $ setObjectPropertyBool obj "loop" val

constructDOMHTMLMediaElementLoop :: (IsDOMHTMLMediaElement o) => Bool -> IO (GValueConstruct o)
constructDOMHTMLMediaElementLoop val = constructObjectPropertyBool "loop" val

data DOMHTMLMediaElementLoopPropertyInfo
instance AttrInfo DOMHTMLMediaElementLoopPropertyInfo where
    type AttrAllowedOps DOMHTMLMediaElementLoopPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint DOMHTMLMediaElementLoopPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint DOMHTMLMediaElementLoopPropertyInfo = IsDOMHTMLMediaElement
    type AttrGetType DOMHTMLMediaElementLoopPropertyInfo = Bool
    type AttrLabel DOMHTMLMediaElementLoopPropertyInfo = "loop"
    type AttrOrigin DOMHTMLMediaElementLoopPropertyInfo = DOMHTMLMediaElement
    attrGet _ = getDOMHTMLMediaElementLoop
    attrSet _ = setDOMHTMLMediaElementLoop
    attrConstruct _ = constructDOMHTMLMediaElementLoop
    attrClear _ = undefined

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

getDOMHTMLMediaElementMediaGroup :: (MonadIO m, IsDOMHTMLMediaElement o) => o -> m (Maybe T.Text)
getDOMHTMLMediaElementMediaGroup obj = liftIO $ getObjectPropertyString obj "media-group"

setDOMHTMLMediaElementMediaGroup :: (MonadIO m, IsDOMHTMLMediaElement o) => o -> T.Text -> m ()
setDOMHTMLMediaElementMediaGroup obj val = liftIO $ setObjectPropertyString obj "media-group" (Just val)

constructDOMHTMLMediaElementMediaGroup :: (IsDOMHTMLMediaElement o) => T.Text -> IO (GValueConstruct o)
constructDOMHTMLMediaElementMediaGroup val = constructObjectPropertyString "media-group" (Just val)

data DOMHTMLMediaElementMediaGroupPropertyInfo
instance AttrInfo DOMHTMLMediaElementMediaGroupPropertyInfo where
    type AttrAllowedOps DOMHTMLMediaElementMediaGroupPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint DOMHTMLMediaElementMediaGroupPropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint DOMHTMLMediaElementMediaGroupPropertyInfo = IsDOMHTMLMediaElement
    type AttrGetType DOMHTMLMediaElementMediaGroupPropertyInfo = (Maybe T.Text)
    type AttrLabel DOMHTMLMediaElementMediaGroupPropertyInfo = "media-group"
    type AttrOrigin DOMHTMLMediaElementMediaGroupPropertyInfo = DOMHTMLMediaElement
    attrGet _ = getDOMHTMLMediaElementMediaGroup
    attrSet _ = setDOMHTMLMediaElementMediaGroup
    attrConstruct _ = constructDOMHTMLMediaElementMediaGroup
    attrClear _ = undefined

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

getDOMHTMLMediaElementMuted :: (MonadIO m, IsDOMHTMLMediaElement o) => o -> m Bool
getDOMHTMLMediaElementMuted obj = liftIO $ getObjectPropertyBool obj "muted"

setDOMHTMLMediaElementMuted :: (MonadIO m, IsDOMHTMLMediaElement o) => o -> Bool -> m ()
setDOMHTMLMediaElementMuted obj val = liftIO $ setObjectPropertyBool obj "muted" val

constructDOMHTMLMediaElementMuted :: (IsDOMHTMLMediaElement o) => Bool -> IO (GValueConstruct o)
constructDOMHTMLMediaElementMuted val = constructObjectPropertyBool "muted" val

data DOMHTMLMediaElementMutedPropertyInfo
instance AttrInfo DOMHTMLMediaElementMutedPropertyInfo where
    type AttrAllowedOps DOMHTMLMediaElementMutedPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint DOMHTMLMediaElementMutedPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint DOMHTMLMediaElementMutedPropertyInfo = IsDOMHTMLMediaElement
    type AttrGetType DOMHTMLMediaElementMutedPropertyInfo = Bool
    type AttrLabel DOMHTMLMediaElementMutedPropertyInfo = "muted"
    type AttrOrigin DOMHTMLMediaElementMutedPropertyInfo = DOMHTMLMediaElement
    attrGet _ = getDOMHTMLMediaElementMuted
    attrSet _ = setDOMHTMLMediaElementMuted
    attrConstruct _ = constructDOMHTMLMediaElementMuted
    attrClear _ = undefined

-- VVV Prop "network-state"
   -- Type: TBasicType TUInt
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

getDOMHTMLMediaElementNetworkState :: (MonadIO m, IsDOMHTMLMediaElement o) => o -> m Word32
getDOMHTMLMediaElementNetworkState obj = liftIO $ getObjectPropertyUInt32 obj "network-state"

data DOMHTMLMediaElementNetworkStatePropertyInfo
instance AttrInfo DOMHTMLMediaElementNetworkStatePropertyInfo where
    type AttrAllowedOps DOMHTMLMediaElementNetworkStatePropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint DOMHTMLMediaElementNetworkStatePropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMHTMLMediaElementNetworkStatePropertyInfo = IsDOMHTMLMediaElement
    type AttrGetType DOMHTMLMediaElementNetworkStatePropertyInfo = Word32
    type AttrLabel DOMHTMLMediaElementNetworkStatePropertyInfo = "network-state"
    type AttrOrigin DOMHTMLMediaElementNetworkStatePropertyInfo = DOMHTMLMediaElement
    attrGet _ = getDOMHTMLMediaElementNetworkState
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

-- VVV Prop "paused"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

getDOMHTMLMediaElementPaused :: (MonadIO m, IsDOMHTMLMediaElement o) => o -> m Bool
getDOMHTMLMediaElementPaused obj = liftIO $ getObjectPropertyBool obj "paused"

data DOMHTMLMediaElementPausedPropertyInfo
instance AttrInfo DOMHTMLMediaElementPausedPropertyInfo where
    type AttrAllowedOps DOMHTMLMediaElementPausedPropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint DOMHTMLMediaElementPausedPropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMHTMLMediaElementPausedPropertyInfo = IsDOMHTMLMediaElement
    type AttrGetType DOMHTMLMediaElementPausedPropertyInfo = Bool
    type AttrLabel DOMHTMLMediaElementPausedPropertyInfo = "paused"
    type AttrOrigin DOMHTMLMediaElementPausedPropertyInfo = DOMHTMLMediaElement
    attrGet _ = getDOMHTMLMediaElementPaused
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

-- VVV Prop "playback-rate"
   -- Type: TBasicType TDouble
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getDOMHTMLMediaElementPlaybackRate :: (MonadIO m, IsDOMHTMLMediaElement o) => o -> m Double
getDOMHTMLMediaElementPlaybackRate obj = liftIO $ getObjectPropertyDouble obj "playback-rate"

setDOMHTMLMediaElementPlaybackRate :: (MonadIO m, IsDOMHTMLMediaElement o) => o -> Double -> m ()
setDOMHTMLMediaElementPlaybackRate obj val = liftIO $ setObjectPropertyDouble obj "playback-rate" val

constructDOMHTMLMediaElementPlaybackRate :: (IsDOMHTMLMediaElement o) => Double -> IO (GValueConstruct o)
constructDOMHTMLMediaElementPlaybackRate val = constructObjectPropertyDouble "playback-rate" val

data DOMHTMLMediaElementPlaybackRatePropertyInfo
instance AttrInfo DOMHTMLMediaElementPlaybackRatePropertyInfo where
    type AttrAllowedOps DOMHTMLMediaElementPlaybackRatePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint DOMHTMLMediaElementPlaybackRatePropertyInfo = (~) Double
    type AttrBaseTypeConstraint DOMHTMLMediaElementPlaybackRatePropertyInfo = IsDOMHTMLMediaElement
    type AttrGetType DOMHTMLMediaElementPlaybackRatePropertyInfo = Double
    type AttrLabel DOMHTMLMediaElementPlaybackRatePropertyInfo = "playback-rate"
    type AttrOrigin DOMHTMLMediaElementPlaybackRatePropertyInfo = DOMHTMLMediaElement
    attrGet _ = getDOMHTMLMediaElementPlaybackRate
    attrSet _ = setDOMHTMLMediaElementPlaybackRate
    attrConstruct _ = constructDOMHTMLMediaElementPlaybackRate
    attrClear _ = undefined

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

getDOMHTMLMediaElementPlayed :: (MonadIO m, IsDOMHTMLMediaElement o) => o -> m (Maybe WebKit.DOMTimeRanges.DOMTimeRanges)
getDOMHTMLMediaElementPlayed obj = liftIO $ getObjectPropertyObject obj "played" WebKit.DOMTimeRanges.DOMTimeRanges

data DOMHTMLMediaElementPlayedPropertyInfo
instance AttrInfo DOMHTMLMediaElementPlayedPropertyInfo where
    type AttrAllowedOps DOMHTMLMediaElementPlayedPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint DOMHTMLMediaElementPlayedPropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMHTMLMediaElementPlayedPropertyInfo = IsDOMHTMLMediaElement
    type AttrGetType DOMHTMLMediaElementPlayedPropertyInfo = (Maybe WebKit.DOMTimeRanges.DOMTimeRanges)
    type AttrLabel DOMHTMLMediaElementPlayedPropertyInfo = "played"
    type AttrOrigin DOMHTMLMediaElementPlayedPropertyInfo = DOMHTMLMediaElement
    attrGet _ = getDOMHTMLMediaElementPlayed
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

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

getDOMHTMLMediaElementPreload :: (MonadIO m, IsDOMHTMLMediaElement o) => o -> m (Maybe T.Text)
getDOMHTMLMediaElementPreload obj = liftIO $ getObjectPropertyString obj "preload"

setDOMHTMLMediaElementPreload :: (MonadIO m, IsDOMHTMLMediaElement o) => o -> T.Text -> m ()
setDOMHTMLMediaElementPreload obj val = liftIO $ setObjectPropertyString obj "preload" (Just val)

constructDOMHTMLMediaElementPreload :: (IsDOMHTMLMediaElement o) => T.Text -> IO (GValueConstruct o)
constructDOMHTMLMediaElementPreload val = constructObjectPropertyString "preload" (Just val)

data DOMHTMLMediaElementPreloadPropertyInfo
instance AttrInfo DOMHTMLMediaElementPreloadPropertyInfo where
    type AttrAllowedOps DOMHTMLMediaElementPreloadPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint DOMHTMLMediaElementPreloadPropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint DOMHTMLMediaElementPreloadPropertyInfo = IsDOMHTMLMediaElement
    type AttrGetType DOMHTMLMediaElementPreloadPropertyInfo = (Maybe T.Text)
    type AttrLabel DOMHTMLMediaElementPreloadPropertyInfo = "preload"
    type AttrOrigin DOMHTMLMediaElementPreloadPropertyInfo = DOMHTMLMediaElement
    attrGet _ = getDOMHTMLMediaElementPreload
    attrSet _ = setDOMHTMLMediaElementPreload
    attrConstruct _ = constructDOMHTMLMediaElementPreload
    attrClear _ = undefined

-- VVV Prop "ready-state"
   -- Type: TBasicType TUInt
   -- Flags: [PropertyReadable]
   -- Nullable: (Nothing,Nothing)

getDOMHTMLMediaElementReadyState :: (MonadIO m, IsDOMHTMLMediaElement o) => o -> m Word32
getDOMHTMLMediaElementReadyState obj = liftIO $ getObjectPropertyUInt32 obj "ready-state"

data DOMHTMLMediaElementReadyStatePropertyInfo
instance AttrInfo DOMHTMLMediaElementReadyStatePropertyInfo where
    type AttrAllowedOps DOMHTMLMediaElementReadyStatePropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint DOMHTMLMediaElementReadyStatePropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMHTMLMediaElementReadyStatePropertyInfo = IsDOMHTMLMediaElement
    type AttrGetType DOMHTMLMediaElementReadyStatePropertyInfo = Word32
    type AttrLabel DOMHTMLMediaElementReadyStatePropertyInfo = "ready-state"
    type AttrOrigin DOMHTMLMediaElementReadyStatePropertyInfo = DOMHTMLMediaElement
    attrGet _ = getDOMHTMLMediaElementReadyState
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

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

getDOMHTMLMediaElementSeekable :: (MonadIO m, IsDOMHTMLMediaElement o) => o -> m (Maybe WebKit.DOMTimeRanges.DOMTimeRanges)
getDOMHTMLMediaElementSeekable obj = liftIO $ getObjectPropertyObject obj "seekable" WebKit.DOMTimeRanges.DOMTimeRanges

data DOMHTMLMediaElementSeekablePropertyInfo
instance AttrInfo DOMHTMLMediaElementSeekablePropertyInfo where
    type AttrAllowedOps DOMHTMLMediaElementSeekablePropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint DOMHTMLMediaElementSeekablePropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMHTMLMediaElementSeekablePropertyInfo = IsDOMHTMLMediaElement
    type AttrGetType DOMHTMLMediaElementSeekablePropertyInfo = (Maybe WebKit.DOMTimeRanges.DOMTimeRanges)
    type AttrLabel DOMHTMLMediaElementSeekablePropertyInfo = "seekable"
    type AttrOrigin DOMHTMLMediaElementSeekablePropertyInfo = DOMHTMLMediaElement
    attrGet _ = getDOMHTMLMediaElementSeekable
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

-- VVV Prop "seeking"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

getDOMHTMLMediaElementSeeking :: (MonadIO m, IsDOMHTMLMediaElement o) => o -> m Bool
getDOMHTMLMediaElementSeeking obj = liftIO $ getObjectPropertyBool obj "seeking"

data DOMHTMLMediaElementSeekingPropertyInfo
instance AttrInfo DOMHTMLMediaElementSeekingPropertyInfo where
    type AttrAllowedOps DOMHTMLMediaElementSeekingPropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint DOMHTMLMediaElementSeekingPropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMHTMLMediaElementSeekingPropertyInfo = IsDOMHTMLMediaElement
    type AttrGetType DOMHTMLMediaElementSeekingPropertyInfo = Bool
    type AttrLabel DOMHTMLMediaElementSeekingPropertyInfo = "seeking"
    type AttrOrigin DOMHTMLMediaElementSeekingPropertyInfo = DOMHTMLMediaElement
    attrGet _ = getDOMHTMLMediaElementSeeking
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

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

getDOMHTMLMediaElementSrc :: (MonadIO m, IsDOMHTMLMediaElement o) => o -> m (Maybe T.Text)
getDOMHTMLMediaElementSrc obj = liftIO $ getObjectPropertyString obj "src"

setDOMHTMLMediaElementSrc :: (MonadIO m, IsDOMHTMLMediaElement o) => o -> T.Text -> m ()
setDOMHTMLMediaElementSrc obj val = liftIO $ setObjectPropertyString obj "src" (Just val)

constructDOMHTMLMediaElementSrc :: (IsDOMHTMLMediaElement o) => T.Text -> IO (GValueConstruct o)
constructDOMHTMLMediaElementSrc val = constructObjectPropertyString "src" (Just val)

data DOMHTMLMediaElementSrcPropertyInfo
instance AttrInfo DOMHTMLMediaElementSrcPropertyInfo where
    type AttrAllowedOps DOMHTMLMediaElementSrcPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint DOMHTMLMediaElementSrcPropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint DOMHTMLMediaElementSrcPropertyInfo = IsDOMHTMLMediaElement
    type AttrGetType DOMHTMLMediaElementSrcPropertyInfo = (Maybe T.Text)
    type AttrLabel DOMHTMLMediaElementSrcPropertyInfo = "src"
    type AttrOrigin DOMHTMLMediaElementSrcPropertyInfo = DOMHTMLMediaElement
    attrGet _ = getDOMHTMLMediaElementSrc
    attrSet _ = setDOMHTMLMediaElementSrc
    attrConstruct _ = constructDOMHTMLMediaElementSrc
    attrClear _ = undefined

-- VVV Prop "text-tracks"
   -- Type: TInterface (Name {namespace = "WebKit", name = "DOMTextTrackList"})
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

getDOMHTMLMediaElementTextTracks :: (MonadIO m, IsDOMHTMLMediaElement o) => o -> m WebKit.DOMTextTrackList.DOMTextTrackList
getDOMHTMLMediaElementTextTracks obj = liftIO $ checkUnexpectedNothing "getDOMHTMLMediaElementTextTracks" $ getObjectPropertyObject obj "text-tracks" WebKit.DOMTextTrackList.DOMTextTrackList

data DOMHTMLMediaElementTextTracksPropertyInfo
instance AttrInfo DOMHTMLMediaElementTextTracksPropertyInfo where
    type AttrAllowedOps DOMHTMLMediaElementTextTracksPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint DOMHTMLMediaElementTextTracksPropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMHTMLMediaElementTextTracksPropertyInfo = IsDOMHTMLMediaElement
    type AttrGetType DOMHTMLMediaElementTextTracksPropertyInfo = WebKit.DOMTextTrackList.DOMTextTrackList
    type AttrLabel DOMHTMLMediaElementTextTracksPropertyInfo = "text-tracks"
    type AttrOrigin DOMHTMLMediaElementTextTracksPropertyInfo = DOMHTMLMediaElement
    attrGet _ = getDOMHTMLMediaElementTextTracks
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

-- VVV Prop "video-tracks"
   -- Type: TInterface (Name {namespace = "WebKit", name = "DOMVideoTrackList"})
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

getDOMHTMLMediaElementVideoTracks :: (MonadIO m, IsDOMHTMLMediaElement o) => o -> m WebKit.DOMVideoTrackList.DOMVideoTrackList
getDOMHTMLMediaElementVideoTracks obj = liftIO $ checkUnexpectedNothing "getDOMHTMLMediaElementVideoTracks" $ getObjectPropertyObject obj "video-tracks" WebKit.DOMVideoTrackList.DOMVideoTrackList

data DOMHTMLMediaElementVideoTracksPropertyInfo
instance AttrInfo DOMHTMLMediaElementVideoTracksPropertyInfo where
    type AttrAllowedOps DOMHTMLMediaElementVideoTracksPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint DOMHTMLMediaElementVideoTracksPropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMHTMLMediaElementVideoTracksPropertyInfo = IsDOMHTMLMediaElement
    type AttrGetType DOMHTMLMediaElementVideoTracksPropertyInfo = WebKit.DOMVideoTrackList.DOMVideoTrackList
    type AttrLabel DOMHTMLMediaElementVideoTracksPropertyInfo = "video-tracks"
    type AttrOrigin DOMHTMLMediaElementVideoTracksPropertyInfo = DOMHTMLMediaElement
    attrGet _ = getDOMHTMLMediaElementVideoTracks
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

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

getDOMHTMLMediaElementVolume :: (MonadIO m, IsDOMHTMLMediaElement o) => o -> m Double
getDOMHTMLMediaElementVolume obj = liftIO $ getObjectPropertyDouble obj "volume"

setDOMHTMLMediaElementVolume :: (MonadIO m, IsDOMHTMLMediaElement o) => o -> Double -> m ()
setDOMHTMLMediaElementVolume obj val = liftIO $ setObjectPropertyDouble obj "volume" val

constructDOMHTMLMediaElementVolume :: (IsDOMHTMLMediaElement o) => Double -> IO (GValueConstruct o)
constructDOMHTMLMediaElementVolume val = constructObjectPropertyDouble "volume" val

data DOMHTMLMediaElementVolumePropertyInfo
instance AttrInfo DOMHTMLMediaElementVolumePropertyInfo where
    type AttrAllowedOps DOMHTMLMediaElementVolumePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint DOMHTMLMediaElementVolumePropertyInfo = (~) Double
    type AttrBaseTypeConstraint DOMHTMLMediaElementVolumePropertyInfo = IsDOMHTMLMediaElement
    type AttrGetType DOMHTMLMediaElementVolumePropertyInfo = Double
    type AttrLabel DOMHTMLMediaElementVolumePropertyInfo = "volume"
    type AttrOrigin DOMHTMLMediaElementVolumePropertyInfo = DOMHTMLMediaElement
    attrGet _ = getDOMHTMLMediaElementVolume
    attrSet _ = setDOMHTMLMediaElementVolume
    attrConstruct _ = constructDOMHTMLMediaElementVolume
    attrClear _ = undefined

-- VVV Prop "webkit-audio-decoded-byte-count"
   -- Type: TBasicType TULong
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

getDOMHTMLMediaElementWebkitAudioDecodedByteCount :: (MonadIO m, IsDOMHTMLMediaElement o) => o -> m CULong
getDOMHTMLMediaElementWebkitAudioDecodedByteCount obj = liftIO $ getObjectPropertyULong obj "webkit-audio-decoded-byte-count"

data DOMHTMLMediaElementWebkitAudioDecodedByteCountPropertyInfo
instance AttrInfo DOMHTMLMediaElementWebkitAudioDecodedByteCountPropertyInfo where
    type AttrAllowedOps DOMHTMLMediaElementWebkitAudioDecodedByteCountPropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint DOMHTMLMediaElementWebkitAudioDecodedByteCountPropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMHTMLMediaElementWebkitAudioDecodedByteCountPropertyInfo = IsDOMHTMLMediaElement
    type AttrGetType DOMHTMLMediaElementWebkitAudioDecodedByteCountPropertyInfo = CULong
    type AttrLabel DOMHTMLMediaElementWebkitAudioDecodedByteCountPropertyInfo = "webkit-audio-decoded-byte-count"
    type AttrOrigin DOMHTMLMediaElementWebkitAudioDecodedByteCountPropertyInfo = DOMHTMLMediaElement
    attrGet _ = getDOMHTMLMediaElementWebkitAudioDecodedByteCount
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

-- VVV Prop "webkit-closed-captions-visible"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getDOMHTMLMediaElementWebkitClosedCaptionsVisible :: (MonadIO m, IsDOMHTMLMediaElement o) => o -> m Bool
getDOMHTMLMediaElementWebkitClosedCaptionsVisible obj = liftIO $ getObjectPropertyBool obj "webkit-closed-captions-visible"

setDOMHTMLMediaElementWebkitClosedCaptionsVisible :: (MonadIO m, IsDOMHTMLMediaElement o) => o -> Bool -> m ()
setDOMHTMLMediaElementWebkitClosedCaptionsVisible obj val = liftIO $ setObjectPropertyBool obj "webkit-closed-captions-visible" val

constructDOMHTMLMediaElementWebkitClosedCaptionsVisible :: (IsDOMHTMLMediaElement o) => Bool -> IO (GValueConstruct o)
constructDOMHTMLMediaElementWebkitClosedCaptionsVisible val = constructObjectPropertyBool "webkit-closed-captions-visible" val

data DOMHTMLMediaElementWebkitClosedCaptionsVisiblePropertyInfo
instance AttrInfo DOMHTMLMediaElementWebkitClosedCaptionsVisiblePropertyInfo where
    type AttrAllowedOps DOMHTMLMediaElementWebkitClosedCaptionsVisiblePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint DOMHTMLMediaElementWebkitClosedCaptionsVisiblePropertyInfo = (~) Bool
    type AttrBaseTypeConstraint DOMHTMLMediaElementWebkitClosedCaptionsVisiblePropertyInfo = IsDOMHTMLMediaElement
    type AttrGetType DOMHTMLMediaElementWebkitClosedCaptionsVisiblePropertyInfo = Bool
    type AttrLabel DOMHTMLMediaElementWebkitClosedCaptionsVisiblePropertyInfo = "webkit-closed-captions-visible"
    type AttrOrigin DOMHTMLMediaElementWebkitClosedCaptionsVisiblePropertyInfo = DOMHTMLMediaElement
    attrGet _ = getDOMHTMLMediaElementWebkitClosedCaptionsVisible
    attrSet _ = setDOMHTMLMediaElementWebkitClosedCaptionsVisible
    attrConstruct _ = constructDOMHTMLMediaElementWebkitClosedCaptionsVisible
    attrClear _ = undefined

-- VVV Prop "webkit-current-playback-target-is-wireless"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

getDOMHTMLMediaElementWebkitCurrentPlaybackTargetIsWireless :: (MonadIO m, IsDOMHTMLMediaElement o) => o -> m Bool
getDOMHTMLMediaElementWebkitCurrentPlaybackTargetIsWireless obj = liftIO $ getObjectPropertyBool obj "webkit-current-playback-target-is-wireless"

data DOMHTMLMediaElementWebkitCurrentPlaybackTargetIsWirelessPropertyInfo
instance AttrInfo DOMHTMLMediaElementWebkitCurrentPlaybackTargetIsWirelessPropertyInfo where
    type AttrAllowedOps DOMHTMLMediaElementWebkitCurrentPlaybackTargetIsWirelessPropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint DOMHTMLMediaElementWebkitCurrentPlaybackTargetIsWirelessPropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMHTMLMediaElementWebkitCurrentPlaybackTargetIsWirelessPropertyInfo = IsDOMHTMLMediaElement
    type AttrGetType DOMHTMLMediaElementWebkitCurrentPlaybackTargetIsWirelessPropertyInfo = Bool
    type AttrLabel DOMHTMLMediaElementWebkitCurrentPlaybackTargetIsWirelessPropertyInfo = "webkit-current-playback-target-is-wireless"
    type AttrOrigin DOMHTMLMediaElementWebkitCurrentPlaybackTargetIsWirelessPropertyInfo = DOMHTMLMediaElement
    attrGet _ = getDOMHTMLMediaElementWebkitCurrentPlaybackTargetIsWireless
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

-- VVV Prop "webkit-has-closed-captions"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

getDOMHTMLMediaElementWebkitHasClosedCaptions :: (MonadIO m, IsDOMHTMLMediaElement o) => o -> m Bool
getDOMHTMLMediaElementWebkitHasClosedCaptions obj = liftIO $ getObjectPropertyBool obj "webkit-has-closed-captions"

data DOMHTMLMediaElementWebkitHasClosedCaptionsPropertyInfo
instance AttrInfo DOMHTMLMediaElementWebkitHasClosedCaptionsPropertyInfo where
    type AttrAllowedOps DOMHTMLMediaElementWebkitHasClosedCaptionsPropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint DOMHTMLMediaElementWebkitHasClosedCaptionsPropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMHTMLMediaElementWebkitHasClosedCaptionsPropertyInfo = IsDOMHTMLMediaElement
    type AttrGetType DOMHTMLMediaElementWebkitHasClosedCaptionsPropertyInfo = Bool
    type AttrLabel DOMHTMLMediaElementWebkitHasClosedCaptionsPropertyInfo = "webkit-has-closed-captions"
    type AttrOrigin DOMHTMLMediaElementWebkitHasClosedCaptionsPropertyInfo = DOMHTMLMediaElement
    attrGet _ = getDOMHTMLMediaElementWebkitHasClosedCaptions
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

-- VVV Prop "webkit-preserves-pitch"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

getDOMHTMLMediaElementWebkitPreservesPitch :: (MonadIO m, IsDOMHTMLMediaElement o) => o -> m Bool
getDOMHTMLMediaElementWebkitPreservesPitch obj = liftIO $ getObjectPropertyBool obj "webkit-preserves-pitch"

setDOMHTMLMediaElementWebkitPreservesPitch :: (MonadIO m, IsDOMHTMLMediaElement o) => o -> Bool -> m ()
setDOMHTMLMediaElementWebkitPreservesPitch obj val = liftIO $ setObjectPropertyBool obj "webkit-preserves-pitch" val

constructDOMHTMLMediaElementWebkitPreservesPitch :: (IsDOMHTMLMediaElement o) => Bool -> IO (GValueConstruct o)
constructDOMHTMLMediaElementWebkitPreservesPitch val = constructObjectPropertyBool "webkit-preserves-pitch" val

data DOMHTMLMediaElementWebkitPreservesPitchPropertyInfo
instance AttrInfo DOMHTMLMediaElementWebkitPreservesPitchPropertyInfo where
    type AttrAllowedOps DOMHTMLMediaElementWebkitPreservesPitchPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint DOMHTMLMediaElementWebkitPreservesPitchPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint DOMHTMLMediaElementWebkitPreservesPitchPropertyInfo = IsDOMHTMLMediaElement
    type AttrGetType DOMHTMLMediaElementWebkitPreservesPitchPropertyInfo = Bool
    type AttrLabel DOMHTMLMediaElementWebkitPreservesPitchPropertyInfo = "webkit-preserves-pitch"
    type AttrOrigin DOMHTMLMediaElementWebkitPreservesPitchPropertyInfo = DOMHTMLMediaElement
    attrGet _ = getDOMHTMLMediaElementWebkitPreservesPitch
    attrSet _ = setDOMHTMLMediaElementWebkitPreservesPitch
    attrConstruct _ = constructDOMHTMLMediaElementWebkitPreservesPitch
    attrClear _ = undefined

-- VVV Prop "webkit-video-decoded-byte-count"
   -- Type: TBasicType TULong
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

getDOMHTMLMediaElementWebkitVideoDecodedByteCount :: (MonadIO m, IsDOMHTMLMediaElement o) => o -> m CULong
getDOMHTMLMediaElementWebkitVideoDecodedByteCount obj = liftIO $ getObjectPropertyULong obj "webkit-video-decoded-byte-count"

data DOMHTMLMediaElementWebkitVideoDecodedByteCountPropertyInfo
instance AttrInfo DOMHTMLMediaElementWebkitVideoDecodedByteCountPropertyInfo where
    type AttrAllowedOps DOMHTMLMediaElementWebkitVideoDecodedByteCountPropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint DOMHTMLMediaElementWebkitVideoDecodedByteCountPropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMHTMLMediaElementWebkitVideoDecodedByteCountPropertyInfo = IsDOMHTMLMediaElement
    type AttrGetType DOMHTMLMediaElementWebkitVideoDecodedByteCountPropertyInfo = CULong
    type AttrLabel DOMHTMLMediaElementWebkitVideoDecodedByteCountPropertyInfo = "webkit-video-decoded-byte-count"
    type AttrOrigin DOMHTMLMediaElementWebkitVideoDecodedByteCountPropertyInfo = DOMHTMLMediaElement
    attrGet _ = getDOMHTMLMediaElementWebkitVideoDecodedByteCount
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

instance O.HasAttributeList DOMHTMLMediaElement
type instance O.AttributeList DOMHTMLMediaElement = DOMHTMLMediaElementAttributeList
type DOMHTMLMediaElementAttributeList = ('[ '("accessKey", WebKit.DOMHTMLElement.DOMHTMLElementAccessKeyPropertyInfo), '("attributes", WebKit.DOMElement.DOMElementAttributesPropertyInfo), '("audioTracks", DOMHTMLMediaElementAudioTracksPropertyInfo), '("autoplay", DOMHTMLMediaElementAutoplayPropertyInfo), '("baseUri", WebKit.DOMNode.DOMNodeBaseUriPropertyInfo), '("buffered", DOMHTMLMediaElementBufferedPropertyInfo), '("childElementCount", WebKit.DOMElement.DOMElementChildElementCountPropertyInfo), '("childNodes", WebKit.DOMNode.DOMNodeChildNodesPropertyInfo), '("children", WebKit.DOMHTMLElement.DOMHTMLElementChildrenPropertyInfo), '("classList", WebKit.DOMElement.DOMElementClassListPropertyInfo), '("className", WebKit.DOMElement.DOMElementClassNamePropertyInfo), '("clientHeight", WebKit.DOMElement.DOMElementClientHeightPropertyInfo), '("clientLeft", WebKit.DOMElement.DOMElementClientLeftPropertyInfo), '("clientTop", WebKit.DOMElement.DOMElementClientTopPropertyInfo), '("clientWidth", WebKit.DOMElement.DOMElementClientWidthPropertyInfo), '("contentEditable", WebKit.DOMHTMLElement.DOMHTMLElementContentEditablePropertyInfo), '("controller", DOMHTMLMediaElementControllerPropertyInfo), '("controls", DOMHTMLMediaElementControlsPropertyInfo), '("coreObject", WebKit.DOMObject.DOMObjectCoreObjectPropertyInfo), '("currentSrc", DOMHTMLMediaElementCurrentSrcPropertyInfo), '("currentTime", DOMHTMLMediaElementCurrentTimePropertyInfo), '("defaultMuted", DOMHTMLMediaElementDefaultMutedPropertyInfo), '("defaultPlaybackRate", DOMHTMLMediaElementDefaultPlaybackRatePropertyInfo), '("dir", WebKit.DOMHTMLElement.DOMHTMLElementDirPropertyInfo), '("draggable", WebKit.DOMHTMLElement.DOMHTMLElementDraggablePropertyInfo), '("duration", DOMHTMLMediaElementDurationPropertyInfo), '("ended", DOMHTMLMediaElementEndedPropertyInfo), '("error", DOMHTMLMediaElementErrorPropertyInfo), '("firstChild", WebKit.DOMNode.DOMNodeFirstChildPropertyInfo), '("firstElementChild", WebKit.DOMElement.DOMElementFirstElementChildPropertyInfo), '("hidden", WebKit.DOMHTMLElement.DOMHTMLElementHiddenPropertyInfo), '("id", WebKit.DOMElement.DOMElementIdPropertyInfo), '("innerHtml", WebKit.DOMHTMLElement.DOMHTMLElementInnerHtmlPropertyInfo), '("innerText", WebKit.DOMHTMLElement.DOMHTMLElementInnerTextPropertyInfo), '("isContentEditable", WebKit.DOMHTMLElement.DOMHTMLElementIsContentEditablePropertyInfo), '("lang", WebKit.DOMHTMLElement.DOMHTMLElementLangPropertyInfo), '("lastChild", WebKit.DOMNode.DOMNodeLastChildPropertyInfo), '("lastElementChild", WebKit.DOMElement.DOMElementLastElementChildPropertyInfo), '("localName", WebKit.DOMNode.DOMNodeLocalNamePropertyInfo), '("loop", DOMHTMLMediaElementLoopPropertyInfo), '("mediaGroup", DOMHTMLMediaElementMediaGroupPropertyInfo), '("muted", DOMHTMLMediaElementMutedPropertyInfo), '("namespaceUri", WebKit.DOMNode.DOMNodeNamespaceUriPropertyInfo), '("networkState", DOMHTMLMediaElementNetworkStatePropertyInfo), '("nextElementSibling", WebKit.DOMElement.DOMElementNextElementSiblingPropertyInfo), '("nextSibling", WebKit.DOMNode.DOMNodeNextSiblingPropertyInfo), '("nodeName", WebKit.DOMNode.DOMNodeNodeNamePropertyInfo), '("nodeType", WebKit.DOMNode.DOMNodeNodeTypePropertyInfo), '("nodeValue", WebKit.DOMNode.DOMNodeNodeValuePropertyInfo), '("offsetHeight", WebKit.DOMElement.DOMElementOffsetHeightPropertyInfo), '("offsetLeft", WebKit.DOMElement.DOMElementOffsetLeftPropertyInfo), '("offsetParent", WebKit.DOMElement.DOMElementOffsetParentPropertyInfo), '("offsetTop", WebKit.DOMElement.DOMElementOffsetTopPropertyInfo), '("offsetWidth", WebKit.DOMElement.DOMElementOffsetWidthPropertyInfo), '("outerHtml", WebKit.DOMHTMLElement.DOMHTMLElementOuterHtmlPropertyInfo), '("outerText", WebKit.DOMHTMLElement.DOMHTMLElementOuterTextPropertyInfo), '("ownerDocument", WebKit.DOMNode.DOMNodeOwnerDocumentPropertyInfo), '("parentElement", WebKit.DOMNode.DOMNodeParentElementPropertyInfo), '("parentNode", WebKit.DOMNode.DOMNodeParentNodePropertyInfo), '("paused", DOMHTMLMediaElementPausedPropertyInfo), '("playbackRate", DOMHTMLMediaElementPlaybackRatePropertyInfo), '("played", DOMHTMLMediaElementPlayedPropertyInfo), '("prefix", WebKit.DOMNode.DOMNodePrefixPropertyInfo), '("preload", DOMHTMLMediaElementPreloadPropertyInfo), '("previousElementSibling", WebKit.DOMElement.DOMElementPreviousElementSiblingPropertyInfo), '("previousSibling", WebKit.DOMNode.DOMNodePreviousSiblingPropertyInfo), '("readyState", DOMHTMLMediaElementReadyStatePropertyInfo), '("scrollHeight", WebKit.DOMElement.DOMElementScrollHeightPropertyInfo), '("scrollLeft", WebKit.DOMElement.DOMElementScrollLeftPropertyInfo), '("scrollTop", WebKit.DOMElement.DOMElementScrollTopPropertyInfo), '("scrollWidth", WebKit.DOMElement.DOMElementScrollWidthPropertyInfo), '("seekable", DOMHTMLMediaElementSeekablePropertyInfo), '("seeking", DOMHTMLMediaElementSeekingPropertyInfo), '("spellcheck", WebKit.DOMHTMLElement.DOMHTMLElementSpellcheckPropertyInfo), '("src", DOMHTMLMediaElementSrcPropertyInfo), '("style", WebKit.DOMElement.DOMElementStylePropertyInfo), '("tabIndex", WebKit.DOMHTMLElement.DOMHTMLElementTabIndexPropertyInfo), '("tagName", WebKit.DOMElement.DOMElementTagNamePropertyInfo), '("textContent", WebKit.DOMNode.DOMNodeTextContentPropertyInfo), '("textTracks", DOMHTMLMediaElementTextTracksPropertyInfo), '("title", WebKit.DOMHTMLElement.DOMHTMLElementTitlePropertyInfo), '("translate", WebKit.DOMHTMLElement.DOMHTMLElementTranslatePropertyInfo), '("videoTracks", DOMHTMLMediaElementVideoTracksPropertyInfo), '("volume", DOMHTMLMediaElementVolumePropertyInfo), '("webkitAudioDecodedByteCount", DOMHTMLMediaElementWebkitAudioDecodedByteCountPropertyInfo), '("webkitClosedCaptionsVisible", DOMHTMLMediaElementWebkitClosedCaptionsVisiblePropertyInfo), '("webkitCurrentPlaybackTargetIsWireless", DOMHTMLMediaElementWebkitCurrentPlaybackTargetIsWirelessPropertyInfo), '("webkitHasClosedCaptions", DOMHTMLMediaElementWebkitHasClosedCaptionsPropertyInfo), '("webkitPreservesPitch", DOMHTMLMediaElementWebkitPreservesPitchPropertyInfo), '("webkitRegionOverset", WebKit.DOMElement.DOMElementWebkitRegionOversetPropertyInfo), '("webkitVideoDecodedByteCount", DOMHTMLMediaElementWebkitVideoDecodedByteCountPropertyInfo), '("webkitdropzone", WebKit.DOMHTMLElement.DOMHTMLElementWebkitdropzonePropertyInfo)] :: [(Symbol, *)])

dOMHTMLMediaElementAudioTracks :: AttrLabelProxy "audioTracks"
dOMHTMLMediaElementAudioTracks = AttrLabelProxy

dOMHTMLMediaElementAutoplay :: AttrLabelProxy "autoplay"
dOMHTMLMediaElementAutoplay = AttrLabelProxy

dOMHTMLMediaElementBuffered :: AttrLabelProxy "buffered"
dOMHTMLMediaElementBuffered = AttrLabelProxy

dOMHTMLMediaElementController :: AttrLabelProxy "controller"
dOMHTMLMediaElementController = AttrLabelProxy

dOMHTMLMediaElementControls :: AttrLabelProxy "controls"
dOMHTMLMediaElementControls = AttrLabelProxy

dOMHTMLMediaElementCurrentSrc :: AttrLabelProxy "currentSrc"
dOMHTMLMediaElementCurrentSrc = AttrLabelProxy

dOMHTMLMediaElementCurrentTime :: AttrLabelProxy "currentTime"
dOMHTMLMediaElementCurrentTime = AttrLabelProxy

dOMHTMLMediaElementDefaultMuted :: AttrLabelProxy "defaultMuted"
dOMHTMLMediaElementDefaultMuted = AttrLabelProxy

dOMHTMLMediaElementDefaultPlaybackRate :: AttrLabelProxy "defaultPlaybackRate"
dOMHTMLMediaElementDefaultPlaybackRate = AttrLabelProxy

dOMHTMLMediaElementDuration :: AttrLabelProxy "duration"
dOMHTMLMediaElementDuration = AttrLabelProxy

dOMHTMLMediaElementEnded :: AttrLabelProxy "ended"
dOMHTMLMediaElementEnded = AttrLabelProxy

dOMHTMLMediaElementError :: AttrLabelProxy "error"
dOMHTMLMediaElementError = AttrLabelProxy

dOMHTMLMediaElementLoop :: AttrLabelProxy "loop"
dOMHTMLMediaElementLoop = AttrLabelProxy

dOMHTMLMediaElementMediaGroup :: AttrLabelProxy "mediaGroup"
dOMHTMLMediaElementMediaGroup = AttrLabelProxy

dOMHTMLMediaElementMuted :: AttrLabelProxy "muted"
dOMHTMLMediaElementMuted = AttrLabelProxy

dOMHTMLMediaElementNetworkState :: AttrLabelProxy "networkState"
dOMHTMLMediaElementNetworkState = AttrLabelProxy

dOMHTMLMediaElementPaused :: AttrLabelProxy "paused"
dOMHTMLMediaElementPaused = AttrLabelProxy

dOMHTMLMediaElementPlaybackRate :: AttrLabelProxy "playbackRate"
dOMHTMLMediaElementPlaybackRate = AttrLabelProxy

dOMHTMLMediaElementPlayed :: AttrLabelProxy "played"
dOMHTMLMediaElementPlayed = AttrLabelProxy

dOMHTMLMediaElementPreload :: AttrLabelProxy "preload"
dOMHTMLMediaElementPreload = AttrLabelProxy

dOMHTMLMediaElementReadyState :: AttrLabelProxy "readyState"
dOMHTMLMediaElementReadyState = AttrLabelProxy

dOMHTMLMediaElementSeekable :: AttrLabelProxy "seekable"
dOMHTMLMediaElementSeekable = AttrLabelProxy

dOMHTMLMediaElementSeeking :: AttrLabelProxy "seeking"
dOMHTMLMediaElementSeeking = AttrLabelProxy

dOMHTMLMediaElementSrc :: AttrLabelProxy "src"
dOMHTMLMediaElementSrc = AttrLabelProxy

dOMHTMLMediaElementTextTracks :: AttrLabelProxy "textTracks"
dOMHTMLMediaElementTextTracks = AttrLabelProxy

dOMHTMLMediaElementVideoTracks :: AttrLabelProxy "videoTracks"
dOMHTMLMediaElementVideoTracks = AttrLabelProxy

dOMHTMLMediaElementVolume :: AttrLabelProxy "volume"
dOMHTMLMediaElementVolume = AttrLabelProxy

dOMHTMLMediaElementWebkitAudioDecodedByteCount :: AttrLabelProxy "webkitAudioDecodedByteCount"
dOMHTMLMediaElementWebkitAudioDecodedByteCount = AttrLabelProxy

dOMHTMLMediaElementWebkitClosedCaptionsVisible :: AttrLabelProxy "webkitClosedCaptionsVisible"
dOMHTMLMediaElementWebkitClosedCaptionsVisible = AttrLabelProxy

dOMHTMLMediaElementWebkitCurrentPlaybackTargetIsWireless :: AttrLabelProxy "webkitCurrentPlaybackTargetIsWireless"
dOMHTMLMediaElementWebkitCurrentPlaybackTargetIsWireless = AttrLabelProxy

dOMHTMLMediaElementWebkitHasClosedCaptions :: AttrLabelProxy "webkitHasClosedCaptions"
dOMHTMLMediaElementWebkitHasClosedCaptions = AttrLabelProxy

dOMHTMLMediaElementWebkitPreservesPitch :: AttrLabelProxy "webkitPreservesPitch"
dOMHTMLMediaElementWebkitPreservesPitch = AttrLabelProxy

dOMHTMLMediaElementWebkitVideoDecodedByteCount :: AttrLabelProxy "webkitVideoDecodedByteCount"
dOMHTMLMediaElementWebkitVideoDecodedByteCount = AttrLabelProxy

type instance O.SignalList DOMHTMLMediaElement = DOMHTMLMediaElementSignalList
type DOMHTMLMediaElementSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

-- method DOMHTMLMediaElement::add_text_track
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMHTMLMediaElement", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "kind", 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},Arg {argCName = "label", 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},Arg {argCName = "language", 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 : Just (TInterface (Name {namespace = "WebKit", name = "DOMTextTrack"}))
-- throws : True
-- Skip return : False

foreign import ccall "webkit_dom_html_media_element_add_text_track" webkit_dom_html_media_element_add_text_track :: 
    Ptr DOMHTMLMediaElement ->              -- self : TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"})
    CString ->                              -- kind : TBasicType TUTF8
    CString ->                              -- label : TBasicType TUTF8
    CString ->                              -- language : TBasicType TUTF8
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr WebKit.DOMTextTrack.DOMTextTrack)

{- |
/No description available in the introspection data./
-}
dOMHTMLMediaElementAddTextTrack ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMHTMLMediaElement a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMHTMLMediaElement.DOMHTMLMediaElement' -}
    -> T.Text
    {- ^ /@kind@/: A @/gchar/@ -}
    -> T.Text
    {- ^ /@label@/: A @/gchar/@ -}
    -> T.Text
    {- ^ /@language@/: A @/gchar/@ -}
    -> m WebKit.DOMTextTrack.DOMTextTrack
    {- ^ __Returns:__ A 'GI.WebKit.Objects.DOMTextTrack.DOMTextTrack' /(Can throw 'Data.GI.Base.GError.GError')/ -}
dOMHTMLMediaElementAddTextTrack self kind label language = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    kind' <- textToCString kind
    label' <- textToCString label
    language' <- textToCString language
    onException (do
        result <- propagateGError $ webkit_dom_html_media_element_add_text_track self' kind' label' language'
        checkUnexpectedReturnNULL "dOMHTMLMediaElementAddTextTrack" result
        result' <- (wrapObject WebKit.DOMTextTrack.DOMTextTrack) result
        touchManagedPtr self
        freeMem kind'
        freeMem label'
        freeMem language'
        return result'
     ) (do
        freeMem kind'
        freeMem label'
        freeMem language'
     )

data DOMHTMLMediaElementAddTextTrackMethodInfo
instance (signature ~ (T.Text -> T.Text -> T.Text -> m WebKit.DOMTextTrack.DOMTextTrack), MonadIO m, IsDOMHTMLMediaElement a) => O.MethodInfo DOMHTMLMediaElementAddTextTrackMethodInfo a signature where
    overloadedMethod _ = dOMHTMLMediaElementAddTextTrack

-- method DOMHTMLMediaElement::can_play_type
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMHTMLMediaElement", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "type", 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 : Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

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

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

data DOMHTMLMediaElementCanPlayTypeMethodInfo
instance (signature ~ (T.Text -> m T.Text), MonadIO m, IsDOMHTMLMediaElement a) => O.MethodInfo DOMHTMLMediaElementCanPlayTypeMethodInfo a signature where
    overloadedMethod _ = dOMHTMLMediaElementCanPlayType

-- method DOMHTMLMediaElement::fast_seek
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMHTMLMediaElement", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "time", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #gdouble", 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_html_media_element_fast_seek" webkit_dom_html_media_element_fast_seek :: 
    Ptr DOMHTMLMediaElement ->              -- self : TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"})
    CDouble ->                              -- time : TBasicType TDouble
    IO ()

{- |
/No description available in the introspection data./
-}
dOMHTMLMediaElementFastSeek ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMHTMLMediaElement a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMHTMLMediaElement.DOMHTMLMediaElement' -}
    -> Double
    {- ^ /@time@/: A @/gdouble/@ -}
    -> m ()
dOMHTMLMediaElementFastSeek self time = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    let time' = realToFrac time
    webkit_dom_html_media_element_fast_seek self' time'
    touchManagedPtr self
    return ()

data DOMHTMLMediaElementFastSeekMethodInfo
instance (signature ~ (Double -> m ()), MonadIO m, IsDOMHTMLMediaElement a) => O.MethodInfo DOMHTMLMediaElementFastSeekMethodInfo a signature where
    overloadedMethod _ = dOMHTMLMediaElementFastSeek

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

foreign import ccall "webkit_dom_html_media_element_get_audio_tracks" webkit_dom_html_media_element_get_audio_tracks :: 
    Ptr DOMHTMLMediaElement ->              -- self : TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"})
    IO (Ptr WebKit.DOMAudioTrackList.DOMAudioTrackList)

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

data DOMHTMLMediaElementGetAudioTracksMethodInfo
instance (signature ~ (m WebKit.DOMAudioTrackList.DOMAudioTrackList), MonadIO m, IsDOMHTMLMediaElement a) => O.MethodInfo DOMHTMLMediaElementGetAudioTracksMethodInfo a signature where
    overloadedMethod _ = dOMHTMLMediaElementGetAudioTracks

-- method DOMHTMLMediaElement::get_autoplay
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMHTMLMediaElement", 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 "webkit_dom_html_media_element_get_autoplay" webkit_dom_html_media_element_get_autoplay :: 
    Ptr DOMHTMLMediaElement ->              -- self : TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"})
    IO CInt

{- |
/No description available in the introspection data./
-}
dOMHTMLMediaElementGetAutoplay ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMHTMLMediaElement a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMHTMLMediaElement.DOMHTMLMediaElement' -}
    -> m Bool
    {- ^ __Returns:__ A 'Bool' -}
dOMHTMLMediaElementGetAutoplay self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_html_media_element_get_autoplay self'
    let result' = (/= 0) result
    touchManagedPtr self
    return result'

data DOMHTMLMediaElementGetAutoplayMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsDOMHTMLMediaElement a) => O.MethodInfo DOMHTMLMediaElementGetAutoplayMethodInfo a signature where
    overloadedMethod _ = dOMHTMLMediaElementGetAutoplay

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

foreign import ccall "webkit_dom_html_media_element_get_buffered" webkit_dom_html_media_element_get_buffered :: 
    Ptr DOMHTMLMediaElement ->              -- self : TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"})
    IO (Ptr WebKit.DOMTimeRanges.DOMTimeRanges)

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

data DOMHTMLMediaElementGetBufferedMethodInfo
instance (signature ~ (m WebKit.DOMTimeRanges.DOMTimeRanges), MonadIO m, IsDOMHTMLMediaElement a) => O.MethodInfo DOMHTMLMediaElementGetBufferedMethodInfo a signature where
    overloadedMethod _ = dOMHTMLMediaElementGetBuffered

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

foreign import ccall "webkit_dom_html_media_element_get_controller" webkit_dom_html_media_element_get_controller :: 
    Ptr DOMHTMLMediaElement ->              -- self : TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"})
    IO (Ptr WebKit.DOMMediaController.DOMMediaController)

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

data DOMHTMLMediaElementGetControllerMethodInfo
instance (signature ~ (m WebKit.DOMMediaController.DOMMediaController), MonadIO m, IsDOMHTMLMediaElement a) => O.MethodInfo DOMHTMLMediaElementGetControllerMethodInfo a signature where
    overloadedMethod _ = dOMHTMLMediaElementGetController

-- method DOMHTMLMediaElement::get_controls
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMHTMLMediaElement", 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 "webkit_dom_html_media_element_get_controls" webkit_dom_html_media_element_get_controls :: 
    Ptr DOMHTMLMediaElement ->              -- self : TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"})
    IO CInt

{- |
/No description available in the introspection data./
-}
dOMHTMLMediaElementGetControls ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMHTMLMediaElement a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMHTMLMediaElement.DOMHTMLMediaElement' -}
    -> m Bool
    {- ^ __Returns:__ A 'Bool' -}
dOMHTMLMediaElementGetControls self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_html_media_element_get_controls self'
    let result' = (/= 0) result
    touchManagedPtr self
    return result'

data DOMHTMLMediaElementGetControlsMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsDOMHTMLMediaElement a) => O.MethodInfo DOMHTMLMediaElementGetControlsMethodInfo a signature where
    overloadedMethod _ = dOMHTMLMediaElementGetControls

-- method DOMHTMLMediaElement::get_current_src
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMHTMLMediaElement", 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_html_media_element_get_current_src" webkit_dom_html_media_element_get_current_src :: 
    Ptr DOMHTMLMediaElement ->              -- self : TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"})
    IO CString

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

data DOMHTMLMediaElementGetCurrentSrcMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsDOMHTMLMediaElement a) => O.MethodInfo DOMHTMLMediaElementGetCurrentSrcMethodInfo a signature where
    overloadedMethod _ = dOMHTMLMediaElementGetCurrentSrc

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

foreign import ccall "webkit_dom_html_media_element_get_current_time" webkit_dom_html_media_element_get_current_time :: 
    Ptr DOMHTMLMediaElement ->              -- self : TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"})
    IO CDouble

{- |
/No description available in the introspection data./
-}
dOMHTMLMediaElementGetCurrentTime ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMHTMLMediaElement a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMHTMLMediaElement.DOMHTMLMediaElement' -}
    -> m Double
    {- ^ __Returns:__ A @/gdouble/@ -}
dOMHTMLMediaElementGetCurrentTime self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_html_media_element_get_current_time self'
    let result' = realToFrac result
    touchManagedPtr self
    return result'

data DOMHTMLMediaElementGetCurrentTimeMethodInfo
instance (signature ~ (m Double), MonadIO m, IsDOMHTMLMediaElement a) => O.MethodInfo DOMHTMLMediaElementGetCurrentTimeMethodInfo a signature where
    overloadedMethod _ = dOMHTMLMediaElementGetCurrentTime

-- method DOMHTMLMediaElement::get_default_muted
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMHTMLMediaElement", 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 "webkit_dom_html_media_element_get_default_muted" webkit_dom_html_media_element_get_default_muted :: 
    Ptr DOMHTMLMediaElement ->              -- self : TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"})
    IO CInt

{- |
/No description available in the introspection data./
-}
dOMHTMLMediaElementGetDefaultMuted ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMHTMLMediaElement a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMHTMLMediaElement.DOMHTMLMediaElement' -}
    -> m Bool
    {- ^ __Returns:__ A 'Bool' -}
dOMHTMLMediaElementGetDefaultMuted self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_html_media_element_get_default_muted self'
    let result' = (/= 0) result
    touchManagedPtr self
    return result'

data DOMHTMLMediaElementGetDefaultMutedMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsDOMHTMLMediaElement a) => O.MethodInfo DOMHTMLMediaElementGetDefaultMutedMethodInfo a signature where
    overloadedMethod _ = dOMHTMLMediaElementGetDefaultMuted

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

foreign import ccall "webkit_dom_html_media_element_get_default_playback_rate" webkit_dom_html_media_element_get_default_playback_rate :: 
    Ptr DOMHTMLMediaElement ->              -- self : TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"})
    IO CDouble

{- |
/No description available in the introspection data./
-}
dOMHTMLMediaElementGetDefaultPlaybackRate ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMHTMLMediaElement a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMHTMLMediaElement.DOMHTMLMediaElement' -}
    -> m Double
    {- ^ __Returns:__ A @/gdouble/@ -}
dOMHTMLMediaElementGetDefaultPlaybackRate self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_html_media_element_get_default_playback_rate self'
    let result' = realToFrac result
    touchManagedPtr self
    return result'

data DOMHTMLMediaElementGetDefaultPlaybackRateMethodInfo
instance (signature ~ (m Double), MonadIO m, IsDOMHTMLMediaElement a) => O.MethodInfo DOMHTMLMediaElementGetDefaultPlaybackRateMethodInfo a signature where
    overloadedMethod _ = dOMHTMLMediaElementGetDefaultPlaybackRate

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

foreign import ccall "webkit_dom_html_media_element_get_duration" webkit_dom_html_media_element_get_duration :: 
    Ptr DOMHTMLMediaElement ->              -- self : TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"})
    IO CDouble

{- |
/No description available in the introspection data./
-}
dOMHTMLMediaElementGetDuration ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMHTMLMediaElement a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMHTMLMediaElement.DOMHTMLMediaElement' -}
    -> m Double
    {- ^ __Returns:__ A @/gdouble/@ -}
dOMHTMLMediaElementGetDuration self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_html_media_element_get_duration self'
    let result' = realToFrac result
    touchManagedPtr self
    return result'

data DOMHTMLMediaElementGetDurationMethodInfo
instance (signature ~ (m Double), MonadIO m, IsDOMHTMLMediaElement a) => O.MethodInfo DOMHTMLMediaElementGetDurationMethodInfo a signature where
    overloadedMethod _ = dOMHTMLMediaElementGetDuration

-- method DOMHTMLMediaElement::get_ended
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMHTMLMediaElement", 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 "webkit_dom_html_media_element_get_ended" webkit_dom_html_media_element_get_ended :: 
    Ptr DOMHTMLMediaElement ->              -- self : TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"})
    IO CInt

{- |
/No description available in the introspection data./
-}
dOMHTMLMediaElementGetEnded ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMHTMLMediaElement a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMHTMLMediaElement.DOMHTMLMediaElement' -}
    -> m Bool
    {- ^ __Returns:__ A 'Bool' -}
dOMHTMLMediaElementGetEnded self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_html_media_element_get_ended self'
    let result' = (/= 0) result
    touchManagedPtr self
    return result'

data DOMHTMLMediaElementGetEndedMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsDOMHTMLMediaElement a) => O.MethodInfo DOMHTMLMediaElementGetEndedMethodInfo a signature where
    overloadedMethod _ = dOMHTMLMediaElementGetEnded

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

foreign import ccall "webkit_dom_html_media_element_get_error" webkit_dom_html_media_element_get_error :: 
    Ptr DOMHTMLMediaElement ->              -- self : TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"})
    IO (Ptr WebKit.DOMMediaError.DOMMediaError)

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

data DOMHTMLMediaElementGetErrorMethodInfo
instance (signature ~ (m WebKit.DOMMediaError.DOMMediaError), MonadIO m, IsDOMHTMLMediaElement a) => O.MethodInfo DOMHTMLMediaElementGetErrorMethodInfo a signature where
    overloadedMethod _ = dOMHTMLMediaElementGetError

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

foreign import ccall "webkit_dom_html_media_element_get_initial_time" webkit_dom_html_media_element_get_initial_time :: 
    Ptr DOMHTMLMediaElement ->              -- self : TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"})
    IO CDouble

{-# DEPRECATED dOMHTMLMediaElementGetInitialTime ["(Since version 2.2)"] #-}
{- |
The HTMLMediaElement:initial-time property has been removed from WebKit, this function does nothing.
-}
dOMHTMLMediaElementGetInitialTime ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMHTMLMediaElement a) =>
    a
    {- ^ /@self@/: A @/HTMLMediaElement/@ -}
    -> m Double
    {- ^ __Returns:__ A @/gdouble/@ -}
dOMHTMLMediaElementGetInitialTime self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_html_media_element_get_initial_time self'
    let result' = realToFrac result
    touchManagedPtr self
    return result'

data DOMHTMLMediaElementGetInitialTimeMethodInfo
instance (signature ~ (m Double), MonadIO m, IsDOMHTMLMediaElement a) => O.MethodInfo DOMHTMLMediaElementGetInitialTimeMethodInfo a signature where
    overloadedMethod _ = dOMHTMLMediaElementGetInitialTime

-- method DOMHTMLMediaElement::get_loop
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMHTMLMediaElement", 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 "webkit_dom_html_media_element_get_loop" webkit_dom_html_media_element_get_loop :: 
    Ptr DOMHTMLMediaElement ->              -- self : TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"})
    IO CInt

{- |
/No description available in the introspection data./
-}
dOMHTMLMediaElementGetLoop ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMHTMLMediaElement a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMHTMLMediaElement.DOMHTMLMediaElement' -}
    -> m Bool
    {- ^ __Returns:__ A 'Bool' -}
dOMHTMLMediaElementGetLoop self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_html_media_element_get_loop self'
    let result' = (/= 0) result
    touchManagedPtr self
    return result'

data DOMHTMLMediaElementGetLoopMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsDOMHTMLMediaElement a) => O.MethodInfo DOMHTMLMediaElementGetLoopMethodInfo a signature where
    overloadedMethod _ = dOMHTMLMediaElementGetLoop

-- method DOMHTMLMediaElement::get_media_group
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMHTMLMediaElement", 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_html_media_element_get_media_group" webkit_dom_html_media_element_get_media_group :: 
    Ptr DOMHTMLMediaElement ->              -- self : TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"})
    IO CString

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

data DOMHTMLMediaElementGetMediaGroupMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsDOMHTMLMediaElement a) => O.MethodInfo DOMHTMLMediaElementGetMediaGroupMethodInfo a signature where
    overloadedMethod _ = dOMHTMLMediaElementGetMediaGroup

-- method DOMHTMLMediaElement::get_muted
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMHTMLMediaElement", 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 "webkit_dom_html_media_element_get_muted" webkit_dom_html_media_element_get_muted :: 
    Ptr DOMHTMLMediaElement ->              -- self : TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"})
    IO CInt

{- |
/No description available in the introspection data./
-}
dOMHTMLMediaElementGetMuted ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMHTMLMediaElement a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMHTMLMediaElement.DOMHTMLMediaElement' -}
    -> m Bool
    {- ^ __Returns:__ A 'Bool' -}
dOMHTMLMediaElementGetMuted self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_html_media_element_get_muted self'
    let result' = (/= 0) result
    touchManagedPtr self
    return result'

data DOMHTMLMediaElementGetMutedMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsDOMHTMLMediaElement a) => O.MethodInfo DOMHTMLMediaElementGetMutedMethodInfo a signature where
    overloadedMethod _ = dOMHTMLMediaElementGetMuted

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

foreign import ccall "webkit_dom_html_media_element_get_network_state" webkit_dom_html_media_element_get_network_state :: 
    Ptr DOMHTMLMediaElement ->              -- self : TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"})
    IO Word16

{- |
/No description available in the introspection data./
-}
dOMHTMLMediaElementGetNetworkState ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMHTMLMediaElement a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMHTMLMediaElement.DOMHTMLMediaElement' -}
    -> m Word16
    {- ^ __Returns:__ A @/gushort/@ -}
dOMHTMLMediaElementGetNetworkState self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_html_media_element_get_network_state self'
    touchManagedPtr self
    return result

data DOMHTMLMediaElementGetNetworkStateMethodInfo
instance (signature ~ (m Word16), MonadIO m, IsDOMHTMLMediaElement a) => O.MethodInfo DOMHTMLMediaElementGetNetworkStateMethodInfo a signature where
    overloadedMethod _ = dOMHTMLMediaElementGetNetworkState

-- method DOMHTMLMediaElement::get_paused
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMHTMLMediaElement", 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 "webkit_dom_html_media_element_get_paused" webkit_dom_html_media_element_get_paused :: 
    Ptr DOMHTMLMediaElement ->              -- self : TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"})
    IO CInt

{- |
/No description available in the introspection data./
-}
dOMHTMLMediaElementGetPaused ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMHTMLMediaElement a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMHTMLMediaElement.DOMHTMLMediaElement' -}
    -> m Bool
    {- ^ __Returns:__ A 'Bool' -}
dOMHTMLMediaElementGetPaused self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_html_media_element_get_paused self'
    let result' = (/= 0) result
    touchManagedPtr self
    return result'

data DOMHTMLMediaElementGetPausedMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsDOMHTMLMediaElement a) => O.MethodInfo DOMHTMLMediaElementGetPausedMethodInfo a signature where
    overloadedMethod _ = dOMHTMLMediaElementGetPaused

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

foreign import ccall "webkit_dom_html_media_element_get_playback_rate" webkit_dom_html_media_element_get_playback_rate :: 
    Ptr DOMHTMLMediaElement ->              -- self : TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"})
    IO CDouble

{- |
/No description available in the introspection data./
-}
dOMHTMLMediaElementGetPlaybackRate ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMHTMLMediaElement a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMHTMLMediaElement.DOMHTMLMediaElement' -}
    -> m Double
    {- ^ __Returns:__ A @/gdouble/@ -}
dOMHTMLMediaElementGetPlaybackRate self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_html_media_element_get_playback_rate self'
    let result' = realToFrac result
    touchManagedPtr self
    return result'

data DOMHTMLMediaElementGetPlaybackRateMethodInfo
instance (signature ~ (m Double), MonadIO m, IsDOMHTMLMediaElement a) => O.MethodInfo DOMHTMLMediaElementGetPlaybackRateMethodInfo a signature where
    overloadedMethod _ = dOMHTMLMediaElementGetPlaybackRate

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

foreign import ccall "webkit_dom_html_media_element_get_played" webkit_dom_html_media_element_get_played :: 
    Ptr DOMHTMLMediaElement ->              -- self : TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"})
    IO (Ptr WebKit.DOMTimeRanges.DOMTimeRanges)

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

data DOMHTMLMediaElementGetPlayedMethodInfo
instance (signature ~ (m WebKit.DOMTimeRanges.DOMTimeRanges), MonadIO m, IsDOMHTMLMediaElement a) => O.MethodInfo DOMHTMLMediaElementGetPlayedMethodInfo a signature where
    overloadedMethod _ = dOMHTMLMediaElementGetPlayed

-- method DOMHTMLMediaElement::get_preload
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMHTMLMediaElement", 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_html_media_element_get_preload" webkit_dom_html_media_element_get_preload :: 
    Ptr DOMHTMLMediaElement ->              -- self : TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"})
    IO CString

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

data DOMHTMLMediaElementGetPreloadMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsDOMHTMLMediaElement a) => O.MethodInfo DOMHTMLMediaElementGetPreloadMethodInfo a signature where
    overloadedMethod _ = dOMHTMLMediaElementGetPreload

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

foreign import ccall "webkit_dom_html_media_element_get_ready_state" webkit_dom_html_media_element_get_ready_state :: 
    Ptr DOMHTMLMediaElement ->              -- self : TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"})
    IO Word16

{- |
/No description available in the introspection data./
-}
dOMHTMLMediaElementGetReadyState ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMHTMLMediaElement a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMHTMLMediaElement.DOMHTMLMediaElement' -}
    -> m Word16
    {- ^ __Returns:__ A @/gushort/@ -}
dOMHTMLMediaElementGetReadyState self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_html_media_element_get_ready_state self'
    touchManagedPtr self
    return result

data DOMHTMLMediaElementGetReadyStateMethodInfo
instance (signature ~ (m Word16), MonadIO m, IsDOMHTMLMediaElement a) => O.MethodInfo DOMHTMLMediaElementGetReadyStateMethodInfo a signature where
    overloadedMethod _ = dOMHTMLMediaElementGetReadyState

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

foreign import ccall "webkit_dom_html_media_element_get_seekable" webkit_dom_html_media_element_get_seekable :: 
    Ptr DOMHTMLMediaElement ->              -- self : TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"})
    IO (Ptr WebKit.DOMTimeRanges.DOMTimeRanges)

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

data DOMHTMLMediaElementGetSeekableMethodInfo
instance (signature ~ (m WebKit.DOMTimeRanges.DOMTimeRanges), MonadIO m, IsDOMHTMLMediaElement a) => O.MethodInfo DOMHTMLMediaElementGetSeekableMethodInfo a signature where
    overloadedMethod _ = dOMHTMLMediaElementGetSeekable

-- method DOMHTMLMediaElement::get_seeking
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMHTMLMediaElement", 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 "webkit_dom_html_media_element_get_seeking" webkit_dom_html_media_element_get_seeking :: 
    Ptr DOMHTMLMediaElement ->              -- self : TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"})
    IO CInt

{- |
/No description available in the introspection data./
-}
dOMHTMLMediaElementGetSeeking ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMHTMLMediaElement a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMHTMLMediaElement.DOMHTMLMediaElement' -}
    -> m Bool
    {- ^ __Returns:__ A 'Bool' -}
dOMHTMLMediaElementGetSeeking self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_html_media_element_get_seeking self'
    let result' = (/= 0) result
    touchManagedPtr self
    return result'

data DOMHTMLMediaElementGetSeekingMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsDOMHTMLMediaElement a) => O.MethodInfo DOMHTMLMediaElementGetSeekingMethodInfo a signature where
    overloadedMethod _ = dOMHTMLMediaElementGetSeeking

-- method DOMHTMLMediaElement::get_src
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMHTMLMediaElement", 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_html_media_element_get_src" webkit_dom_html_media_element_get_src :: 
    Ptr DOMHTMLMediaElement ->              -- self : TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"})
    IO CString

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

data DOMHTMLMediaElementGetSrcMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsDOMHTMLMediaElement a) => O.MethodInfo DOMHTMLMediaElementGetSrcMethodInfo a signature where
    overloadedMethod _ = dOMHTMLMediaElementGetSrc

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

foreign import ccall "webkit_dom_html_media_element_get_start_time" webkit_dom_html_media_element_get_start_time :: 
    Ptr DOMHTMLMediaElement ->              -- self : TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"})
    IO CDouble

{-# DEPRECATED dOMHTMLMediaElementGetStartTime ["(Since version 2.2)"] #-}
{- |
The HTMLMediaElement:start-time property has been removed from WebKit, this function does nothing.
-}
dOMHTMLMediaElementGetStartTime ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMHTMLMediaElement a) =>
    a
    {- ^ /@self@/: A @/HTMLMediaElement/@ -}
    -> m Double
    {- ^ __Returns:__ A @/gdouble/@ -}
dOMHTMLMediaElementGetStartTime self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_html_media_element_get_start_time self'
    let result' = realToFrac result
    touchManagedPtr self
    return result'

data DOMHTMLMediaElementGetStartTimeMethodInfo
instance (signature ~ (m Double), MonadIO m, IsDOMHTMLMediaElement a) => O.MethodInfo DOMHTMLMediaElementGetStartTimeMethodInfo a signature where
    overloadedMethod _ = dOMHTMLMediaElementGetStartTime

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

foreign import ccall "webkit_dom_html_media_element_get_text_tracks" webkit_dom_html_media_element_get_text_tracks :: 
    Ptr DOMHTMLMediaElement ->              -- self : TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"})
    IO (Ptr WebKit.DOMTextTrackList.DOMTextTrackList)

{- |
/No description available in the introspection data./
-}
dOMHTMLMediaElementGetTextTracks ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMHTMLMediaElement a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMHTMLMediaElement.DOMHTMLMediaElement' -}
    -> m WebKit.DOMTextTrackList.DOMTextTrackList
    {- ^ __Returns:__ A 'GI.WebKit.Objects.DOMTextTrackList.DOMTextTrackList' -}
dOMHTMLMediaElementGetTextTracks self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_html_media_element_get_text_tracks self'
    checkUnexpectedReturnNULL "dOMHTMLMediaElementGetTextTracks" result
    result' <- (newObject WebKit.DOMTextTrackList.DOMTextTrackList) result
    touchManagedPtr self
    return result'

data DOMHTMLMediaElementGetTextTracksMethodInfo
instance (signature ~ (m WebKit.DOMTextTrackList.DOMTextTrackList), MonadIO m, IsDOMHTMLMediaElement a) => O.MethodInfo DOMHTMLMediaElementGetTextTracksMethodInfo a signature where
    overloadedMethod _ = dOMHTMLMediaElementGetTextTracks

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

foreign import ccall "webkit_dom_html_media_element_get_video_tracks" webkit_dom_html_media_element_get_video_tracks :: 
    Ptr DOMHTMLMediaElement ->              -- self : TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"})
    IO (Ptr WebKit.DOMVideoTrackList.DOMVideoTrackList)

{- |
/No description available in the introspection data./
-}
dOMHTMLMediaElementGetVideoTracks ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMHTMLMediaElement a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMHTMLMediaElement.DOMHTMLMediaElement' -}
    -> m WebKit.DOMVideoTrackList.DOMVideoTrackList
    {- ^ __Returns:__ A 'GI.WebKit.Objects.DOMVideoTrackList.DOMVideoTrackList' -}
dOMHTMLMediaElementGetVideoTracks self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_html_media_element_get_video_tracks self'
    checkUnexpectedReturnNULL "dOMHTMLMediaElementGetVideoTracks" result
    result' <- (newObject WebKit.DOMVideoTrackList.DOMVideoTrackList) result
    touchManagedPtr self
    return result'

data DOMHTMLMediaElementGetVideoTracksMethodInfo
instance (signature ~ (m WebKit.DOMVideoTrackList.DOMVideoTrackList), MonadIO m, IsDOMHTMLMediaElement a) => O.MethodInfo DOMHTMLMediaElementGetVideoTracksMethodInfo a signature where
    overloadedMethod _ = dOMHTMLMediaElementGetVideoTracks

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

foreign import ccall "webkit_dom_html_media_element_get_volume" webkit_dom_html_media_element_get_volume :: 
    Ptr DOMHTMLMediaElement ->              -- self : TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"})
    IO CDouble

{- |
/No description available in the introspection data./
-}
dOMHTMLMediaElementGetVolume ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMHTMLMediaElement a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMHTMLMediaElement.DOMHTMLMediaElement' -}
    -> m Double
    {- ^ __Returns:__ A @/gdouble/@ -}
dOMHTMLMediaElementGetVolume self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_html_media_element_get_volume self'
    let result' = realToFrac result
    touchManagedPtr self
    return result'

data DOMHTMLMediaElementGetVolumeMethodInfo
instance (signature ~ (m Double), MonadIO m, IsDOMHTMLMediaElement a) => O.MethodInfo DOMHTMLMediaElementGetVolumeMethodInfo a signature where
    overloadedMethod _ = dOMHTMLMediaElementGetVolume

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

foreign import ccall "webkit_dom_html_media_element_get_webkit_audio_decoded_byte_count" webkit_dom_html_media_element_get_webkit_audio_decoded_byte_count :: 
    Ptr DOMHTMLMediaElement ->              -- self : TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"})
    IO CULong

{- |
/No description available in the introspection data./
-}
dOMHTMLMediaElementGetWebkitAudioDecodedByteCount ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMHTMLMediaElement a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMHTMLMediaElement.DOMHTMLMediaElement' -}
    -> m CULong
    {- ^ __Returns:__ A @/gulong/@ -}
dOMHTMLMediaElementGetWebkitAudioDecodedByteCount self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_html_media_element_get_webkit_audio_decoded_byte_count self'
    touchManagedPtr self
    return result

data DOMHTMLMediaElementGetWebkitAudioDecodedByteCountMethodInfo
instance (signature ~ (m CULong), MonadIO m, IsDOMHTMLMediaElement a) => O.MethodInfo DOMHTMLMediaElementGetWebkitAudioDecodedByteCountMethodInfo a signature where
    overloadedMethod _ = dOMHTMLMediaElementGetWebkitAudioDecodedByteCount

-- method DOMHTMLMediaElement::get_webkit_closed_captions_visible
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMHTMLMediaElement", 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 "webkit_dom_html_media_element_get_webkit_closed_captions_visible" webkit_dom_html_media_element_get_webkit_closed_captions_visible :: 
    Ptr DOMHTMLMediaElement ->              -- self : TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"})
    IO CInt

{- |
/No description available in the introspection data./
-}
dOMHTMLMediaElementGetWebkitClosedCaptionsVisible ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMHTMLMediaElement a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMHTMLMediaElement.DOMHTMLMediaElement' -}
    -> m Bool
    {- ^ __Returns:__ A 'Bool' -}
dOMHTMLMediaElementGetWebkitClosedCaptionsVisible self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_html_media_element_get_webkit_closed_captions_visible self'
    let result' = (/= 0) result
    touchManagedPtr self
    return result'

data DOMHTMLMediaElementGetWebkitClosedCaptionsVisibleMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsDOMHTMLMediaElement a) => O.MethodInfo DOMHTMLMediaElementGetWebkitClosedCaptionsVisibleMethodInfo a signature where
    overloadedMethod _ = dOMHTMLMediaElementGetWebkitClosedCaptionsVisible

-- method DOMHTMLMediaElement::get_webkit_current_playback_target_is_wireless
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMHTMLMediaElement", 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 "webkit_dom_html_media_element_get_webkit_current_playback_target_is_wireless" webkit_dom_html_media_element_get_webkit_current_playback_target_is_wireless :: 
    Ptr DOMHTMLMediaElement ->              -- self : TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"})
    IO CInt

{- |
/No description available in the introspection data./
-}
dOMHTMLMediaElementGetWebkitCurrentPlaybackTargetIsWireless ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMHTMLMediaElement a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMHTMLMediaElement.DOMHTMLMediaElement' -}
    -> m Bool
    {- ^ __Returns:__ A 'Bool' -}
dOMHTMLMediaElementGetWebkitCurrentPlaybackTargetIsWireless self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_html_media_element_get_webkit_current_playback_target_is_wireless self'
    let result' = (/= 0) result
    touchManagedPtr self
    return result'

data DOMHTMLMediaElementGetWebkitCurrentPlaybackTargetIsWirelessMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsDOMHTMLMediaElement a) => O.MethodInfo DOMHTMLMediaElementGetWebkitCurrentPlaybackTargetIsWirelessMethodInfo a signature where
    overloadedMethod _ = dOMHTMLMediaElementGetWebkitCurrentPlaybackTargetIsWireless

-- method DOMHTMLMediaElement::get_webkit_has_closed_captions
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMHTMLMediaElement", 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 "webkit_dom_html_media_element_get_webkit_has_closed_captions" webkit_dom_html_media_element_get_webkit_has_closed_captions :: 
    Ptr DOMHTMLMediaElement ->              -- self : TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"})
    IO CInt

{- |
/No description available in the introspection data./
-}
dOMHTMLMediaElementGetWebkitHasClosedCaptions ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMHTMLMediaElement a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMHTMLMediaElement.DOMHTMLMediaElement' -}
    -> m Bool
    {- ^ __Returns:__ A 'Bool' -}
dOMHTMLMediaElementGetWebkitHasClosedCaptions self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_html_media_element_get_webkit_has_closed_captions self'
    let result' = (/= 0) result
    touchManagedPtr self
    return result'

data DOMHTMLMediaElementGetWebkitHasClosedCaptionsMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsDOMHTMLMediaElement a) => O.MethodInfo DOMHTMLMediaElementGetWebkitHasClosedCaptionsMethodInfo a signature where
    overloadedMethod _ = dOMHTMLMediaElementGetWebkitHasClosedCaptions

-- method DOMHTMLMediaElement::get_webkit_preserves_pitch
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMHTMLMediaElement", 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 "webkit_dom_html_media_element_get_webkit_preserves_pitch" webkit_dom_html_media_element_get_webkit_preserves_pitch :: 
    Ptr DOMHTMLMediaElement ->              -- self : TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"})
    IO CInt

{- |
/No description available in the introspection data./
-}
dOMHTMLMediaElementGetWebkitPreservesPitch ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMHTMLMediaElement a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMHTMLMediaElement.DOMHTMLMediaElement' -}
    -> m Bool
    {- ^ __Returns:__ A 'Bool' -}
dOMHTMLMediaElementGetWebkitPreservesPitch self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_html_media_element_get_webkit_preserves_pitch self'
    let result' = (/= 0) result
    touchManagedPtr self
    return result'

data DOMHTMLMediaElementGetWebkitPreservesPitchMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsDOMHTMLMediaElement a) => O.MethodInfo DOMHTMLMediaElementGetWebkitPreservesPitchMethodInfo a signature where
    overloadedMethod _ = dOMHTMLMediaElementGetWebkitPreservesPitch

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

foreign import ccall "webkit_dom_html_media_element_get_webkit_video_decoded_byte_count" webkit_dom_html_media_element_get_webkit_video_decoded_byte_count :: 
    Ptr DOMHTMLMediaElement ->              -- self : TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"})
    IO CULong

{- |
/No description available in the introspection data./
-}
dOMHTMLMediaElementGetWebkitVideoDecodedByteCount ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMHTMLMediaElement a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMHTMLMediaElement.DOMHTMLMediaElement' -}
    -> m CULong
    {- ^ __Returns:__ A @/gulong/@ -}
dOMHTMLMediaElementGetWebkitVideoDecodedByteCount self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    result <- webkit_dom_html_media_element_get_webkit_video_decoded_byte_count self'
    touchManagedPtr self
    return result

data DOMHTMLMediaElementGetWebkitVideoDecodedByteCountMethodInfo
instance (signature ~ (m CULong), MonadIO m, IsDOMHTMLMediaElement a) => O.MethodInfo DOMHTMLMediaElementGetWebkitVideoDecodedByteCountMethodInfo a signature where
    overloadedMethod _ = dOMHTMLMediaElementGetWebkitVideoDecodedByteCount

-- method DOMHTMLMediaElement::load
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMHTMLMediaElement", 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_html_media_element_load" webkit_dom_html_media_element_load :: 
    Ptr DOMHTMLMediaElement ->              -- self : TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"})
    IO ()

{- |
/No description available in the introspection data./
-}
dOMHTMLMediaElementLoad ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMHTMLMediaElement a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMHTMLMediaElement.DOMHTMLMediaElement' -}
    -> m ()
dOMHTMLMediaElementLoad self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    webkit_dom_html_media_element_load self'
    touchManagedPtr self
    return ()

data DOMHTMLMediaElementLoadMethodInfo
instance (signature ~ (m ()), MonadIO m, IsDOMHTMLMediaElement a) => O.MethodInfo DOMHTMLMediaElementLoadMethodInfo a signature where
    overloadedMethod _ = dOMHTMLMediaElementLoad

-- method DOMHTMLMediaElement::pause
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMHTMLMediaElement", 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_html_media_element_pause" webkit_dom_html_media_element_pause :: 
    Ptr DOMHTMLMediaElement ->              -- self : TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"})
    IO ()

{- |
/No description available in the introspection data./
-}
dOMHTMLMediaElementPause ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMHTMLMediaElement a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMHTMLMediaElement.DOMHTMLMediaElement' -}
    -> m ()
dOMHTMLMediaElementPause self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    webkit_dom_html_media_element_pause self'
    touchManagedPtr self
    return ()

data DOMHTMLMediaElementPauseMethodInfo
instance (signature ~ (m ()), MonadIO m, IsDOMHTMLMediaElement a) => O.MethodInfo DOMHTMLMediaElementPauseMethodInfo a signature where
    overloadedMethod _ = dOMHTMLMediaElementPause

-- method DOMHTMLMediaElement::play
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMHTMLMediaElement", 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_html_media_element_play" webkit_dom_html_media_element_play :: 
    Ptr DOMHTMLMediaElement ->              -- self : TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"})
    IO ()

{- |
/No description available in the introspection data./
-}
dOMHTMLMediaElementPlay ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMHTMLMediaElement a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMHTMLMediaElement.DOMHTMLMediaElement' -}
    -> m ()
dOMHTMLMediaElementPlay self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    webkit_dom_html_media_element_play self'
    touchManagedPtr self
    return ()

data DOMHTMLMediaElementPlayMethodInfo
instance (signature ~ (m ()), MonadIO m, IsDOMHTMLMediaElement a) => O.MethodInfo DOMHTMLMediaElementPlayMethodInfo a signature where
    overloadedMethod _ = dOMHTMLMediaElementPlay

-- method DOMHTMLMediaElement::set_autoplay
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMHTMLMediaElement", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #gboolean", 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_html_media_element_set_autoplay" webkit_dom_html_media_element_set_autoplay :: 
    Ptr DOMHTMLMediaElement ->              -- self : TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"})
    CInt ->                                 -- value : TBasicType TBoolean
    IO ()

{- |
/No description available in the introspection data./
-}
dOMHTMLMediaElementSetAutoplay ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMHTMLMediaElement a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMHTMLMediaElement.DOMHTMLMediaElement' -}
    -> Bool
    {- ^ /@value@/: A 'Bool' -}
    -> m ()
dOMHTMLMediaElementSetAutoplay self value = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    let value' = (fromIntegral . fromEnum) value
    webkit_dom_html_media_element_set_autoplay self' value'
    touchManagedPtr self
    return ()

data DOMHTMLMediaElementSetAutoplayMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsDOMHTMLMediaElement a) => O.MethodInfo DOMHTMLMediaElementSetAutoplayMethodInfo a signature where
    overloadedMethod _ = dOMHTMLMediaElementSetAutoplay

-- method DOMHTMLMediaElement::set_controls
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMHTMLMediaElement", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #gboolean", 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_html_media_element_set_controls" webkit_dom_html_media_element_set_controls :: 
    Ptr DOMHTMLMediaElement ->              -- self : TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"})
    CInt ->                                 -- value : TBasicType TBoolean
    IO ()

{- |
/No description available in the introspection data./
-}
dOMHTMLMediaElementSetControls ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMHTMLMediaElement a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMHTMLMediaElement.DOMHTMLMediaElement' -}
    -> Bool
    {- ^ /@value@/: A 'Bool' -}
    -> m ()
dOMHTMLMediaElementSetControls self value = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    let value' = (fromIntegral . fromEnum) value
    webkit_dom_html_media_element_set_controls self' value'
    touchManagedPtr self
    return ()

data DOMHTMLMediaElementSetControlsMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsDOMHTMLMediaElement a) => O.MethodInfo DOMHTMLMediaElementSetControlsMethodInfo a signature where
    overloadedMethod _ = dOMHTMLMediaElementSetControls

-- method DOMHTMLMediaElement::set_current_time
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMHTMLMediaElement", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #gdouble", 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_html_media_element_set_current_time" webkit_dom_html_media_element_set_current_time :: 
    Ptr DOMHTMLMediaElement ->              -- self : TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"})
    CDouble ->                              -- value : TBasicType TDouble
    Ptr (Ptr GError) ->                     -- error
    IO ()

{- |
/No description available in the introspection data./
-}
dOMHTMLMediaElementSetCurrentTime ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMHTMLMediaElement a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMHTMLMediaElement.DOMHTMLMediaElement' -}
    -> Double
    {- ^ /@value@/: A @/gdouble/@ -}
    -> m ()
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
dOMHTMLMediaElementSetCurrentTime self value = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    let value' = realToFrac value
    onException (do
        propagateGError $ webkit_dom_html_media_element_set_current_time self' value'
        touchManagedPtr self
        return ()
     ) (do
        return ()
     )

data DOMHTMLMediaElementSetCurrentTimeMethodInfo
instance (signature ~ (Double -> m ()), MonadIO m, IsDOMHTMLMediaElement a) => O.MethodInfo DOMHTMLMediaElementSetCurrentTimeMethodInfo a signature where
    overloadedMethod _ = dOMHTMLMediaElementSetCurrentTime

-- method DOMHTMLMediaElement::set_default_muted
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMHTMLMediaElement", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #gboolean", 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_html_media_element_set_default_muted" webkit_dom_html_media_element_set_default_muted :: 
    Ptr DOMHTMLMediaElement ->              -- self : TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"})
    CInt ->                                 -- value : TBasicType TBoolean
    IO ()

{- |
/No description available in the introspection data./
-}
dOMHTMLMediaElementSetDefaultMuted ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMHTMLMediaElement a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMHTMLMediaElement.DOMHTMLMediaElement' -}
    -> Bool
    {- ^ /@value@/: A 'Bool' -}
    -> m ()
dOMHTMLMediaElementSetDefaultMuted self value = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    let value' = (fromIntegral . fromEnum) value
    webkit_dom_html_media_element_set_default_muted self' value'
    touchManagedPtr self
    return ()

data DOMHTMLMediaElementSetDefaultMutedMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsDOMHTMLMediaElement a) => O.MethodInfo DOMHTMLMediaElementSetDefaultMutedMethodInfo a signature where
    overloadedMethod _ = dOMHTMLMediaElementSetDefaultMuted

-- method DOMHTMLMediaElement::set_default_playback_rate
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMHTMLMediaElement", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #gdouble", 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_html_media_element_set_default_playback_rate" webkit_dom_html_media_element_set_default_playback_rate :: 
    Ptr DOMHTMLMediaElement ->              -- self : TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"})
    CDouble ->                              -- value : TBasicType TDouble
    IO ()

{- |
/No description available in the introspection data./
-}
dOMHTMLMediaElementSetDefaultPlaybackRate ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMHTMLMediaElement a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMHTMLMediaElement.DOMHTMLMediaElement' -}
    -> Double
    {- ^ /@value@/: A @/gdouble/@ -}
    -> m ()
dOMHTMLMediaElementSetDefaultPlaybackRate self value = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    let value' = realToFrac value
    webkit_dom_html_media_element_set_default_playback_rate self' value'
    touchManagedPtr self
    return ()

data DOMHTMLMediaElementSetDefaultPlaybackRateMethodInfo
instance (signature ~ (Double -> m ()), MonadIO m, IsDOMHTMLMediaElement a) => O.MethodInfo DOMHTMLMediaElementSetDefaultPlaybackRateMethodInfo a signature where
    overloadedMethod _ = dOMHTMLMediaElementSetDefaultPlaybackRate

-- method DOMHTMLMediaElement::set_loop
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMHTMLMediaElement", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #gboolean", 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_html_media_element_set_loop" webkit_dom_html_media_element_set_loop :: 
    Ptr DOMHTMLMediaElement ->              -- self : TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"})
    CInt ->                                 -- value : TBasicType TBoolean
    IO ()

{- |
/No description available in the introspection data./
-}
dOMHTMLMediaElementSetLoop ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMHTMLMediaElement a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMHTMLMediaElement.DOMHTMLMediaElement' -}
    -> Bool
    {- ^ /@value@/: A 'Bool' -}
    -> m ()
dOMHTMLMediaElementSetLoop self value = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    let value' = (fromIntegral . fromEnum) value
    webkit_dom_html_media_element_set_loop self' value'
    touchManagedPtr self
    return ()

data DOMHTMLMediaElementSetLoopMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsDOMHTMLMediaElement a) => O.MethodInfo DOMHTMLMediaElementSetLoopMethodInfo a signature where
    overloadedMethod _ = dOMHTMLMediaElementSetLoop

-- method DOMHTMLMediaElement::set_media_group
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMHTMLMediaElement", 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_html_media_element_set_media_group" webkit_dom_html_media_element_set_media_group :: 
    Ptr DOMHTMLMediaElement ->              -- self : TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"})
    CString ->                              -- value : TBasicType TUTF8
    IO ()

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

data DOMHTMLMediaElementSetMediaGroupMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsDOMHTMLMediaElement a) => O.MethodInfo DOMHTMLMediaElementSetMediaGroupMethodInfo a signature where
    overloadedMethod _ = dOMHTMLMediaElementSetMediaGroup

-- method DOMHTMLMediaElement::set_muted
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMHTMLMediaElement", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #gboolean", 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_html_media_element_set_muted" webkit_dom_html_media_element_set_muted :: 
    Ptr DOMHTMLMediaElement ->              -- self : TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"})
    CInt ->                                 -- value : TBasicType TBoolean
    IO ()

{- |
/No description available in the introspection data./
-}
dOMHTMLMediaElementSetMuted ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMHTMLMediaElement a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMHTMLMediaElement.DOMHTMLMediaElement' -}
    -> Bool
    {- ^ /@value@/: A 'Bool' -}
    -> m ()
dOMHTMLMediaElementSetMuted self value = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    let value' = (fromIntegral . fromEnum) value
    webkit_dom_html_media_element_set_muted self' value'
    touchManagedPtr self
    return ()

data DOMHTMLMediaElementSetMutedMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsDOMHTMLMediaElement a) => O.MethodInfo DOMHTMLMediaElementSetMutedMethodInfo a signature where
    overloadedMethod _ = dOMHTMLMediaElementSetMuted

-- method DOMHTMLMediaElement::set_playback_rate
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMHTMLMediaElement", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #gdouble", 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_html_media_element_set_playback_rate" webkit_dom_html_media_element_set_playback_rate :: 
    Ptr DOMHTMLMediaElement ->              -- self : TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"})
    CDouble ->                              -- value : TBasicType TDouble
    IO ()

{- |
/No description available in the introspection data./
-}
dOMHTMLMediaElementSetPlaybackRate ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMHTMLMediaElement a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMHTMLMediaElement.DOMHTMLMediaElement' -}
    -> Double
    {- ^ /@value@/: A @/gdouble/@ -}
    -> m ()
dOMHTMLMediaElementSetPlaybackRate self value = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    let value' = realToFrac value
    webkit_dom_html_media_element_set_playback_rate self' value'
    touchManagedPtr self
    return ()

data DOMHTMLMediaElementSetPlaybackRateMethodInfo
instance (signature ~ (Double -> m ()), MonadIO m, IsDOMHTMLMediaElement a) => O.MethodInfo DOMHTMLMediaElementSetPlaybackRateMethodInfo a signature where
    overloadedMethod _ = dOMHTMLMediaElementSetPlaybackRate

-- method DOMHTMLMediaElement::set_preload
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMHTMLMediaElement", 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_html_media_element_set_preload" webkit_dom_html_media_element_set_preload :: 
    Ptr DOMHTMLMediaElement ->              -- self : TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"})
    CString ->                              -- value : TBasicType TUTF8
    IO ()

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

data DOMHTMLMediaElementSetPreloadMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsDOMHTMLMediaElement a) => O.MethodInfo DOMHTMLMediaElementSetPreloadMethodInfo a signature where
    overloadedMethod _ = dOMHTMLMediaElementSetPreload

-- method DOMHTMLMediaElement::set_src
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMHTMLMediaElement", 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_html_media_element_set_src" webkit_dom_html_media_element_set_src :: 
    Ptr DOMHTMLMediaElement ->              -- self : TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"})
    CString ->                              -- value : TBasicType TUTF8
    IO ()

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

data DOMHTMLMediaElementSetSrcMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m, IsDOMHTMLMediaElement a) => O.MethodInfo DOMHTMLMediaElementSetSrcMethodInfo a signature where
    overloadedMethod _ = dOMHTMLMediaElementSetSrc

-- method DOMHTMLMediaElement::set_volume
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMHTMLMediaElement", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TDouble, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #gdouble", 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_html_media_element_set_volume" webkit_dom_html_media_element_set_volume :: 
    Ptr DOMHTMLMediaElement ->              -- self : TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"})
    CDouble ->                              -- value : TBasicType TDouble
    Ptr (Ptr GError) ->                     -- error
    IO ()

{- |
/No description available in the introspection data./
-}
dOMHTMLMediaElementSetVolume ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMHTMLMediaElement a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMHTMLMediaElement.DOMHTMLMediaElement' -}
    -> Double
    {- ^ /@value@/: A @/gdouble/@ -}
    -> m ()
    {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
dOMHTMLMediaElementSetVolume self value = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    let value' = realToFrac value
    onException (do
        propagateGError $ webkit_dom_html_media_element_set_volume self' value'
        touchManagedPtr self
        return ()
     ) (do
        return ()
     )

data DOMHTMLMediaElementSetVolumeMethodInfo
instance (signature ~ (Double -> m ()), MonadIO m, IsDOMHTMLMediaElement a) => O.MethodInfo DOMHTMLMediaElementSetVolumeMethodInfo a signature where
    overloadedMethod _ = dOMHTMLMediaElementSetVolume

-- method DOMHTMLMediaElement::set_webkit_closed_captions_visible
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMHTMLMediaElement", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #gboolean", 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_html_media_element_set_webkit_closed_captions_visible" webkit_dom_html_media_element_set_webkit_closed_captions_visible :: 
    Ptr DOMHTMLMediaElement ->              -- self : TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"})
    CInt ->                                 -- value : TBasicType TBoolean
    IO ()

{- |
/No description available in the introspection data./
-}
dOMHTMLMediaElementSetWebkitClosedCaptionsVisible ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMHTMLMediaElement a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMHTMLMediaElement.DOMHTMLMediaElement' -}
    -> Bool
    {- ^ /@value@/: A 'Bool' -}
    -> m ()
dOMHTMLMediaElementSetWebkitClosedCaptionsVisible self value = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    let value' = (fromIntegral . fromEnum) value
    webkit_dom_html_media_element_set_webkit_closed_captions_visible self' value'
    touchManagedPtr self
    return ()

data DOMHTMLMediaElementSetWebkitClosedCaptionsVisibleMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsDOMHTMLMediaElement a) => O.MethodInfo DOMHTMLMediaElementSetWebkitClosedCaptionsVisibleMethodInfo a signature where
    overloadedMethod _ = dOMHTMLMediaElementSetWebkitClosedCaptionsVisible

-- method DOMHTMLMediaElement::set_webkit_preserves_pitch
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMHTMLMediaElement", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "value", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #gboolean", 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_html_media_element_set_webkit_preserves_pitch" webkit_dom_html_media_element_set_webkit_preserves_pitch :: 
    Ptr DOMHTMLMediaElement ->              -- self : TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"})
    CInt ->                                 -- value : TBasicType TBoolean
    IO ()

{- |
/No description available in the introspection data./
-}
dOMHTMLMediaElementSetWebkitPreservesPitch ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMHTMLMediaElement a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMHTMLMediaElement.DOMHTMLMediaElement' -}
    -> Bool
    {- ^ /@value@/: A 'Bool' -}
    -> m ()
dOMHTMLMediaElementSetWebkitPreservesPitch self value = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    let value' = (fromIntegral . fromEnum) value
    webkit_dom_html_media_element_set_webkit_preserves_pitch self' value'
    touchManagedPtr self
    return ()

data DOMHTMLMediaElementSetWebkitPreservesPitchMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsDOMHTMLMediaElement a) => O.MethodInfo DOMHTMLMediaElementSetWebkitPreservesPitchMethodInfo a signature where
    overloadedMethod _ = dOMHTMLMediaElementSetWebkitPreservesPitch

-- method DOMHTMLMediaElement::webkit_show_playback_target_picker
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #WebKitDOMHTMLMediaElement", 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_html_media_element_webkit_show_playback_target_picker" webkit_dom_html_media_element_webkit_show_playback_target_picker :: 
    Ptr DOMHTMLMediaElement ->              -- self : TInterface (Name {namespace = "WebKit", name = "DOMHTMLMediaElement"})
    IO ()

{- |
/No description available in the introspection data./
-}
dOMHTMLMediaElementWebkitShowPlaybackTargetPicker ::
    (B.CallStack.HasCallStack, MonadIO m, IsDOMHTMLMediaElement a) =>
    a
    {- ^ /@self@/: A 'GI.WebKit.Objects.DOMHTMLMediaElement.DOMHTMLMediaElement' -}
    -> m ()
dOMHTMLMediaElementWebkitShowPlaybackTargetPicker self = liftIO $ do
    self' <- unsafeManagedPtrCastPtr self
    webkit_dom_html_media_element_webkit_show_playback_target_picker self'
    touchManagedPtr self
    return ()

data DOMHTMLMediaElementWebkitShowPlaybackTargetPickerMethodInfo
instance (signature ~ (m ()), MonadIO m, IsDOMHTMLMediaElement a) => O.MethodInfo DOMHTMLMediaElementWebkitShowPlaybackTargetPickerMethodInfo a signature where
    overloadedMethod _ = dOMHTMLMediaElementWebkitShowPlaybackTargetPicker