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

-- * Exported types
    DOMValidityState(..)                    ,
    IsDOMValidityState                      ,
    toDOMValidityState                      ,
    noDOMValidityState                      ,


 -- * Methods
-- ** getBadInput #method:getBadInput#
    DOMValidityStateGetBadInputMethodInfo   ,
    dOMValidityStateGetBadInput             ,


-- ** getCustomError #method:getCustomError#
    DOMValidityStateGetCustomErrorMethodInfo,
    dOMValidityStateGetCustomError          ,


-- ** getPatternMismatch #method:getPatternMismatch#
    DOMValidityStateGetPatternMismatchMethodInfo,
    dOMValidityStateGetPatternMismatch      ,


-- ** getRangeOverflow #method:getRangeOverflow#
    DOMValidityStateGetRangeOverflowMethodInfo,
    dOMValidityStateGetRangeOverflow        ,


-- ** getRangeUnderflow #method:getRangeUnderflow#
    DOMValidityStateGetRangeUnderflowMethodInfo,
    dOMValidityStateGetRangeUnderflow       ,


-- ** getStepMismatch #method:getStepMismatch#
    DOMValidityStateGetStepMismatchMethodInfo,
    dOMValidityStateGetStepMismatch         ,


-- ** getTooLong #method:getTooLong#
    DOMValidityStateGetTooLongMethodInfo    ,
    dOMValidityStateGetTooLong              ,


-- ** getTypeMismatch #method:getTypeMismatch#
    DOMValidityStateGetTypeMismatchMethodInfo,
    dOMValidityStateGetTypeMismatch         ,


-- ** getValid #method:getValid#
    DOMValidityStateGetValidMethodInfo      ,
    dOMValidityStateGetValid                ,


-- ** getValueMissing #method:getValueMissing#
    DOMValidityStateGetValueMissingMethodInfo,
    dOMValidityStateGetValueMissing         ,




 -- * Properties
-- ** badInput #attr:badInput#
    DOMValidityStateBadInputPropertyInfo    ,
    dOMValidityStateBadInput                ,
    getDOMValidityStateBadInput             ,


-- ** customError #attr:customError#
    DOMValidityStateCustomErrorPropertyInfo ,
    dOMValidityStateCustomError             ,
    getDOMValidityStateCustomError          ,


-- ** patternMismatch #attr:patternMismatch#
    DOMValidityStatePatternMismatchPropertyInfo,
    dOMValidityStatePatternMismatch         ,
    getDOMValidityStatePatternMismatch      ,


-- ** rangeOverflow #attr:rangeOverflow#
    DOMValidityStateRangeOverflowPropertyInfo,
    dOMValidityStateRangeOverflow           ,
    getDOMValidityStateRangeOverflow        ,


-- ** rangeUnderflow #attr:rangeUnderflow#
    DOMValidityStateRangeUnderflowPropertyInfo,
    dOMValidityStateRangeUnderflow          ,
    getDOMValidityStateRangeUnderflow       ,


-- ** stepMismatch #attr:stepMismatch#
    DOMValidityStateStepMismatchPropertyInfo,
    dOMValidityStateStepMismatch            ,
    getDOMValidityStateStepMismatch         ,


-- ** tooLong #attr:tooLong#
    DOMValidityStateTooLongPropertyInfo     ,
    dOMValidityStateTooLong                 ,
    getDOMValidityStateTooLong              ,


-- ** typeMismatch #attr:typeMismatch#
    DOMValidityStateTypeMismatchPropertyInfo,
    dOMValidityStateTypeMismatch            ,
    getDOMValidityStateTypeMismatch         ,


-- ** valid #attr:valid#
    DOMValidityStateValidPropertyInfo       ,
    dOMValidityStateValid                   ,
    getDOMValidityStateValid                ,


-- ** valueMissing #attr:valueMissing#
    DOMValidityStateValueMissingPropertyInfo,
    dOMValidityStateValueMissing            ,
    getDOMValidityStateValueMissing         ,




    ) 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.Objects.DOMObject as WebKit.DOMObject

