content: {-# LANGUAGE PatternSynonyms #-}
  {-# LANGUAGE ForeignFunctionInterface #-}
  {-# LANGUAGE JavaScriptFFI #-}
  -- For HasCallStack compatibility
  {-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
  module GHCJS.DOM.JSFFI.Generated.Window
         (js_decodeURI, decodeURI, decodeURI_, js_decodeURIComponent,
          decodeURIComponent, decodeURIComponent_, js_encodeURI, encodeURI,
          encodeURI_, js_encodeURIComponent, encodeURIComponent,
          encodeURIComponent_, js_fetch, fetch, fetch_, js_openDatabase,
          openDatabase, openDatabase_, openDatabaseUnsafe,
          openDatabaseUnchecked, js_close, close, js_stop, stop, js_focus,
          focus, js_blur, blur, js_open, open, open_, openUnsafe,
          openUnchecked, js_alertNoMessage, alertNoMessage, js_alert, alert,
          js_confirm, confirm, confirm_, js_prompt, prompt, prompt_,
          promptUnsafe, promptUnchecked, js_print, print,
          js_requestAnimationFrame, requestAnimationFrame,
          requestAnimationFrame_, js_cancelAnimationFrame,
          cancelAnimationFrame, js_postMessage, postMessage,
          js_captureEvents, captureEvents, js_releaseEvents, releaseEvents,
          js_getComputedStyle, getComputedStyle, getComputedStyle_,
          js_matchMedia, matchMedia, matchMedia_, js_moveTo, moveTo,
          js_moveBy, moveBy, js_resizeTo, resizeTo, js_resizeBy, resizeBy,
          js_scrollOpt, scrollOpt, js_scroll, scroll, js_scrollToOpt,
          scrollToOpt, js_scrollTo, scrollTo, js_scrollByOpt, scrollByOpt,
          js_scrollBy, scrollBy, js_getSelection, getSelection,
          getSelection_, getSelectionUnsafe, getSelectionUnchecked, js_find,
          find, find_, js_webkitRequestAnimationFrame,
          webkitRequestAnimationFrame, webkitRequestAnimationFrame_,
          js_webkitCancelAnimationFrame, webkitCancelAnimationFrame,
          js_webkitCancelRequestAnimationFrame,
          webkitCancelRequestAnimationFrame, js_getMatchedCSSRules,
          getMatchedCSSRules, getMatchedCSSRules_, js_showModalDialog,
          showModalDialog, showModalDialog_,
          js_webkitConvertPointFromPageToNode,
          webkitConvertPointFromPageToNode,
          webkitConvertPointFromPageToNode_,
          js_webkitConvertPointFromNodeToPage,
          webkitConvertPointFromNodeToPage,
          webkitConvertPointFromNodeToPage_,
          js_collectMatchingElementsInFlatTree,
          collectMatchingElementsInFlatTree,
          collectMatchingElementsInFlatTree_, js_matchingElementInFlatTree,
          matchingElementInFlatTree, matchingElementInFlatTree_,
          matchingElementInFlatTreeUnsafe,
          matchingElementInFlatTreeUnchecked, js_getIndexedDB, getIndexedDB,
          js_getWebkitIndexedDB, getWebkitIndexedDB, js_getWebkitStorageInfo,
          getWebkitStorageInfo, js_getSpeechSynthesis, getSpeechSynthesis,
          js_getWindow, getWindow, js_getSelf, getSelf, js_getDocument,
          getDocument, js_setName, setName, js_getName, getName,
          js_getLocation, getLocation, js_getHistory, getHistory,
          js_getCustomElements, getCustomElements, js_getLocationbar,
          getLocationbar, js_getMenubar, getMenubar, js_getPersonalbar,
          getPersonalbar, js_getScrollbars, getScrollbars, js_getStatusbar,
          getStatusbar, js_getToolbar, getToolbar, js_setStatus, setStatus,
          js_getStatus, getStatus, js_getClosed, getClosed, js_getFrames,
          getFrames, js_getLength, getLength, js_getTop, getTop,
          getTopUnsafe, getTopUnchecked, js_getOpener, getOpener,
          getOpenerUnsafe, getOpenerUnchecked, js_getParent, getParent,
          getParentUnsafe, getParentUnchecked, js_getFrameElement,
          getFrameElement, getFrameElementUnsafe, getFrameElementUnchecked,
          js_getNavigator, getNavigator, js_getApplicationCache,
          getApplicationCache, js_getSessionStorage, getSessionStorage,
          js_getLocalStorage, getLocalStorage, js_getScreen, getScreen,
          js_getInnerHeight, getInnerHeight, js_getInnerWidth, getInnerWidth,
          js_getScrollX, getScrollX, js_getPageXOffset, getPageXOffset,
          js_getScrollY, getScrollY, js_getPageYOffset, getPageYOffset,
          js_getScreenX, getScreenX, js_getScreenY, getScreenY,
          js_getOuterWidth, getOuterWidth, js_getOuterHeight, getOuterHeight,
          js_getDevicePixelRatio, getDevicePixelRatio, js_getOrientation,
          getOrientation, js_getEvent, getEvent, js_setDefaultStatus,
          setDefaultStatus, js_getDefaultStatus, getDefaultStatus,
          js_setDefaultstatus, setDefaultstatus, js_getDefaultstatus,
          getDefaultstatus, js_getOffscreenBuffering, getOffscreenBuffering,
          js_getScreenLeft, getScreenLeft, js_getScreenTop, getScreenTop,
          js_getClientInformation, getClientInformation, js_getStyleMedia,
          getStyleMedia, gestureChange, gestureEnd, gestureStart,
          deviceMotion, deviceOrientation, webKitDeviceProximity,
          webKitAnimationEnd, webKitAnimationIteration, webKitAnimationStart,
          webKitTransitionEnd, Window(..), gTypeWindow)
         where
  import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, fmap, Show, Read, Eq, Ord)
  import qualified Prelude (error)
  import Data.Typeable (Typeable)
  import GHCJS.Types (JSVal(..), JSString)
  import GHCJS.Foreign (jsNull, jsUndefined)
  import GHC.JS.Foreign.Callback (syncCallback, asyncCallback, syncCallback1, asyncCallback1, syncCallback2, asyncCallback2, OnBlocked(..))
  import GHCJS.Marshal (ToJSVal(..), FromJSVal(..))
  import GHCJS.Marshal.Pure (PToJSVal(..), PFromJSVal(..))
  import Control.Monad (void)
  import Control.Monad.IO.Class (MonadIO(..))
  import Data.Int (Int64)
  import Data.Word (Word, Word64)
  import Data.Maybe (fromJust)
  import Data.Traversable (mapM)
  import GHCJS.DOM.Types
  import Control.Applicative ((<$>))
  import GHCJS.DOM.EventTargetClosures (EventName, unsafeEventName, unsafeEventNameAsync)
  import GHCJS.DOM.JSFFI.Generated.Enums
   
  foreign import javascript unsafe "(($1, $2) => { return $1[\"decodeURI\"]($2); })"
          js_decodeURI :: Window -> JSString -> IO JSString
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.decodeURI Mozilla Window.decodeURI documentation> 
  decodeURI ::
            (MonadIO m, ToJSString uri, FromJSString result) =>
              Window -> uri -> m result
  decodeURI self uri
    = liftIO (fromJSString <$> (js_decodeURI self (toJSString uri)))
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.decodeURI Mozilla Window.decodeURI documentation> 
  decodeURI_ :: (MonadIO m, ToJSString uri) => Window -> uri -> m ()
  decodeURI_ self uri
    = liftIO (void (js_decodeURI self (toJSString uri)))
   
  foreign import javascript unsafe "(($1, $2) => { return $1[\"decodeURIComponent\"]($2); })"
          js_decodeURIComponent :: Window -> JSString -> IO JSString
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.decodeURIComponent Mozilla Window.decodeURIComponent documentation> 
  decodeURIComponent ::
                     (MonadIO m, ToJSString uri, FromJSString result) =>
                       Window -> uri -> m result
  decodeURIComponent self uri
    = liftIO
        (fromJSString <$> (js_decodeURIComponent self (toJSString uri)))
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.decodeURIComponent Mozilla Window.decodeURIComponent documentation> 
  decodeURIComponent_ ::
                      (MonadIO m, ToJSString uri) => Window -> uri -> m ()
  decodeURIComponent_ self uri
    = liftIO (void (js_decodeURIComponent self (toJSString uri)))
   
  foreign import javascript unsafe "(($1, $2) => { return $1[\"encodeURI\"]($2); })"
          js_encodeURI :: Window -> JSString -> IO JSString
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.encodeURI Mozilla Window.encodeURI documentation> 
  encodeURI ::
            (MonadIO m, ToJSString uri, FromJSString result) =>
              Window -> uri -> m result
  encodeURI self uri
    = liftIO (fromJSString <$> (js_encodeURI self (toJSString uri)))
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.encodeURI Mozilla Window.encodeURI documentation> 
  encodeURI_ :: (MonadIO m, ToJSString uri) => Window -> uri -> m ()
  encodeURI_ self uri
    = liftIO (void (js_encodeURI self (toJSString uri)))
   
  foreign import javascript unsafe "(($1, $2) => { return $1[\"encodeURIComponent\"]($2); })"
          js_encodeURIComponent :: Window -> JSString -> IO JSString
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.encodeURIComponent Mozilla Window.encodeURIComponent documentation> 
  encodeURIComponent ::
                     (MonadIO m, ToJSString uri, FromJSString result) =>
                       Window -> uri -> m result
  encodeURIComponent self uri
    = liftIO
        (fromJSString <$> (js_encodeURIComponent self (toJSString uri)))
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.encodeURIComponent Mozilla Window.encodeURIComponent documentation> 
  encodeURIComponent_ ::
                      (MonadIO m, ToJSString uri) => Window -> uri -> m ()
  encodeURIComponent_ self uri
    = liftIO (void (js_encodeURIComponent self (toJSString uri)))
   
  foreign import javascript interruptible
          "(($1, $2, $3, $c) => { return $1[\"fetch\"]($2, $3).then(function(s) { $c(null, s);}, function(e) { $c(e, null);}); })"
          js_fetch ::
          Window -> JSVal -> Optional RequestInit -> IO (JSVal, Response)
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.fetch Mozilla Window.fetch documentation> 
  fetch ::
        (MonadIO m, ToJSVal input) =>
          Window -> input -> Maybe RequestInit -> m Response
  fetch self input init
    = liftIO
        ((toJSVal input >>= \ input' -> js_fetch self input'
            (maybeToOptional init))
           >>= checkPromiseResult)
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.fetch Mozilla Window.fetch documentation> 
  fetch_ ::
         (MonadIO m, ToJSVal input) =>
           Window -> input -> Maybe RequestInit -> m ()
  fetch_ self input init
    = liftIO
        (void
           (toJSVal input >>= \ input' -> js_fetch self input'
              (maybeToOptional init)))
   
  foreign import javascript safe
          "(($1, $2, $3, $4, $5, $6) => { return $1[\"openDatabase\"]($2, $3, $4,\n$5, $6); })" js_openDatabase ::
          Window ->
            JSString ->
              JSString ->
                JSString ->
                  Word -> Optional DatabaseCallback -> IO (Nullable Database)
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.openDatabase Mozilla Window.openDatabase documentation> 
  openDatabase ::
               (MonadIO m, ToJSString name, ToJSString version,
                ToJSString displayName) =>
                 Window ->
                   name ->
                     version ->
                       displayName -> Word -> Maybe DatabaseCallback -> m (Maybe Database)
  openDatabase self name version displayName estimatedSize
    creationCallback
    = liftIO
        (nullableToMaybe <$>
           (js_openDatabase self (toJSString name) (toJSString version)
              (toJSString displayName)
              estimatedSize
              (maybeToOptional creationCallback)))
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.openDatabase Mozilla Window.openDatabase documentation> 
  openDatabase_ ::
                (MonadIO m, ToJSString name, ToJSString version,
                 ToJSString displayName) =>
                  Window ->
                    name ->
                      version -> displayName -> Word -> Maybe DatabaseCallback -> m ()
  openDatabase_ self name version displayName estimatedSize
    creationCallback
    = liftIO
        (void
           (js_openDatabase self (toJSString name) (toJSString version)
              (toJSString displayName)
              estimatedSize
              (maybeToOptional creationCallback)))
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.openDatabase Mozilla Window.openDatabase documentation> 
  openDatabaseUnsafe ::
                     (MonadIO m, ToJSString name, ToJSString version,
                      ToJSString displayName, HasCallStack) =>
                       Window ->
                         name ->
                           version ->
                             displayName -> Word -> Maybe DatabaseCallback -> m Database
  openDatabaseUnsafe self name version displayName estimatedSize
    creationCallback
    = liftIO
        ((nullableToMaybe <$>
            (js_openDatabase self (toJSString name) (toJSString version)
               (toJSString displayName)
               estimatedSize
               (maybeToOptional creationCallback)))
           >>= maybe (Prelude.error "Nothing to return") return)
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.openDatabase Mozilla Window.openDatabase documentation> 
  openDatabaseUnchecked ::
                        (MonadIO m, ToJSString name, ToJSString version,
                         ToJSString displayName) =>
                          Window ->
                            name ->
                              version ->
                                displayName -> Word -> Maybe DatabaseCallback -> m Database
  openDatabaseUnchecked self name version displayName estimatedSize
    creationCallback
    = liftIO
        (fromJust . nullableToMaybe <$>
           (js_openDatabase self (toJSString name) (toJSString version)
              (toJSString displayName)
              estimatedSize
              (maybeToOptional creationCallback)))
   
  foreign import javascript unsafe "(($1) => { return $1[\"close\"](); })" js_close ::
          Window -> IO ()
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.close Mozilla Window.close documentation> 
  close :: (MonadIO m) => Window -> m ()
  close self = liftIO (js_close self)
   
  foreign import javascript unsafe "(($1) => { return $1[\"stop\"](); })" js_stop ::
          Window -> IO ()
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.stop Mozilla Window.stop documentation> 
  stop :: (MonadIO m) => Window -> m ()
  stop self = liftIO (js_stop self)
   
  foreign import javascript unsafe "(($1) => { return $1[\"focus\"](); })" js_focus ::
          Window -> IO ()
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.focus Mozilla Window.focus documentation> 
  focus :: (MonadIO m) => Window -> m ()
  focus self = liftIO (js_focus self)
   
  foreign import javascript unsafe "(($1) => { return $1[\"blur\"](); })" js_blur ::
          Window -> IO ()
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.blur Mozilla Window.blur documentation> 
  blur :: (MonadIO m) => Window -> m ()
  blur self = liftIO (js_blur self)
   
  foreign import javascript unsafe "(($1, $2, $3, $4) => { return $1[\"open\"]($2, $3, $4); })" js_open
          ::
          Window ->
            Optional JSString ->
              Optional JSString -> Optional JSString -> IO (Nullable Window)
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.open Mozilla Window.open documentation> 
  open ::
       (MonadIO m, ToJSString url, ToJSString target,
        ToJSString features) =>
         Window ->
           Maybe url -> Maybe target -> Maybe features -> m (Maybe Window)
  open self url target features
    = liftIO
        (nullableToMaybe <$>
           (js_open self (toOptionalJSString url) (toOptionalJSString target)
              (toOptionalJSString features)))
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.open Mozilla Window.open documentation> 
  open_ ::
        (MonadIO m, ToJSString url, ToJSString target,
         ToJSString features) =>
          Window -> Maybe url -> Maybe target -> Maybe features -> m ()
  open_ self url target features
    = liftIO
        (void
           (js_open self (toOptionalJSString url) (toOptionalJSString target)
              (toOptionalJSString features)))
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.open Mozilla Window.open documentation> 
  openUnsafe ::
             (MonadIO m, ToJSString url, ToJSString target, ToJSString features,
              HasCallStack) =>
               Window -> Maybe url -> Maybe target -> Maybe features -> m Window
  openUnsafe self url target features
    = liftIO
        ((nullableToMaybe <$>
            (js_open self (toOptionalJSString url) (toOptionalJSString target)
               (toOptionalJSString features)))
           >>= maybe (Prelude.error "Nothing to return") return)
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.open Mozilla Window.open documentation> 
  openUnchecked ::
                (MonadIO m, ToJSString url, ToJSString target,
                 ToJSString features) =>
                  Window -> Maybe url -> Maybe target -> Maybe features -> m Window
  openUnchecked self url target features
    = liftIO
        (fromJust . nullableToMaybe <$>
           (js_open self (toOptionalJSString url) (toOptionalJSString target)
              (toOptionalJSString features)))
   
  foreign import javascript unsafe "(($1) => { return $1[\"alert\"](); })"
          js_alertNoMessage :: Window -> IO ()
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.alert Mozilla Window.alert documentation> 
  alertNoMessage :: (MonadIO m) => Window -> m ()
  alertNoMessage self = liftIO (js_alertNoMessage self)
   
  foreign import javascript unsafe "(($1, $2) => { return $1[\"alert\"]($2); })" js_alert ::
          Window -> JSString -> IO ()
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.alert Mozilla Window.alert documentation> 
  alert ::
        (MonadIO m, ToJSString message) => Window -> message -> m ()
  alert self message = liftIO (js_alert self (toJSString message))
   
  foreign import javascript unsafe "(($1, $2) => { return ($1[\"confirm\"]($2) ? 1 : 0); })"
          js_confirm :: Window -> Optional JSString -> IO Bool
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.confirm Mozilla Window.confirm documentation> 
  confirm ::
          (MonadIO m, ToJSString message) =>
            Window -> Maybe message -> m Bool
  confirm self message
    = liftIO (js_confirm self (toOptionalJSString message))
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.confirm Mozilla Window.confirm documentation> 
  confirm_ ::
           (MonadIO m, ToJSString message) => Window -> Maybe message -> m ()
  confirm_ self message
    = liftIO (void (js_confirm self (toOptionalJSString message)))
   
  foreign import javascript unsafe "(($1, $2, $3) => { return $1[\"prompt\"]($2, $3); })" js_prompt
          ::
          Window ->
            Optional JSString -> Optional JSString -> IO (Nullable JSString)
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.prompt Mozilla Window.prompt documentation> 
  prompt ::
         (MonadIO m, ToJSString message, ToJSString defaultValue,
          FromJSString result) =>
           Window -> Maybe message -> Maybe defaultValue -> m (Maybe result)
  prompt self message defaultValue
    = liftIO
        (fromMaybeJSString <$>
           (js_prompt self (toOptionalJSString message)
              (toOptionalJSString defaultValue)))
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.prompt Mozilla Window.prompt documentation> 
  prompt_ ::
          (MonadIO m, ToJSString message, ToJSString defaultValue) =>
            Window -> Maybe message -> Maybe defaultValue -> m ()
  prompt_ self message defaultValue
    = liftIO
        (void
           (js_prompt self (toOptionalJSString message)
              (toOptionalJSString defaultValue)))
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.prompt Mozilla Window.prompt documentation> 
  promptUnsafe ::
               (MonadIO m, ToJSString message, ToJSString defaultValue,
                HasCallStack, FromJSString result) =>
                 Window -> Maybe message -> Maybe defaultValue -> m result
  promptUnsafe self message defaultValue
    = liftIO
        ((fromMaybeJSString <$>
            (js_prompt self (toOptionalJSString message)
               (toOptionalJSString defaultValue)))
           >>= maybe (Prelude.error "Nothing to return") return)
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.prompt Mozilla Window.prompt documentation> 
  promptUnchecked ::
                  (MonadIO m, ToJSString message, ToJSString defaultValue,
                   FromJSString result) =>
                    Window -> Maybe message -> Maybe defaultValue -> m result
  promptUnchecked self message defaultValue
    = liftIO
        (fromJust . fromMaybeJSString <$>
           (js_prompt self (toOptionalJSString message)
              (toOptionalJSString defaultValue)))
   
  foreign import javascript unsafe "(($1) => { return $1[\"print\"](); })" js_print ::
          Window -> IO ()
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.print Mozilla Window.print documentation> 
  print :: (MonadIO m) => Window -> m ()
  print self = liftIO (js_print self)
   
  foreign import javascript unsafe
          "(($1, $2) => { return $1[\"requestAnimationFrame\"]($2); })" js_requestAnimationFrame ::
          Window -> RequestAnimationFrameCallback -> IO Int
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.requestAnimationFrame Mozilla Window.requestAnimationFrame documentation> 
  requestAnimationFrame ::
                        (MonadIO m) => Window -> RequestAnimationFrameCallback -> m Int
  requestAnimationFrame self callback
    = liftIO (js_requestAnimationFrame self callback)
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.requestAnimationFrame Mozilla Window.requestAnimationFrame documentation> 
  requestAnimationFrame_ ::
                         (MonadIO m) => Window -> RequestAnimationFrameCallback -> m ()
  requestAnimationFrame_ self callback
    = liftIO (void (js_requestAnimationFrame self callback))
   
  foreign import javascript unsafe "(($1, $2) => { return $1[\"cancelAnimationFrame\"]($2); })"
          js_cancelAnimationFrame :: Window -> Int -> IO ()
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.cancelAnimationFrame Mozilla Window.cancelAnimationFrame documentation> 
  cancelAnimationFrame :: (MonadIO m) => Window -> Int -> m ()
  cancelAnimationFrame self handle
    = liftIO (js_cancelAnimationFrame self handle)
   
  foreign import javascript safe "(($1, $2, $3, $4) => { return $1[\"postMessage\"]($2, $3, $4); })"
          js_postMessage :: Window -> JSVal -> JSString -> JSVal -> IO ()
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.postMessage Mozilla Window.postMessage documentation> 
  postMessage ::
              (MonadIO m, ToJSVal message, ToJSString targetOrigin,
               IsGObject transfer) =>
                Window -> message -> targetOrigin -> [transfer] -> m ()
  postMessage self message targetOrigin transfer
    = liftIO
        (toJSVal transfer >>=
           \ transfer' ->
             toJSVal message >>= \ message' -> js_postMessage self message'
               (toJSString targetOrigin)
               transfer')
   
  foreign import javascript unsafe "(($1) => { return $1[\"captureEvents\"](); })"
          js_captureEvents :: Window -> IO ()
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.captureEvents Mozilla Window.captureEvents documentation> 
  captureEvents :: (MonadIO m) => Window -> m ()
  captureEvents self = liftIO (js_captureEvents self)
   
  foreign import javascript unsafe "(($1) => { return $1[\"releaseEvents\"](); })"
          js_releaseEvents :: Window -> IO ()
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.releaseEvents Mozilla Window.releaseEvents documentation> 
  releaseEvents :: (MonadIO m) => Window -> m ()
  releaseEvents self = liftIO (js_releaseEvents self)
   
  foreign import javascript unsafe "(($1, $2, $3) => { return $1[\"getComputedStyle\"]($2, $3); })"
          js_getComputedStyle ::
          Window -> Element -> Optional JSString -> IO CSSStyleDeclaration
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.getComputedStyle Mozilla Window.getComputedStyle documentation> 
  getComputedStyle ::
                   (MonadIO m, IsElement element, ToJSString pseudoElement) =>
                     Window -> element -> Maybe pseudoElement -> m CSSStyleDeclaration
  getComputedStyle self element pseudoElement
    = liftIO
        (js_getComputedStyle self (toElement element)
           (toOptionalJSString pseudoElement))
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.getComputedStyle Mozilla Window.getComputedStyle documentation> 
  getComputedStyle_ ::
                    (MonadIO m, IsElement element, ToJSString pseudoElement) =>
                      Window -> element -> Maybe pseudoElement -> m ()
  getComputedStyle_ self element pseudoElement
    = liftIO
        (void
           (js_getComputedStyle self (toElement element)
              (toOptionalJSString pseudoElement)))
   
  foreign import javascript unsafe "(($1, $2) => { return $1[\"matchMedia\"]($2); })"
          js_matchMedia :: Window -> JSString -> IO MediaQueryList
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.matchMedia Mozilla Window.matchMedia documentation> 
  matchMedia ::
             (MonadIO m, ToJSString query) =>
               Window -> query -> m MediaQueryList
  matchMedia self query
    = liftIO (js_matchMedia self (toJSString query))
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.matchMedia Mozilla Window.matchMedia documentation> 
  matchMedia_ ::
              (MonadIO m, ToJSString query) => Window -> query -> m ()
  matchMedia_ self query
    = liftIO (void (js_matchMedia self (toJSString query)))
   
  foreign import javascript unsafe "(($1, $2, $3) => { return $1[\"moveTo\"]($2, $3); })" js_moveTo
          :: Window -> Optional Float -> Optional Float -> IO ()
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.moveTo Mozilla Window.moveTo documentation> 
  moveTo ::
         (MonadIO m) => Window -> Maybe Float -> Maybe Float -> m ()
  moveTo self x y
    = liftIO (js_moveTo self (maybeToOptional x) (maybeToOptional y))
   
  foreign import javascript unsafe "(($1, $2, $3) => { return $1[\"moveBy\"]($2, $3); })" js_moveBy
          :: Window -> Optional Float -> Optional Float -> IO ()
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.moveBy Mozilla Window.moveBy documentation> 
  moveBy ::
         (MonadIO m) => Window -> Maybe Float -> Maybe Float -> m ()
  moveBy self x y
    = liftIO (js_moveBy self (maybeToOptional x) (maybeToOptional y))
   
  foreign import javascript unsafe "(($1, $2, $3) => { return $1[\"resizeTo\"]($2, $3); })"
          js_resizeTo :: Window -> Optional Float -> Optional Float -> IO ()
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.resizeTo Mozilla Window.resizeTo documentation> 
  resizeTo ::
           (MonadIO m) => Window -> Maybe Float -> Maybe Float -> m ()
  resizeTo self width height
    = liftIO
        (js_resizeTo self (maybeToOptional width) (maybeToOptional height))
   
  foreign import javascript unsafe "(($1, $2, $3) => { return $1[\"resizeBy\"]($2, $3); })"
          js_resizeBy :: Window -> Optional Float -> Optional Float -> IO ()
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.resizeBy Mozilla Window.resizeBy documentation> 
  resizeBy ::
           (MonadIO m) => Window -> Maybe Float -> Maybe Float -> m ()
  resizeBy self x y
    = liftIO (js_resizeBy self (maybeToOptional x) (maybeToOptional y))
   
  foreign import javascript unsafe "(($1, $2) => { return $1[\"scroll\"]($2); })" js_scrollOpt
          :: Window -> Optional ScrollToOptions -> IO ()
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.scroll Mozilla Window.scroll documentation> 
  scrollOpt :: (MonadIO m) => Window -> Maybe ScrollToOptions -> m ()
  scrollOpt self options
    = liftIO (js_scrollOpt self (maybeToOptional options))
   
  foreign import javascript unsafe "(($1, $2, $3) => { return $1[\"scroll\"]($2, $3); })" js_scroll
          :: Window -> Double -> Double -> IO ()
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.scroll Mozilla Window.scroll documentation> 
  scroll :: (MonadIO m) => Window -> Double -> Double -> m ()
  scroll self x y = liftIO (js_scroll self x y)
   
  foreign import javascript unsafe "(($1, $2) => { return $1[\"scrollTo\"]($2); })"
          js_scrollToOpt :: Window -> Optional ScrollToOptions -> IO ()
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.scrollTo Mozilla Window.scrollTo documentation> 
  scrollToOpt ::
              (MonadIO m) => Window -> Maybe ScrollToOptions -> m ()
  scrollToOpt self options
    = liftIO (js_scrollToOpt self (maybeToOptional options))
   
  foreign import javascript unsafe "(($1, $2, $3) => { return $1[\"scrollTo\"]($2, $3); })"
          js_scrollTo :: Window -> Double -> Double -> IO ()
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.scrollTo Mozilla Window.scrollTo documentation> 
  scrollTo :: (MonadIO m) => Window -> Double -> Double -> m ()
  scrollTo self x y = liftIO (js_scrollTo self x y)
   
  foreign import javascript unsafe "(($1, $2) => { return $1[\"scrollBy\"]($2); })"
          js_scrollByOpt :: Window -> Optional ScrollToOptions -> IO ()
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.scrollBy Mozilla Window.scrollBy documentation> 
  scrollByOpt ::
              (MonadIO m) => Window -> Maybe ScrollToOptions -> m ()
  scrollByOpt self option
    = liftIO (js_scrollByOpt self (maybeToOptional option))
   
  foreign import javascript unsafe "(($1, $2, $3) => { return $1[\"scrollBy\"]($2, $3); })"
          js_scrollBy :: Window -> Double -> Double -> IO ()
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.scrollBy Mozilla Window.scrollBy documentation> 
  scrollBy :: (MonadIO m) => Window -> Double -> Double -> m ()
  scrollBy self x y = liftIO (js_scrollBy self x y)
   
  foreign import javascript unsafe "(($1) => { return $1[\"getSelection\"](); })"
          js_getSelection :: Window -> IO (Nullable Selection)
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.getSelection Mozilla Window.getSelection documentation> 
  getSelection :: (MonadIO m) => Window -> m (Maybe Selection)
  getSelection self
    = liftIO (nullableToMaybe <$> (js_getSelection self))
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.getSelection Mozilla Window.getSelection documentation> 
  getSelection_ :: (MonadIO m) => Window -> m ()
  getSelection_ self = liftIO (void (js_getSelection self))
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.getSelection Mozilla Window.getSelection documentation> 
  getSelectionUnsafe ::
                     (MonadIO m, HasCallStack) => Window -> m Selection
  getSelectionUnsafe self
    = liftIO
        ((nullableToMaybe <$> (js_getSelection self)) >>=
           maybe (Prelude.error "Nothing to return") return)
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.getSelection Mozilla Window.getSelection documentation> 
  getSelectionUnchecked :: (MonadIO m) => Window -> m Selection
  getSelectionUnchecked self
    = liftIO (fromJust . nullableToMaybe <$> (js_getSelection self))
   
  foreign import javascript unsafe
          "(($1, $2, $3, $4, $5, $6, $7, $8) => { return ($1[\"find\"]($2, $3, $4, $5, $6,\n$7, $8) ? 1 : 0); })" js_find ::
          Window ->
            Optional JSString ->
              Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> IO Bool
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.find Mozilla Window.find documentation> 
  find ::
       (MonadIO m, ToJSString string) =>
         Window ->
           Maybe string ->
             Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> m Bool
  find self string caseSensitive backwards wrap wholeWord
    searchInFrames showDialog
    = liftIO
        (js_find self (toOptionalJSString string) caseSensitive backwards
           wrap
           wholeWord
           searchInFrames
           showDialog)
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.find Mozilla Window.find documentation> 
  find_ ::
        (MonadIO m, ToJSString string) =>
          Window ->
            Maybe string ->
              Bool -> Bool -> Bool -> Bool -> Bool -> Bool -> m ()
  find_ self string caseSensitive backwards wrap wholeWord
    searchInFrames showDialog
    = liftIO
        (void
           (js_find self (toOptionalJSString string) caseSensitive backwards
              wrap
              wholeWord
              searchInFrames
              showDialog))
   
  foreign import javascript unsafe
          "(($1, $2) => { return $1[\"webkitRequestAnimationFrame\"]($2); })"
          js_webkitRequestAnimationFrame ::
          Window -> RequestAnimationFrameCallback -> IO Int
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.webkitRequestAnimationFrame Mozilla Window.webkitRequestAnimationFrame documentation> 
  webkitRequestAnimationFrame ::
                              (MonadIO m) => Window -> RequestAnimationFrameCallback -> m Int
  webkitRequestAnimationFrame self callback
    = liftIO (js_webkitRequestAnimationFrame self callback)
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.webkitRequestAnimationFrame Mozilla Window.webkitRequestAnimationFrame documentation> 
  webkitRequestAnimationFrame_ ::
                               (MonadIO m) => Window -> RequestAnimationFrameCallback -> m ()
  webkitRequestAnimationFrame_ self callback
    = liftIO (void (js_webkitRequestAnimationFrame self callback))
   
  foreign import javascript unsafe
          "(($1, $2) => { return $1[\"webkitCancelAnimationFrame\"]($2); })"
          js_webkitCancelAnimationFrame :: Window -> Int -> IO ()
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.webkitCancelAnimationFrame Mozilla Window.webkitCancelAnimationFrame documentation> 
  webkitCancelAnimationFrame :: (MonadIO m) => Window -> Int -> m ()
  webkitCancelAnimationFrame self id
    = liftIO (js_webkitCancelAnimationFrame self id)
   
  foreign import javascript unsafe
          "(($1, $2) => { return $1[\"webkitCancelRequestAnimationFrame\"]($2); })"
          js_webkitCancelRequestAnimationFrame :: Window -> Int -> IO ()
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.webkitCancelRequestAnimationFrame Mozilla Window.webkitCancelRequestAnimationFrame documentation> 
  webkitCancelRequestAnimationFrame ::
                                    (MonadIO m) => Window -> Int -> m ()
  webkitCancelRequestAnimationFrame self id
    = liftIO (js_webkitCancelRequestAnimationFrame self id)
   
  foreign import javascript unsafe
          "(($1, $2, $3) => { return $1[\"getMatchedCSSRules\"]($2, $3); })" js_getMatchedCSSRules ::
          Window -> Optional Element -> Optional JSString -> IO CSSRuleList
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.getMatchedCSSRules Mozilla Window.getMatchedCSSRules documentation> 
  getMatchedCSSRules ::
                     (MonadIO m, IsElement element, ToJSString pseudoElement) =>
                       Window -> Maybe element -> Maybe pseudoElement -> m CSSRuleList
  getMatchedCSSRules self element pseudoElement
    = liftIO
        (js_getMatchedCSSRules self
           (maybeToOptional (fmap toElement element))
           (toOptionalJSString pseudoElement))
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.getMatchedCSSRules Mozilla Window.getMatchedCSSRules documentation> 
  getMatchedCSSRules_ ::
                      (MonadIO m, IsElement element, ToJSString pseudoElement) =>
                        Window -> Maybe element -> Maybe pseudoElement -> m ()
  getMatchedCSSRules_ self element pseudoElement
    = liftIO
        (void
           (js_getMatchedCSSRules self
              (maybeToOptional (fmap toElement element))
              (toOptionalJSString pseudoElement)))
   
  foreign import javascript unsafe
          "(($1, $2, $3, $4) => { return $1[\"showModalDialog\"]($2, $3,\n$4); })" js_showModalDialog ::
          Window ->
            JSString -> Optional JSVal -> Optional JSString -> IO JSVal
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.showModalDialog Mozilla Window.showModalDialog documentation> 
  showModalDialog ::
                  (MonadIO m, ToJSString url, ToJSVal dialogArgs,
                   ToJSString featureArgs) =>
                    Window -> url -> Maybe dialogArgs -> Maybe featureArgs -> m JSVal
  showModalDialog self url dialogArgs featureArgs
    = liftIO
        (mapM toJSVal dialogArgs >>=
           \ dialogArgs' ->
             js_showModalDialog self (toJSString url)
               (maybeToOptional dialogArgs')
           (toOptionalJSString featureArgs))
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.showModalDialog Mozilla Window.showModalDialog documentation> 
  showModalDialog_ ::
                   (MonadIO m, ToJSString url, ToJSVal dialogArgs,
                    ToJSString featureArgs) =>
                     Window -> url -> Maybe dialogArgs -> Maybe featureArgs -> m ()
  showModalDialog_ self url dialogArgs featureArgs
    = liftIO
        (void
           (mapM toJSVal dialogArgs >>=
              \ dialogArgs' ->
                js_showModalDialog self (toJSString url)
                  (maybeToOptional dialogArgs')
              (toOptionalJSString featureArgs)))
   
  foreign import javascript unsafe
          "(($1, $2, $3) => { return $1[\"webkitConvertPointFromPageToNode\"]($2,\n$3); })"
          js_webkitConvertPointFromPageToNode ::
          Window -> Optional Node -> Optional WebKitPoint -> IO WebKitPoint
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.webkitConvertPointFromPageToNode Mozilla Window.webkitConvertPointFromPageToNode documentation> 
  webkitConvertPointFromPageToNode ::
                                   (MonadIO m, IsNode node) =>
                                     Window -> Maybe node -> Maybe WebKitPoint -> m WebKitPoint
  webkitConvertPointFromPageToNode self node p
    = liftIO
        (js_webkitConvertPointFromPageToNode self
           (maybeToOptional (fmap toNode node))
           (maybeToOptional p))
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.webkitConvertPointFromPageToNode Mozilla Window.webkitConvertPointFromPageToNode documentation> 
  webkitConvertPointFromPageToNode_ ::
                                    (MonadIO m, IsNode node) =>
                                      Window -> Maybe node -> Maybe WebKitPoint -> m ()
  webkitConvertPointFromPageToNode_ self node p
    = liftIO
        (void
           (js_webkitConvertPointFromPageToNode self
              (maybeToOptional (fmap toNode node))
              (maybeToOptional p)))
   
  foreign import javascript unsafe
          "(($1, $2, $3) => { return $1[\"webkitConvertPointFromNodeToPage\"]($2,\n$3); })"
          js_webkitConvertPointFromNodeToPage ::
          Window -> Optional Node -> Optional WebKitPoint -> IO WebKitPoint
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.webkitConvertPointFromNodeToPage Mozilla Window.webkitConvertPointFromNodeToPage documentation> 
  webkitConvertPointFromNodeToPage ::
                                   (MonadIO m, IsNode node) =>
                                     Window -> Maybe node -> Maybe WebKitPoint -> m WebKitPoint
  webkitConvertPointFromNodeToPage self node p
    = liftIO
        (js_webkitConvertPointFromNodeToPage self
           (maybeToOptional (fmap toNode node))
           (maybeToOptional p))
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.webkitConvertPointFromNodeToPage Mozilla Window.webkitConvertPointFromNodeToPage documentation> 
  webkitConvertPointFromNodeToPage_ ::
                                    (MonadIO m, IsNode node) =>
                                      Window -> Maybe node -> Maybe WebKitPoint -> m ()
  webkitConvertPointFromNodeToPage_ self node p
    = liftIO
        (void
           (js_webkitConvertPointFromNodeToPage self
              (maybeToOptional (fmap toNode node))
              (maybeToOptional p)))
   
  foreign import javascript safe
          "(($1, $2, $3) => { return $1[\"collectMatchingElementsInFlatTree\"]($2,\n$3); })"
          js_collectMatchingElementsInFlatTree ::
          Window -> Node -> JSString -> IO NodeList
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.collectMatchingElementsInFlatTree Mozilla Window.collectMatchingElementsInFlatTree documentation> 
  collectMatchingElementsInFlatTree ::
                                    (MonadIO m, IsNode scope, ToJSString selectors) =>
                                      Window -> scope -> selectors -> m NodeList
  collectMatchingElementsInFlatTree self scope selectors
    = liftIO
        (js_collectMatchingElementsInFlatTree self (toNode scope)
           (toJSString selectors))
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.collectMatchingElementsInFlatTree Mozilla Window.collectMatchingElementsInFlatTree documentation> 
  collectMatchingElementsInFlatTree_ ::
                                     (MonadIO m, IsNode scope, ToJSString selectors) =>
                                       Window -> scope -> selectors -> m ()
  collectMatchingElementsInFlatTree_ self scope selectors
    = liftIO
        (void
           (js_collectMatchingElementsInFlatTree self (toNode scope)
              (toJSString selectors)))
   
  foreign import javascript safe
          "(($1, $2, $3) => { return $1[\"matchingElementInFlatTree\"]($2,\n$3); })"
          js_matchingElementInFlatTree ::
          Window -> Node -> JSString -> IO (Nullable Element)
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.matchingElementInFlatTree Mozilla Window.matchingElementInFlatTree documentation> 
  matchingElementInFlatTree ::
                            (MonadIO m, IsNode scope, ToJSString selectors) =>
                              Window -> scope -> selectors -> m (Maybe Element)
  matchingElementInFlatTree self scope selectors
    = liftIO
        (nullableToMaybe <$>
           (js_matchingElementInFlatTree self (toNode scope)
              (toJSString selectors)))
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.matchingElementInFlatTree Mozilla Window.matchingElementInFlatTree documentation> 
  matchingElementInFlatTree_ ::
                             (MonadIO m, IsNode scope, ToJSString selectors) =>
                               Window -> scope -> selectors -> m ()
  matchingElementInFlatTree_ self scope selectors
    = liftIO
        (void
           (js_matchingElementInFlatTree self (toNode scope)
              (toJSString selectors)))
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.matchingElementInFlatTree Mozilla Window.matchingElementInFlatTree documentation> 
  matchingElementInFlatTreeUnsafe ::
                                  (MonadIO m, IsNode scope, ToJSString selectors, HasCallStack) =>
                                    Window -> scope -> selectors -> m Element
  matchingElementInFlatTreeUnsafe self scope selectors
    = liftIO
        ((nullableToMaybe <$>
            (js_matchingElementInFlatTree self (toNode scope)
               (toJSString selectors)))
           >>= maybe (Prelude.error "Nothing to return") return)
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.matchingElementInFlatTree Mozilla Window.matchingElementInFlatTree documentation> 
  matchingElementInFlatTreeUnchecked ::
                                     (MonadIO m, IsNode scope, ToJSString selectors) =>
                                       Window -> scope -> selectors -> m Element
  matchingElementInFlatTreeUnchecked self scope selectors
    = liftIO
        (fromJust . nullableToMaybe <$>
           (js_matchingElementInFlatTree self (toNode scope)
              (toJSString selectors)))
   
  foreign import javascript unsafe "(($1) => { return $1[\"indexedDB\"]; })"
          js_getIndexedDB :: Window -> IO IDBFactory
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.indexedDB Mozilla Window.indexedDB documentation> 
  getIndexedDB :: (MonadIO m) => Window -> m IDBFactory
  getIndexedDB self = liftIO (js_getIndexedDB self)
   
  foreign import javascript unsafe "(($1) => { return $1[\"webkitIndexedDB\"]; })"
          js_getWebkitIndexedDB :: Window -> IO IDBFactory
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.webkitIndexedDB Mozilla Window.webkitIndexedDB documentation> 
  getWebkitIndexedDB :: (MonadIO m) => Window -> m IDBFactory
  getWebkitIndexedDB self = liftIO (js_getWebkitIndexedDB self)
   
  foreign import javascript unsafe "(($1) => { return $1[\"webkitStorageInfo\"]; })"
          js_getWebkitStorageInfo :: Window -> IO StorageInfo
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.webkitStorageInfo Mozilla Window.webkitStorageInfo documentation> 
  getWebkitStorageInfo :: (MonadIO m) => Window -> m StorageInfo
  getWebkitStorageInfo self = liftIO (js_getWebkitStorageInfo self)
   
  foreign import javascript unsafe "(($1) => { return $1[\"speechSynthesis\"]; })"
          js_getSpeechSynthesis :: Window -> IO SpeechSynthesis
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.speechSynthesis Mozilla Window.speechSynthesis documentation> 
  getSpeechSynthesis :: (MonadIO m) => Window -> m SpeechSynthesis
  getSpeechSynthesis self = liftIO (js_getSpeechSynthesis self)
   
  foreign import javascript unsafe "(($1) => { return $1[\"window\"]; })" js_getWindow ::
          Window -> IO Window
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.window Mozilla Window.window documentation> 
  getWindow :: (MonadIO m) => Window -> m Window
  getWindow self = liftIO (js_getWindow self)
   
  foreign import javascript unsafe "(($1) => { return $1[\"self\"]; })" js_getSelf ::
          Window -> IO Window
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.self Mozilla Window.self documentation> 
  getSelf :: (MonadIO m) => Window -> m Window
  getSelf self = liftIO (js_getSelf self)
   
  foreign import javascript unsafe "(($1) => { return $1[\"document\"]; })" js_getDocument
          :: Window -> IO Document
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.document Mozilla Window.document documentation> 
  getDocument :: (MonadIO m) => Window -> m Document
  getDocument self = liftIO (js_getDocument self)
   
  foreign import javascript unsafe "(($1, $2) => { $1[\"name\"] = $2; })" js_setName ::
          Window -> JSString -> IO ()
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.name Mozilla Window.name documentation> 
  setName :: (MonadIO m, ToJSString val) => Window -> val -> m ()
  setName self val = liftIO (js_setName self (toJSString val))
   
  foreign import javascript unsafe "(($1) => { return $1[\"name\"]; })" js_getName ::
          Window -> IO JSString
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.name Mozilla Window.name documentation> 
  getName :: (MonadIO m, FromJSString result) => Window -> m result
  getName self = liftIO (fromJSString <$> (js_getName self))
   
  foreign import javascript unsafe "(($1) => { return $1[\"location\"]; })" js_getLocation
          :: Window -> IO Location
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.location Mozilla Window.location documentation> 
  getLocation :: (MonadIO m) => Window -> m Location
  getLocation self = liftIO (js_getLocation self)
   
  foreign import javascript unsafe "(($1) => { return $1[\"history\"]; })" js_getHistory ::
          Window -> IO History
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.history Mozilla Window.history documentation> 
  getHistory :: (MonadIO m) => Window -> m History
  getHistory self = liftIO (js_getHistory self)
   
  foreign import javascript unsafe "(($1) => { return $1[\"customElements\"]; })"
          js_getCustomElements :: Window -> IO CustomElementRegistry
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.customElements Mozilla Window.customElements documentation> 
  getCustomElements ::
                    (MonadIO m) => Window -> m CustomElementRegistry
  getCustomElements self = liftIO (js_getCustomElements self)
   
  foreign import javascript unsafe "(($1) => { return $1[\"locationbar\"]; })"
          js_getLocationbar :: Window -> IO BarProp
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.locationbar Mozilla Window.locationbar documentation> 
  getLocationbar :: (MonadIO m) => Window -> m BarProp
  getLocationbar self = liftIO (js_getLocationbar self)
   
  foreign import javascript unsafe "(($1) => { return $1[\"menubar\"]; })" js_getMenubar ::
          Window -> IO BarProp
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.menubar Mozilla Window.menubar documentation> 
  getMenubar :: (MonadIO m) => Window -> m BarProp
  getMenubar self = liftIO (js_getMenubar self)
   
  foreign import javascript unsafe "(($1) => { return $1[\"personalbar\"]; })"
          js_getPersonalbar :: Window -> IO BarProp
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.personalbar Mozilla Window.personalbar documentation> 
  getPersonalbar :: (MonadIO m) => Window -> m BarProp
  getPersonalbar self = liftIO (js_getPersonalbar self)
   
  foreign import javascript unsafe "(($1) => { return $1[\"scrollbars\"]; })"
          js_getScrollbars :: Window -> IO BarProp
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.scrollbars Mozilla Window.scrollbars documentation> 
  getScrollbars :: (MonadIO m) => Window -> m BarProp
  getScrollbars self = liftIO (js_getScrollbars self)
   
  foreign import javascript unsafe "(($1) => { return $1[\"statusbar\"]; })"
          js_getStatusbar :: Window -> IO BarProp
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.statusbar Mozilla Window.statusbar documentation> 
  getStatusbar :: (MonadIO m) => Window -> m BarProp
  getStatusbar self = liftIO (js_getStatusbar self)
   
  foreign import javascript unsafe "(($1) => { return $1[\"toolbar\"]; })" js_getToolbar ::
          Window -> IO BarProp
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.toolbar Mozilla Window.toolbar documentation> 
  getToolbar :: (MonadIO m) => Window -> m BarProp
  getToolbar self = liftIO (js_getToolbar self)
   
  foreign import javascript unsafe "(($1, $2) => { $1[\"status\"] = $2; })"
          js_setStatus :: Window -> JSString -> IO ()
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.status Mozilla Window.status documentation> 
  setStatus :: (MonadIO m, ToJSString val) => Window -> val -> m ()
  setStatus self val = liftIO (js_setStatus self (toJSString val))
   
  foreign import javascript unsafe "(($1) => { return $1[\"status\"]; })" js_getStatus ::
          Window -> IO JSString
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.status Mozilla Window.status documentation> 
  getStatus :: (MonadIO m, FromJSString result) => Window -> m result
  getStatus self = liftIO (fromJSString <$> (js_getStatus self))
   
  foreign import javascript unsafe "(($1) => { return ($1[\"closed\"] ? 1 : 0); })"
          js_getClosed :: Window -> IO Bool
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.closed Mozilla Window.closed documentation> 
  getClosed :: (MonadIO m) => Window -> m Bool
  getClosed self = liftIO (js_getClosed self)
   
  foreign import javascript unsafe "(($1) => { return $1[\"frames\"]; })" js_getFrames ::
          Window -> IO Window
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.frames Mozilla Window.frames documentation> 
  getFrames :: (MonadIO m) => Window -> m Window
  getFrames self = liftIO (js_getFrames self)
   
  foreign import javascript unsafe "(($1) => { return $1[\"length\"]; })" js_getLength ::
          Window -> IO Word
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.length Mozilla Window.length documentation> 
  getLength :: (MonadIO m) => Window -> m Word
  getLength self = liftIO (js_getLength self)
   
  foreign import javascript unsafe "(($1) => { return $1[\"top\"]; })" js_getTop ::
          Window -> IO (Nullable Window)
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.top Mozilla Window.top documentation> 
  getTop :: (MonadIO m) => Window -> m (Maybe Window)
  getTop self = liftIO (nullableToMaybe <$> (js_getTop self))
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.top Mozilla Window.top documentation> 
  getTopUnsafe :: (MonadIO m, HasCallStack) => Window -> m Window
  getTopUnsafe self
    = liftIO
        ((nullableToMaybe <$> (js_getTop self)) >>=
           maybe (Prelude.error "Nothing to return") return)
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.top Mozilla Window.top documentation> 
  getTopUnchecked :: (MonadIO m) => Window -> m Window
  getTopUnchecked self
    = liftIO (fromJust . nullableToMaybe <$> (js_getTop self))
   
  foreign import javascript unsafe "(($1) => { return $1[\"opener\"]; })" js_getOpener ::
          Window -> IO (Nullable Window)
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.opener Mozilla Window.opener documentation> 
  getOpener :: (MonadIO m) => Window -> m (Maybe Window)
  getOpener self = liftIO (nullableToMaybe <$> (js_getOpener self))
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.opener Mozilla Window.opener documentation> 
  getOpenerUnsafe :: (MonadIO m, HasCallStack) => Window -> m Window
  getOpenerUnsafe self
    = liftIO
        ((nullableToMaybe <$> (js_getOpener self)) >>=
           maybe (Prelude.error "Nothing to return") return)
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.opener Mozilla Window.opener documentation> 
  getOpenerUnchecked :: (MonadIO m) => Window -> m Window
  getOpenerUnchecked self
    = liftIO (fromJust . nullableToMaybe <$> (js_getOpener self))
   
  foreign import javascript unsafe "(($1) => { return $1[\"parent\"]; })" js_getParent ::
          Window -> IO (Nullable Window)
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.parent Mozilla Window.parent documentation> 
  getParent :: (MonadIO m) => Window -> m (Maybe Window)
  getParent self = liftIO (nullableToMaybe <$> (js_getParent self))
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.parent Mozilla Window.parent documentation> 
  getParentUnsafe :: (MonadIO m, HasCallStack) => Window -> m Window
  getParentUnsafe self
    = liftIO
        ((nullableToMaybe <$> (js_getParent self)) >>=
           maybe (Prelude.error "Nothing to return") return)
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.parent Mozilla Window.parent documentation> 
  getParentUnchecked :: (MonadIO m) => Window -> m Window
  getParentUnchecked self
    = liftIO (fromJust . nullableToMaybe <$> (js_getParent self))
   
  foreign import javascript unsafe "(($1) => { return $1[\"frameElement\"]; })"
          js_getFrameElement :: Window -> IO (Nullable Element)
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.frameElement Mozilla Window.frameElement documentation> 
  getFrameElement :: (MonadIO m) => Window -> m (Maybe Element)
  getFrameElement self
    = liftIO (nullableToMaybe <$> (js_getFrameElement self))
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.frameElement Mozilla Window.frameElement documentation> 
  getFrameElementUnsafe ::
                        (MonadIO m, HasCallStack) => Window -> m Element
  getFrameElementUnsafe self
    = liftIO
        ((nullableToMaybe <$> (js_getFrameElement self)) >>=
           maybe (Prelude.error "Nothing to return") return)
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.frameElement Mozilla Window.frameElement documentation> 
  getFrameElementUnchecked :: (MonadIO m) => Window -> m Element
  getFrameElementUnchecked self
    = liftIO (fromJust . nullableToMaybe <$> (js_getFrameElement self))
   
  foreign import javascript unsafe "(($1) => { return $1[\"navigator\"]; })"
          js_getNavigator :: Window -> IO Navigator
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.navigator Mozilla Window.navigator documentation> 
  getNavigator :: (MonadIO m) => Window -> m Navigator
  getNavigator self = liftIO (js_getNavigator self)
   
  foreign import javascript unsafe "(($1) => { return $1[\"applicationCache\"]; })"
          js_getApplicationCache :: Window -> IO ApplicationCache
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.applicationCache Mozilla Window.applicationCache documentation> 
  getApplicationCache :: (MonadIO m) => Window -> m ApplicationCache
  getApplicationCache self = liftIO (js_getApplicationCache self)
   
  foreign import javascript safe "(($1) => { return $1[\"sessionStorage\"]; })"
          js_getSessionStorage :: Window -> IO Storage
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.sessionStorage Mozilla Window.sessionStorage documentation> 
  getSessionStorage :: (MonadIO m) => Window -> m Storage
  getSessionStorage self = liftIO (js_getSessionStorage self)
   
  foreign import javascript safe "(($1) => { return $1[\"localStorage\"]; })"
          js_getLocalStorage :: Window -> IO Storage
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.localStorage Mozilla Window.localStorage documentation> 
  getLocalStorage :: (MonadIO m) => Window -> m Storage
  getLocalStorage self = liftIO (js_getLocalStorage self)
   
  foreign import javascript unsafe "(($1) => { return $1[\"screen\"]; })" js_getScreen ::
          Window -> IO Screen
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.screen Mozilla Window.screen documentation> 
  getScreen :: (MonadIO m) => Window -> m Screen
  getScreen self = liftIO (js_getScreen self)
   
  foreign import javascript unsafe "(($1) => { return $1[\"innerHeight\"]; })"
          js_getInnerHeight :: Window -> IO Int
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.innerHeight Mozilla Window.innerHeight documentation> 
  getInnerHeight :: (MonadIO m) => Window -> m Int
  getInnerHeight self = liftIO (js_getInnerHeight self)
   
  foreign import javascript unsafe "(($1) => { return $1[\"innerWidth\"]; })"
          js_getInnerWidth :: Window -> IO Int
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.innerWidth Mozilla Window.innerWidth documentation> 
  getInnerWidth :: (MonadIO m) => Window -> m Int
  getInnerWidth self = liftIO (js_getInnerWidth self)
   
  foreign import javascript unsafe "(($1) => { return $1[\"scrollX\"]; })" js_getScrollX ::
          Window -> IO Double
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.scrollX Mozilla Window.scrollX documentation> 
  getScrollX :: (MonadIO m) => Window -> m Double
  getScrollX self = liftIO (js_getScrollX self)
   
  foreign import javascript unsafe "(($1) => { return $1[\"pageXOffset\"]; })"
          js_getPageXOffset :: Window -> IO Double
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.pageXOffset Mozilla Window.pageXOffset documentation> 
  getPageXOffset :: (MonadIO m) => Window -> m Double
  getPageXOffset self = liftIO (js_getPageXOffset self)
   
  foreign import javascript unsafe "(($1) => { return $1[\"scrollY\"]; })" js_getScrollY ::
          Window -> IO Double
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.scrollY Mozilla Window.scrollY documentation> 
  getScrollY :: (MonadIO m) => Window -> m Double
  getScrollY self = liftIO (js_getScrollY self)
   
  foreign import javascript unsafe "(($1) => { return $1[\"pageYOffset\"]; })"
          js_getPageYOffset :: Window -> IO Double
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.pageYOffset Mozilla Window.pageYOffset documentation> 
  getPageYOffset :: (MonadIO m) => Window -> m Double
  getPageYOffset self = liftIO (js_getPageYOffset self)
   
  foreign import javascript unsafe "(($1) => { return $1[\"screenX\"]; })" js_getScreenX ::
          Window -> IO Int
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.screenX Mozilla Window.screenX documentation> 
  getScreenX :: (MonadIO m) => Window -> m Int
  getScreenX self = liftIO (js_getScreenX self)
   
  foreign import javascript unsafe "(($1) => { return $1[\"screenY\"]; })" js_getScreenY ::
          Window -> IO Int
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.screenY Mozilla Window.screenY documentation> 
  getScreenY :: (MonadIO m) => Window -> m Int
  getScreenY self = liftIO (js_getScreenY self)
   
  foreign import javascript unsafe "(($1) => { return $1[\"outerWidth\"]; })"
          js_getOuterWidth :: Window -> IO Int
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.outerWidth Mozilla Window.outerWidth documentation> 
  getOuterWidth :: (MonadIO m) => Window -> m Int
  getOuterWidth self = liftIO (js_getOuterWidth self)
   
  foreign import javascript unsafe "(($1) => { return $1[\"outerHeight\"]; })"
          js_getOuterHeight :: Window -> IO Int
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.outerHeight Mozilla Window.outerHeight documentation> 
  getOuterHeight :: (MonadIO m) => Window -> m Int
  getOuterHeight self = liftIO (js_getOuterHeight self)
   
  foreign import javascript unsafe "(($1) => { return $1[\"devicePixelRatio\"]; })"
          js_getDevicePixelRatio :: Window -> IO Double
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.devicePixelRatio Mozilla Window.devicePixelRatio documentation> 
  getDevicePixelRatio :: (MonadIO m) => Window -> m Double
  getDevicePixelRatio self = liftIO (js_getDevicePixelRatio self)
   
  foreign import javascript unsafe "(($1) => { return $1[\"orientation\"]; })"
          js_getOrientation :: Window -> IO Int
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.orientation Mozilla Window.orientation documentation> 
  getOrientation :: (MonadIO m) => Window -> m Int
  getOrientation self = liftIO (js_getOrientation self)
   
  foreign import javascript unsafe "(($1) => { return $1[\"event\"]; })" js_getEvent ::
          Window -> IO Event
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.event Mozilla Window.event documentation> 
  getEvent :: (MonadIO m) => Window -> m Event
  getEvent self = liftIO (js_getEvent self)
   
  foreign import javascript unsafe "(($1, $2) => { $1[\"defaultStatus\"] = $2; })"
          js_setDefaultStatus :: Window -> JSString -> IO ()
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.defaultStatus Mozilla Window.defaultStatus documentation> 
  setDefaultStatus ::
                   (MonadIO m, ToJSString val) => Window -> val -> m ()
  setDefaultStatus self val
    = liftIO (js_setDefaultStatus self (toJSString val))
   
  foreign import javascript unsafe "(($1) => { return $1[\"defaultStatus\"]; })"
          js_getDefaultStatus :: Window -> IO JSString
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.defaultStatus Mozilla Window.defaultStatus documentation> 
  getDefaultStatus ::
                   (MonadIO m, FromJSString result) => Window -> m result
  getDefaultStatus self
    = liftIO (fromJSString <$> (js_getDefaultStatus self))
   
  foreign import javascript unsafe "(($1, $2) => { $1[\"defaultstatus\"] = $2; })"
          js_setDefaultstatus :: Window -> JSString -> IO ()
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.defaultstatus Mozilla Window.defaultstatus documentation> 
  setDefaultstatus ::
                   (MonadIO m, ToJSString val) => Window -> val -> m ()
  setDefaultstatus self val
    = liftIO (js_setDefaultstatus self (toJSString val))
   
  foreign import javascript unsafe "(($1) => { return $1[\"defaultstatus\"]; })"
          js_getDefaultstatus :: Window -> IO JSString
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.defaultstatus Mozilla Window.defaultstatus documentation> 
  getDefaultstatus ::
                   (MonadIO m, FromJSString result) => Window -> m result
  getDefaultstatus self
    = liftIO (fromJSString <$> (js_getDefaultstatus self))
   
  foreign import javascript unsafe
          "(($1) => { return ($1[\"offscreenBuffering\"] ? 1 : 0); })" js_getOffscreenBuffering ::
          Window -> IO Bool
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.offscreenBuffering Mozilla Window.offscreenBuffering documentation> 
  getOffscreenBuffering :: (MonadIO m) => Window -> m Bool
  getOffscreenBuffering self = liftIO (js_getOffscreenBuffering self)
   
  foreign import javascript unsafe "(($1) => { return $1[\"screenLeft\"]; })"
          js_getScreenLeft :: Window -> IO Int
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.screenLeft Mozilla Window.screenLeft documentation> 
  getScreenLeft :: (MonadIO m) => Window -> m Int
  getScreenLeft self = liftIO (js_getScreenLeft self)
   
  foreign import javascript unsafe "(($1) => { return $1[\"screenTop\"]; })"
          js_getScreenTop :: Window -> IO Int
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.screenTop Mozilla Window.screenTop documentation> 
  getScreenTop :: (MonadIO m) => Window -> m Int
  getScreenTop self = liftIO (js_getScreenTop self)
   
  foreign import javascript unsafe "(($1) => { return $1[\"clientInformation\"]; })"
          js_getClientInformation :: Window -> IO Navigator
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.clientInformation Mozilla Window.clientInformation documentation> 
  getClientInformation :: (MonadIO m) => Window -> m Navigator
  getClientInformation self = liftIO (js_getClientInformation self)
   
  foreign import javascript unsafe "(($1) => { return $1[\"styleMedia\"]; })"
          js_getStyleMedia :: Window -> IO StyleMedia
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.styleMedia Mozilla Window.styleMedia documentation> 
  getStyleMedia :: (MonadIO m) => Window -> m StyleMedia
  getStyleMedia self = liftIO (js_getStyleMedia self)
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.ongesturechange Mozilla Window.ongesturechange documentation> 
  gestureChange :: EventName Window UIEvent
  gestureChange = unsafeEventName (toJSString "gesturechange")
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.ongestureend Mozilla Window.ongestureend documentation> 
  gestureEnd :: EventName Window UIEvent
  gestureEnd = unsafeEventName (toJSString "gestureend")
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.ongesturestart Mozilla Window.ongesturestart documentation> 
  gestureStart :: EventName Window UIEvent
  gestureStart = unsafeEventName (toJSString "gesturestart")
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.ondevicemotion Mozilla Window.ondevicemotion documentation> 
  deviceMotion :: EventName Window DeviceMotionEvent
  deviceMotion = unsafeEventName (toJSString "devicemotion")
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.ondeviceorientation Mozilla Window.ondeviceorientation documentation> 
  deviceOrientation :: EventName Window DeviceOrientationEvent
  deviceOrientation
    = unsafeEventName (toJSString "deviceorientation")
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.onwebkitdeviceproximity Mozilla Window.onwebkitdeviceproximity documentation> 
  webKitDeviceProximity :: EventName Window DeviceProximityEvent
  webKitDeviceProximity
    = unsafeEventName (toJSString "webkitdeviceproximity")
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.onwebkitanimationend Mozilla Window.onwebkitanimationend documentation> 
  webKitAnimationEnd :: EventName Window AnimationEvent
  webKitAnimationEnd
    = unsafeEventName (toJSString "webkitanimationend")
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.onwebkitanimationiteration Mozilla Window.onwebkitanimationiteration documentation> 
  webKitAnimationIteration :: EventName Window AnimationEvent
  webKitAnimationIteration
    = unsafeEventName (toJSString "webkitanimationiteration")
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.onwebkitanimationstart Mozilla Window.onwebkitanimationstart documentation> 
  webKitAnimationStart :: EventName Window AnimationEvent
  webKitAnimationStart
    = unsafeEventName (toJSString "webkitanimationstart")
  
  -- | <https://developer.mozilla.org/en-US/docs/Web/API/Window.onwebkittransitionend Mozilla Window.onwebkittransitionend documentation> 
  webKitTransitionEnd :: EventName Window TransitionEvent
  webKitTransitionEnd
    = unsafeEventName (toJSString "webkittransitionend")