ValidityState.hs

{-# LANGUAGE PatternSynonyms #-}
{-# LANGUAGE ForeignFunctionInterface #-}
{-# LANGUAGE JavaScriptFFI #-}
-- For HasCallStack compatibility
{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
module GHCJS.DOM.JSFFI.Generated.ValidityState
       (js_getValueMissing, getValueMissing, js_getTypeMismatch,
        getTypeMismatch, js_getPatternMismatch, getPatternMismatch,
        js_getTooShort, getTooShort, js_getTooLong, getTooLong,
        js_getRangeUnderflow, getRangeUnderflow, js_getRangeOverflow,
        getRangeOverflow, js_getStepMismatch, getStepMismatch,
        js_getBadInput, getBadInput, js_getCustomError, getCustomError,
        js_getValid, getValid, ValidityState(..), gTypeValidityState)
       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) => { return ($1[\"valueMissing\"] ? 1 : 0); })"
        js_getValueMissing :: ValidityState -> IO Bool

-- | <https://developer.mozilla.org/en-US/docs/Web/API/ValidityState.valueMissing Mozilla ValidityState.valueMissing documentation> 
getValueMissing :: (MonadIO m) => ValidityState -> m Bool
getValueMissing self = liftIO (js_getValueMissing self)
 
foreign import javascript unsafe "(($1) => { return ($1[\"typeMismatch\"] ? 1 : 0); })"
        js_getTypeMismatch :: ValidityState -> IO Bool

-- | <https://developer.mozilla.org/en-US/docs/Web/API/ValidityState.typeMismatch Mozilla ValidityState.typeMismatch documentation> 
getTypeMismatch :: (MonadIO m) => ValidityState -> m Bool
getTypeMismatch self = liftIO (js_getTypeMismatch self)
 
foreign import javascript unsafe
        "(($1) => { return ($1[\"patternMismatch\"] ? 1 : 0); })" js_getPatternMismatch ::
        ValidityState -> IO Bool

-- | <https://developer.mozilla.org/en-US/docs/Web/API/ValidityState.patternMismatch Mozilla ValidityState.patternMismatch documentation> 
getPatternMismatch :: (MonadIO m) => ValidityState -> m Bool
getPatternMismatch self = liftIO (js_getPatternMismatch self)
 
foreign import javascript unsafe "(($1) => { return ($1[\"tooShort\"] ? 1 : 0); })"
        js_getTooShort :: ValidityState -> IO Bool

-- | <https://developer.mozilla.org/en-US/docs/Web/API/ValidityState.tooShort Mozilla ValidityState.tooShort documentation> 
getTooShort :: (MonadIO m) => ValidityState -> m Bool
getTooShort self = liftIO (js_getTooShort self)
 
foreign import javascript unsafe "(($1) => { return ($1[\"tooLong\"] ? 1 : 0); })"
        js_getTooLong :: ValidityState -> IO Bool

-- | <https://developer.mozilla.org/en-US/docs/Web/API/ValidityState.tooLong Mozilla ValidityState.tooLong documentation> 
getTooLong :: (MonadIO m) => ValidityState -> m Bool
getTooLong self = liftIO (js_getTooLong self)
 
foreign import javascript unsafe "(($1) => { return ($1[\"rangeUnderflow\"] ? 1 : 0); })"
        js_getRangeUnderflow :: ValidityState -> IO Bool

-- | <https://developer.mozilla.org/en-US/docs/Web/API/ValidityState.rangeUnderflow Mozilla ValidityState.rangeUnderflow documentation> 
getRangeUnderflow :: (MonadIO m) => ValidityState -> m Bool
getRangeUnderflow self = liftIO (js_getRangeUnderflow self)
 
foreign import javascript unsafe "(($1) => { return ($1[\"rangeOverflow\"] ? 1 : 0); })"
        js_getRangeOverflow :: ValidityState -> IO Bool

-- | <https://developer.mozilla.org/en-US/docs/Web/API/ValidityState.rangeOverflow Mozilla ValidityState.rangeOverflow documentation> 
getRangeOverflow :: (MonadIO m) => ValidityState -> m Bool
getRangeOverflow self = liftIO (js_getRangeOverflow self)
 
foreign import javascript unsafe "(($1) => { return ($1[\"stepMismatch\"] ? 1 : 0); })"
        js_getStepMismatch :: ValidityState -> IO Bool

-- | <https://developer.mozilla.org/en-US/docs/Web/API/ValidityState.stepMismatch Mozilla ValidityState.stepMismatch documentation> 
getStepMismatch :: (MonadIO m) => ValidityState -> m Bool
getStepMismatch self = liftIO (js_getStepMismatch self)
 
foreign import javascript unsafe "(($1) => { return ($1[\"badInput\"] ? 1 : 0); })"
        js_getBadInput :: ValidityState -> IO Bool

-- | <https://developer.mozilla.org/en-US/docs/Web/API/ValidityState.badInput Mozilla ValidityState.badInput documentation> 
getBadInput :: (MonadIO m) => ValidityState -> m Bool
getBadInput self = liftIO (js_getBadInput self)
 
foreign import javascript unsafe "(($1) => { return ($1[\"customError\"] ? 1 : 0); })"
        js_getCustomError :: ValidityState -> IO Bool

-- | <https://developer.mozilla.org/en-US/docs/Web/API/ValidityState.customError Mozilla ValidityState.customError documentation> 
getCustomError :: (MonadIO m) => ValidityState -> m Bool
getCustomError self = liftIO (js_getCustomError self)
 
foreign import javascript unsafe "(($1) => { return ($1[\"valid\"] ? 1 : 0); })"
        js_getValid :: ValidityState -> IO Bool

-- | <https://developer.mozilla.org/en-US/docs/Web/API/ValidityState.valid Mozilla ValidityState.valid documentation> 
getValid :: (MonadIO m) => ValidityState -> m Bool
getValid self = liftIO (js_getValid self)