newtype DOMValidityState = DOMValidityState (ManagedPtr DOMValidityState)
foreign import ccall "webkit_dom_validity_state_get_type"
    c_webkit_dom_validity_state_get_type :: IO GType

instance GObject DOMValidityState where
    gobjectType _ = c_webkit_dom_validity_state_get_type
    

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

toDOMValidityState :: IsDOMValidityState o => o -> IO DOMValidityState
toDOMValidityState = unsafeCastTo DOMValidityState

noDOMValidityState :: Maybe DOMValidityState
noDOMValidityState = Nothing

type family ResolveDOMValidityStateMethod (t :: Symbol) (o :: *) :: * where
    ResolveDOMValidityStateMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveDOMValidityStateMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveDOMValidityStateMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveDOMValidityStateMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveDOMValidityStateMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveDOMValidityStateMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveDOMValidityStateMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveDOMValidityStateMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveDOMValidityStateMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveDOMValidityStateMethod "replaceData" o = GObject.Object.ObjectReplaceDataMethodInfo
    ResolveDOMValidityStateMethod "replaceQdata" o = GObject.Object.ObjectReplaceQdataMethodInfo
    ResolveDOMValidityStateMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveDOMValidityStateMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveDOMValidityStateMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveDOMValidityStateMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveDOMValidityStateMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveDOMValidityStateMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveDOMValidityStateMethod "getBadInput" o = DOMValidityStateGetBadInputMethodInfo
    ResolveDOMValidityStateMethod "getCustomError" o = DOMValidityStateGetCustomErrorMethodInfo
    ResolveDOMValidityStateMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveDOMValidityStateMethod "getPatternMismatch" o = DOMValidityStateGetPatternMismatchMethodInfo
    ResolveDOMValidityStateMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveDOMValidityStateMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveDOMValidityStateMethod "getRangeOverflow" o = DOMValidityStateGetRangeOverflowMethodInfo
    ResolveDOMValidityStateMethod "getRangeUnderflow" o = DOMValidityStateGetRangeUnderflowMethodInfo
    ResolveDOMValidityStateMethod "getStepMismatch" o = DOMValidityStateGetStepMismatchMethodInfo
    ResolveDOMValidityStateMethod "getTooLong" o = DOMValidityStateGetTooLongMethodInfo
    ResolveDOMValidityStateMethod "getTypeMismatch" o = DOMValidityStateGetTypeMismatchMethodInfo
    ResolveDOMValidityStateMethod "getValid" o = DOMValidityStateGetValidMethodInfo
    ResolveDOMValidityStateMethod "getValueMissing" o = DOMValidityStateGetValueMissingMethodInfo
    ResolveDOMValidityStateMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveDOMValidityStateMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveDOMValidityStateMethod l o = O.MethodResolutionFailed l o

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

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

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

getDOMValidityStateBadInput :: (MonadIO m, IsDOMValidityState o) => o -> m Bool
getDOMValidityStateBadInput obj = liftIO $ getObjectPropertyBool obj "bad-input"

data DOMValidityStateBadInputPropertyInfo
instance AttrInfo DOMValidityStateBadInputPropertyInfo where
    type AttrAllowedOps DOMValidityStateBadInputPropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint DOMValidityStateBadInputPropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMValidityStateBadInputPropertyInfo = IsDOMValidityState
    type AttrGetType DOMValidityStateBadInputPropertyInfo = Bool
    type AttrLabel DOMValidityStateBadInputPropertyInfo = "bad-input"
    type AttrOrigin DOMValidityStateBadInputPropertyInfo = DOMValidityState
    attrGet _ = getDOMValidityStateBadInput
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

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

getDOMValidityStateCustomError :: (MonadIO m, IsDOMValidityState o) => o -> m Bool
getDOMValidityStateCustomError obj = liftIO $ getObjectPropertyBool obj "custom-error"

data DOMValidityStateCustomErrorPropertyInfo
instance AttrInfo DOMValidityStateCustomErrorPropertyInfo where
    type AttrAllowedOps DOMValidityStateCustomErrorPropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint DOMValidityStateCustomErrorPropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMValidityStateCustomErrorPropertyInfo = IsDOMValidityState
    type AttrGetType DOMValidityStateCustomErrorPropertyInfo = Bool
    type AttrLabel DOMValidityStateCustomErrorPropertyInfo = "custom-error"
    type AttrOrigin DOMValidityStateCustomErrorPropertyInfo = DOMValidityState
    attrGet _ = getDOMValidityStateCustomError
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

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

