{-# LANGUAGE PatternSynonyms #-}
{-# LANGUAGE ForeignFunctionInterface #-}
{-# LANGUAGE JavaScriptFFI #-}
-- For HasCallStack compatibility
{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
module GHCJS.DOM.JSFFI.Generated.PerformanceTiming
       (js_getNavigationStart, getNavigationStart, js_getUnloadEventStart,
        getUnloadEventStart, js_getUnloadEventEnd, getUnloadEventEnd,
        js_getRedirectStart, getRedirectStart, js_getRedirectEnd,
        getRedirectEnd, js_getFetchStart, getFetchStart,
        js_getDomainLookupStart, getDomainLookupStart,
        js_getDomainLookupEnd, getDomainLookupEnd, js_getConnectStart,
        getConnectStart, js_getConnectEnd, getConnectEnd,
        js_getSecureConnectionStart, getSecureConnectionStart,
        js_getRequestStart, getRequestStart, js_getResponseStart,
        getResponseStart, js_getResponseEnd, getResponseEnd,
        js_getDomLoading, getDomLoading, js_getDomInteractive,
        getDomInteractive, js_getDomContentLoadedEventStart,
        getDomContentLoadedEventStart, js_getDomContentLoadedEventEnd,
        getDomContentLoadedEventEnd, js_getDomComplete, getDomComplete,
        js_getLoadEventStart, getLoadEventStart, js_getLoadEventEnd,
        getLoadEventEnd, PerformanceTiming(..), gTypePerformanceTiming)
       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 GHCJS.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)
import GHCJS.DOM.JSFFI.Generated.Enums
 
foreign import javascript unsafe "$1[\"navigationStart\"]"
        js_getNavigationStart :: PerformanceTiming -> IO Double

-- | <https://developer.mozilla.org/en-US/docs/Web/API/PerformanceTiming.navigationStart Mozilla PerformanceTiming.navigationStart documentation> 
getNavigationStart :: (MonadIO m) => PerformanceTiming -> m Word64
getNavigationStart self
  = liftIO (round <$> (js_getNavigationStart self))
 
foreign import javascript unsafe "$1[\"unloadEventStart\"]"
        js_getUnloadEventStart :: PerformanceTiming -> IO Double

-- | <https://developer.mozilla.org/en-US/docs/Web/API/PerformanceTiming.unloadEventStart Mozilla PerformanceTiming.unloadEventStart documentation> 
getUnloadEventStart :: (MonadIO m) => PerformanceTiming -> m Word64
getUnloadEventStart self
  = liftIO (round <$> (js_getUnloadEventStart self))
 
foreign import javascript unsafe "$1[\"unloadEventEnd\"]"
        js_getUnloadEventEnd :: PerformanceTiming -> IO Double

-- | <https://developer.mozilla.org/en-US/docs/Web/API/PerformanceTiming.unloadEventEnd Mozilla PerformanceTiming.unloadEventEnd documentation> 
getUnloadEventEnd :: (MonadIO m) => PerformanceTiming -> m Word64
getUnloadEventEnd self
  = liftIO (round <$> (js_getUnloadEventEnd self))
 
foreign import javascript unsafe "$1[\"redirectStart\"]"
        js_getRedirectStart :: PerformanceTiming -> IO Double

-- | <https://developer.mozilla.org/en-US/docs/Web/API/PerformanceTiming.redirectStart Mozilla PerformanceTiming.redirectStart documentation> 
getRedirectStart :: (MonadIO m) => PerformanceTiming -> m Word64
getRedirectStart self
  = liftIO (round <$> (js_getRedirectStart self))
 
foreign import javascript unsafe "$1[\"redirectEnd\"]"
        js_getRedirectEnd :: PerformanceTiming -> IO Double

-- | <https://developer.mozilla.org/en-US/docs/Web/API/PerformanceTiming.redirectEnd Mozilla PerformanceTiming.redirectEnd documentation> 
getRedirectEnd :: (MonadIO m) => PerformanceTiming -> m Word64
getRedirectEnd self = liftIO (round <$> (js_getRedirectEnd self))
 
foreign import javascript unsafe "$1[\"fetchStart\"]"
        js_getFetchStart :: PerformanceTiming -> IO Double

-- | <https://developer.mozilla.org/en-US/docs/Web/API/PerformanceTiming.fetchStart Mozilla PerformanceTiming.fetchStart documentation> 
getFetchStart :: (MonadIO m) => PerformanceTiming -> m Word64
getFetchStart self = liftIO (round <$> (js_getFetchStart self))
 
foreign import javascript unsafe "$1[\"domainLookupStart\"]"
        js_getDomainLookupStart :: PerformanceTiming -> IO Double

-- | <https://developer.mozilla.org/en-US/docs/Web/API/PerformanceTiming.domainLookupStart Mozilla PerformanceTiming.domainLookupStart documentation> 
getDomainLookupStart ::
                     (MonadIO m) => PerformanceTiming -> m Word64
getDomainLookupStart self
  = liftIO (round <$> (js_getDomainLookupStart self))
 
foreign import javascript unsafe "$1[\"domainLookupEnd\"]"
        js_getDomainLookupEnd :: PerformanceTiming -> IO Double

-- | <https://developer.mozilla.org/en-US/docs/Web/API/PerformanceTiming.domainLookupEnd Mozilla PerformanceTiming.domainLookupEnd documentation> 
getDomainLookupEnd :: (MonadIO m) => PerformanceTiming -> m Word64
getDomainLookupEnd self
  = liftIO (round <$> (js_getDomainLookupEnd self))
 
foreign import javascript unsafe "$1[\"connectStart\"]"
        js_getConnectStart :: PerformanceTiming -> IO Double

-- | <https://developer.mozilla.org/en-US/docs/Web/API/PerformanceTiming.connectStart Mozilla PerformanceTiming.connectStart documentation> 
getConnectStart :: (MonadIO m) => PerformanceTiming -> m Word64
getConnectStart self = liftIO (round <$> (js_getConnectStart self))
 
foreign import javascript unsafe "$1[\"connectEnd\"]"
        js_getConnectEnd :: PerformanceTiming -> IO Double

-- | <https://developer.mozilla.org/en-US/docs/Web/API/PerformanceTiming.connectEnd Mozilla PerformanceTiming.connectEnd documentation> 
getConnectEnd :: (MonadIO m) => PerformanceTiming -> m Word64
getConnectEnd self = liftIO (round <$> (js_getConnectEnd self))
 
foreign import javascript unsafe "$1[\"secureConnectionStart\"]"
        js_getSecureConnectionStart :: PerformanceTiming -> IO Double

-- | <https://developer.mozilla.org/en-US/docs/Web/API/PerformanceTiming.secureConnectionStart Mozilla PerformanceTiming.secureConnectionStart documentation> 
getSecureConnectionStart ::
                         (MonadIO m) => PerformanceTiming -> m Word64
getSecureConnectionStart self
  = liftIO (round <$> (js_getSecureConnectionStart self))
 
foreign import javascript unsafe "$1[\"requestStart\"]"
        js_getRequestStart :: PerformanceTiming -> IO Double

-- | <https://developer.mozilla.org/en-US/docs/Web/API/PerformanceTiming.requestStart Mozilla PerformanceTiming.requestStart documentation> 
getRequestStart :: (MonadIO m) => PerformanceTiming -> m Word64
getRequestStart self = liftIO (round <$> (js_getRequestStart self))
 
foreign import javascript unsafe "$1[\"responseStart\"]"
        js_getResponseStart :: PerformanceTiming -> IO Double

-- | <https://developer.mozilla.org/en-US/docs/Web/API/PerformanceTiming.responseStart Mozilla PerformanceTiming.responseStart documentation> 
getResponseStart :: (MonadIO m) => PerformanceTiming -> m Word64
getResponseStart self
  = liftIO (round <$> (js_getResponseStart self))
 
foreign import javascript unsafe "$1[\"responseEnd\"]"
        js_getResponseEnd :: PerformanceTiming -> IO Double

-- | <https://developer.mozilla.org/en-US/docs/Web/API/PerformanceTiming.responseEnd Mozilla PerformanceTiming.responseEnd documentation> 
getResponseEnd :: (MonadIO m) => PerformanceTiming -> m Word64
getResponseEnd self = liftIO (round <$> (js_getResponseEnd self))
 
foreign import javascript unsafe "$1[\"domLoading\"]"
        js_getDomLoading :: PerformanceTiming -> IO Double

-- | <https://developer.mozilla.org/en-US/docs/Web/API/PerformanceTiming.domLoading Mozilla PerformanceTiming.domLoading documentation> 
getDomLoading :: (MonadIO m) => PerformanceTiming -> m Word64
getDomLoading self = liftIO (round <$> (js_getDomLoading self))
 
foreign import javascript unsafe "$1[\"domInteractive\"]"
        js_getDomInteractive :: PerformanceTiming -> IO Double

-- | <https://developer.mozilla.org/en-US/docs/Web/API/PerformanceTiming.domInteractive Mozilla PerformanceTiming.domInteractive documentation> 
getDomInteractive :: (MonadIO m) => PerformanceTiming -> m Word64
getDomInteractive self
  = liftIO (round <$> (js_getDomInteractive self))
 
foreign import javascript unsafe
        "$1[\"domContentLoadedEventStart\"]"
        js_getDomContentLoadedEventStart :: PerformanceTiming -> IO Double

-- | <https://developer.mozilla.org/en-US/docs/Web/API/PerformanceTiming.domContentLoadedEventStart Mozilla PerformanceTiming.domContentLoadedEventStart documentation> 
getDomContentLoadedEventStart ::
                              (MonadIO m) => PerformanceTiming -> m Word64
getDomContentLoadedEventStart self
  = liftIO (round <$> (js_getDomContentLoadedEventStart self))
 
foreign import javascript unsafe "$1[\"domContentLoadedEventEnd\"]"
        js_getDomContentLoadedEventEnd :: PerformanceTiming -> IO Double

-- | <https://developer.mozilla.org/en-US/docs/Web/API/PerformanceTiming.domContentLoadedEventEnd Mozilla PerformanceTiming.domContentLoadedEventEnd documentation> 
getDomContentLoadedEventEnd ::
                            (MonadIO m) => PerformanceTiming -> m Word64
getDomContentLoadedEventEnd self
  = liftIO (round <$> (js_getDomContentLoadedEventEnd self))
 
foreign import javascript unsafe "$1[\"domComplete\"]"
        js_getDomComplete :: PerformanceTiming -> IO Double

-- | <https://developer.mozilla.org/en-US/docs/Web/API/PerformanceTiming.domComplete Mozilla PerformanceTiming.domComplete documentation> 
getDomComplete :: (MonadIO m) => PerformanceTiming -> m Word64
getDomComplete self = liftIO (round <$> (js_getDomComplete self))
 
foreign import javascript unsafe "$1[\"loadEventStart\"]"
        js_getLoadEventStart :: PerformanceTiming -> IO Double

-- | <https://developer.mozilla.org/en-US/docs/Web/API/PerformanceTiming.loadEventStart Mozilla PerformanceTiming.loadEventStart documentation> 
getLoadEventStart :: (MonadIO m) => PerformanceTiming -> m Word64
getLoadEventStart self
  = liftIO (round <$> (js_getLoadEventStart self))
 
foreign import javascript unsafe "$1[\"loadEventEnd\"]"
        js_getLoadEventEnd :: PerformanceTiming -> IO Double

-- | <https://developer.mozilla.org/en-US/docs/Web/API/PerformanceTiming.loadEventEnd Mozilla PerformanceTiming.loadEventEnd documentation> 
getLoadEventEnd :: (MonadIO m) => PerformanceTiming -> m Word64
getLoadEventEnd self = liftIO (round <$> (js_getLoadEventEnd self))