getDOMValidityStatePatternMismatch :: (MonadIO m, IsDOMValidityState o) => o -> m Bool
getDOMValidityStatePatternMismatch obj = liftIO $ getObjectPropertyBool obj "pattern-mismatch"

data DOMValidityStatePatternMismatchPropertyInfo
instance AttrInfo DOMValidityStatePatternMismatchPropertyInfo where
    type AttrAllowedOps DOMValidityStatePatternMismatchPropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint DOMValidityStatePatternMismatchPropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMValidityStatePatternMismatchPropertyInfo = IsDOMValidityState
    type AttrGetType DOMValidityStatePatternMismatchPropertyInfo = Bool
    type AttrLabel DOMValidityStatePatternMismatchPropertyInfo = "pattern-mismatch"
    type AttrOrigin DOMValidityStatePatternMismatchPropertyInfo = DOMValidityState
    attrGet _ = getDOMValidityStatePatternMismatch
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

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

getDOMValidityStateRangeOverflow :: (MonadIO m, IsDOMValidityState o) => o -> m Bool
getDOMValidityStateRangeOverflow obj = liftIO $ getObjectPropertyBool obj "range-overflow"

data DOMValidityStateRangeOverflowPropertyInfo
instance AttrInfo DOMValidityStateRangeOverflowPropertyInfo where
    type AttrAllowedOps DOMValidityStateRangeOverflowPropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint DOMValidityStateRangeOverflowPropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMValidityStateRangeOverflowPropertyInfo = IsDOMValidityState
    type AttrGetType DOMValidityStateRangeOverflowPropertyInfo = Bool
    type AttrLabel DOMValidityStateRangeOverflowPropertyInfo = "range-overflow"
    type AttrOrigin DOMValidityStateRangeOverflowPropertyInfo = DOMValidityState
    attrGet _ = getDOMValidityStateRangeOverflow
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

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

getDOMValidityStateRangeUnderflow :: (MonadIO m, IsDOMValidityState o) => o -> m Bool
getDOMValidityStateRangeUnderflow obj = liftIO $ getObjectPropertyBool obj "range-underflow"

data DOMValidityStateRangeUnderflowPropertyInfo
instance AttrInfo DOMValidityStateRangeUnderflowPropertyInfo where
    type AttrAllowedOps DOMValidityStateRangeUnderflowPropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint DOMValidityStateRangeUnderflowPropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMValidityStateRangeUnderflowPropertyInfo = IsDOMValidityState
    type AttrGetType DOMValidityStateRangeUnderflowPropertyInfo = Bool
    type AttrLabel DOMValidityStateRangeUnderflowPropertyInfo = "range-underflow"
    type AttrOrigin DOMValidityStateRangeUnderflowPropertyInfo = DOMValidityState
    attrGet _ = getDOMValidityStateRangeUnderflow
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

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

getDOMValidityStateStepMismatch :: (MonadIO m, IsDOMValidityState o) => o -> m Bool
getDOMValidityStateStepMismatch obj = liftIO $ getObjectPropertyBool obj "step-mismatch"

data DOMValidityStateStepMismatchPropertyInfo
instance AttrInfo DOMValidityStateStepMismatchPropertyInfo where
    type AttrAllowedOps DOMValidityStateStepMismatchPropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint DOMValidityStateStepMismatchPropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMValidityStateStepMismatchPropertyInfo = IsDOMValidityState
    type AttrGetType DOMValidityStateStepMismatchPropertyInfo = Bool
    type AttrLabel DOMValidityStateStepMismatchPropertyInfo = "step-mismatch"
    type AttrOrigin DOMValidityStateStepMismatchPropertyInfo = DOMValidityState
    attrGet _ = getDOMValidityStateStepMismatch
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

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

getDOMValidityStateTooLong :: (MonadIO m, IsDOMValidityState o) => o -> m Bool
getDOMValidityStateTooLong obj = liftIO $ getObjectPropertyBool obj "too-long"

data DOMValidityStateTooLongPropertyInfo
instance AttrInfo DOMValidityStateTooLongPropertyInfo where
    type AttrAllowedOps DOMValidityStateTooLongPropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint DOMValidityStateTooLongPropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMValidityStateTooLongPropertyInfo = IsDOMValidityState
    type AttrGetType DOMValidityStateTooLongPropertyInfo = Bool
    type AttrLabel DOMValidityStateTooLongPropertyInfo = "too-long"
    type AttrOrigin DOMValidityStateTooLongPropertyInfo = DOMValidityState
    attrGet _ = getDOMValidityStateTooLong
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

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

getDOMValidityStateTypeMismatch :: (MonadIO m, IsDOMValidityState o) => o -> m Bool
getDOMValidityStateTypeMismatch obj = liftIO $ getObjectPropertyBool obj "type-mismatch"

data DOMValidityStateTypeMismatchPropertyInfo
instance AttrInfo DOMValidityStateTypeMismatchPropertyInfo where
    type AttrAllowedOps DOMValidityStateTypeMismatchPropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint DOMValidityStateTypeMismatchPropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMValidityStateTypeMismatchPropertyInfo = IsDOMValidityState
    type AttrGetType DOMValidityStateTypeMismatchPropertyInfo = Bool
    type AttrLabel DOMValidityStateTypeMismatchPropertyInfo = "type-mismatch"
    type AttrOrigin DOMValidityStateTypeMismatchPropertyInfo = DOMValidityState
    attrGet _ = getDOMValidityStateTypeMismatch
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

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

getDOMValidityStateValid :: (MonadIO m, IsDOMValidityState o) => o -> m Bool
getDOMValidityStateValid obj = liftIO $ getObjectPropertyBool obj "valid"

data DOMValidityStateValidPropertyInfo
instance AttrInfo DOMValidityStateValidPropertyInfo where
    type AttrAllowedOps DOMValidityStateValidPropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint DOMValidityStateValidPropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMValidityStateValidPropertyInfo = IsDOMValidityState
    type AttrGetType DOMValidityStateValidPropertyInfo = Bool
    type AttrLabel DOMValidityStateValidPropertyInfo = "valid"
    type AttrOrigin DOMValidityStateValidPropertyInfo = DOMValidityState
    attrGet _ = getDOMValidityStateValid
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

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

getDOMValidityStateValueMissing :: (MonadIO m, IsDOMValidityState o) => o -> m Bool
getDOMValidityStateValueMissing obj = liftIO $ getObjectPropertyBool obj "value-missing"

data DOMValidityStateValueMissingPropertyInfo
instance AttrInfo DOMValidityStateValueMissingPropertyInfo where
    type AttrAllowedOps DOMValidityStateValueMissingPropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint DOMValidityStateValueMissingPropertyInfo = (~) ()
    type AttrBaseTypeConstraint DOMValidityStateValueMissingPropertyInfo = IsDOMValidityState
    type AttrGetType DOMValidityStateValueMissingPropertyInfo = Bool
    type AttrLabel DOMValidityStateValueMissingPropertyInfo = "value-missing"
    type AttrOrigin DOMValidityStateValueMissingPropertyInfo = DOMValidityState
    attrGet _ = getDOMValidityStateValueMissing
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

instance O.HasAttributeList DOMValidityState
type instance O.AttributeList DOMValidityState = DOMValidityStateAttributeList
type DOMValidityStateAttributeList = ('[ '("badInput", DOMValidityStateBadInputPropertyInfo), '("coreObject", WebKit.DOMObject.DOMObjectCoreObjectPropertyInfo), '("customError", DOMValidityStateCustomErrorPropertyInfo), '("patternMismatch", DOMValidityStatePatternMismatchPropertyInfo), '("rangeOverflow", DOMValidityStateRangeOverflowPropertyInfo), '("rangeUnderflow", DOMValidityStateRangeUnderflowPropertyInfo), '("stepMismatch", DOMValidityStateStepMismatchPropertyInfo), '("tooLong", DOMValidityStateTooLongPropertyInfo), '("typeMismatch", DOMValidityStateTypeMismatchPropertyInfo), '("valid", DOMValidityStateValidPropertyInfo), '("valueMissing", DOMValidityStateValueMissingPropertyInfo)] :: [(Symbol, *)])

dOMValidityStateBadInput :: AttrLabelProxy "badInput"
dOMValidityStateBadInput = AttrLabelProxy

dOMValidityStateCustomError :: AttrLabelProxy "customError"
dOMValidityStateCustomError = AttrLabelProxy

dOMValidityStatePatternMismatch :: AttrLabelProxy "patternMismatch"
dOMValidityStatePatternMismatch = AttrLabelProxy

dOMValidityStateRangeOverflow :: AttrLabelProxy "rangeOverflow"
dOMValidityStateRangeOverflow = AttrLabelProxy

dOMValidityStateRangeUnderflow :: AttrLabelProxy "rangeUnderflow"
dOMValidityStateRangeUnderflow = AttrLabelProxy

dOMValidityStateStepMismatch :: AttrLabelProxy "stepMismatch"
dOMValidityStateStepMismatch = AttrLabelProxy

dOMValidityStateTooLong :: AttrLabelProxy "tooLong"
dOMValidityStateTooLong = AttrLabelProxy

dOMValidityStateTypeMismatch :: AttrLabelProxy "typeMismatch"
dOMValidityStateTypeMismatch = AttrLabelProxy

dOMValidityStateValid :: AttrLabelProxy "valid"
dOMValidityStateValid = AttrLabelProxy

dOMValidityStateValueMissing :: AttrLabelProxy "valueMissing"
dOMValidityStateValueMissing = AttrLabelProxy

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

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

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

data DOMValidityStateGetBadInputMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsDOMValidityState a) => O.MethodInfo DOMValidityStateGetBadInputMethodInfo a signature where
    overloadedMethod _ = dOMValidityStateGetBadInput

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

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

data DOMValidityStateGetCustomErrorMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsDOMValidityState a) => O.MethodInfo DOMValidityStateGetCustomErrorMethodInfo a signature where
    overloadedMethod _ = dOMValidityStateGetCustomError

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

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

data DOMValidityStateGetPatternMismatchMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsDOMValidityState a) => O.MethodInfo DOMValidityStateGetPatternMismatchMethodInfo a signature where
    overloadedMethod _ = dOMValidityStateGetPatternMismatch

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

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

data DOMValidityStateGetRangeOverflowMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsDOMValidityState a) => O.MethodInfo DOMValidityStateGetRangeOverflowMethodInfo a signature where
    overloadedMethod _ = dOMValidityStateGetRangeOverflow

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

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

data DOMValidityStateGetRangeUnderflowMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsDOMValidityState a) => O.MethodInfo DOMValidityStateGetRangeUnderflowMethodInfo a signature where
    overloadedMethod _ = dOMValidityStateGetRangeUnderflow

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

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

data DOMValidityStateGetStepMismatchMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsDOMValidityState a) => O.MethodInfo DOMValidityStateGetStepMismatchMethodInfo a signature where
    overloadedMethod _ = dOMValidityStateGetStepMismatch

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

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

data DOMValidityStateGetTooLongMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsDOMValidityState a) => O.MethodInfo DOMValidityStateGetTooLongMethodInfo a signature where
    overloadedMethod _ = dOMValidityStateGetTooLong

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

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

data DOMValidityStateGetTypeMismatchMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsDOMValidityState a) => O.MethodInfo DOMValidityStateGetTypeMismatchMethodInfo a signature where
    overloadedMethod _ = dOMValidityStateGetTypeMismatch

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

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

data DOMValidityStateGetValidMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsDOMValidityState a) => O.MethodInfo DOMValidityStateGetValidMethodInfo a signature where
    overloadedMethod _ = dOMValidityStateGetValid

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

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

data DOMValidityStateGetValueMissingMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsDOMValidityState a) => O.MethodInfo DOMValidityStateGetValueMissingMethodInfo a signature where
    overloadedMethod _ = dOMValidityStateGetValueMissing