-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria

#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif

module GI.WebKit2.Enums
    ( 

 -- * Enumerations


-- ** AuthenticationScheme #enum:AuthenticationScheme#

    AuthenticationScheme(..)                ,


-- ** AutomationBrowsingContextPresentation #enum:AutomationBrowsingContextPresentation#

    AutomationBrowsingContextPresentation(..),


-- ** AutoplayPolicy #enum:AutoplayPolicy#

    AutoplayPolicy(..)                      ,


-- ** CacheModel #enum:CacheModel#

    CacheModel(..)                          ,


-- ** ContextMenuAction #enum:ContextMenuAction#

    ContextMenuAction(..)                   ,


-- ** CookieAcceptPolicy #enum:CookieAcceptPolicy#

    CookieAcceptPolicy(..)                  ,


-- ** CookiePersistentStorage #enum:CookiePersistentStorage#

    CookiePersistentStorage(..)             ,


-- ** CredentialPersistence #enum:CredentialPersistence#

    CredentialPersistence(..)               ,


-- ** DownloadError #enum:DownloadError#

    DownloadError(..)                       ,
    catchDownloadError                      ,
    handleDownloadError                     ,


-- ** FaviconDatabaseError #enum:FaviconDatabaseError#

    FaviconDatabaseError(..)                ,
    catchFaviconDatabaseError               ,
    handleFaviconDatabaseError              ,


-- ** HardwareAccelerationPolicy #enum:HardwareAccelerationPolicy#

    HardwareAccelerationPolicy(..)          ,


-- ** InputPurpose #enum:InputPurpose#

    InputPurpose(..)                        ,


-- ** InsecureContentEvent #enum:InsecureContentEvent#

    InsecureContentEvent(..)                ,


-- ** JavascriptError #enum:JavascriptError#

    JavascriptError(..)                     ,
    catchJavascriptError                    ,
    handleJavascriptError                   ,


-- ** LoadEvent #enum:LoadEvent#

    LoadEvent(..)                           ,


-- ** NavigationType #enum:NavigationType#

    NavigationType(..)                      ,


-- ** NetworkError #enum:NetworkError#

    NetworkError(..)                        ,
    catchNetworkError                       ,
    handleNetworkError                      ,


-- ** NetworkProxyMode #enum:NetworkProxyMode#

    NetworkProxyMode(..)                    ,


-- ** PluginError #enum:PluginError#

    PluginError(..)                         ,
    catchPluginError                        ,
    handlePluginError                       ,


-- ** PolicyDecisionType #enum:PolicyDecisionType#

    PolicyDecisionType(..)                  ,


-- ** PolicyError #enum:PolicyError#

    PolicyError(..)                         ,
    catchPolicyError                        ,
    handlePolicyError                       ,


-- ** PrintError #enum:PrintError#

    PrintError(..)                          ,
    catchPrintError                         ,
    handlePrintError                        ,


-- ** PrintOperationResponse #enum:PrintOperationResponse#

    PrintOperationResponse(..)              ,


-- ** ProcessModel #enum:ProcessModel#

    ProcessModel(..)                        ,


-- ** SaveMode #enum:SaveMode#

    SaveMode(..)                            ,


-- ** ScriptDialogType #enum:ScriptDialogType#

    ScriptDialogType(..)                    ,


-- ** SnapshotError #enum:SnapshotError#

    SnapshotError(..)                       ,
    catchSnapshotError                      ,
    handleSnapshotError                     ,


-- ** SnapshotRegion #enum:SnapshotRegion#

    SnapshotRegion(..)                      ,


-- ** TLSErrorsPolicy #enum:TLSErrorsPolicy#

    TLSErrorsPolicy(..)                     ,


-- ** UserContentFilterError #enum:UserContentFilterError#

    UserContentFilterError(..)              ,
    catchUserContentFilterError             ,
    handleUserContentFilterError            ,


-- ** UserContentInjectedFrames #enum:UserContentInjectedFrames#

    UserContentInjectedFrames(..)           ,


-- ** UserMessageError #enum:UserMessageError#

    UserMessageError(..)                    ,
    catchUserMessageError                   ,
    handleUserMessageError                  ,


-- ** UserScriptInjectionTime #enum:UserScriptInjectionTime#

    UserScriptInjectionTime(..)             ,


-- ** UserStyleLevel #enum:UserStyleLevel#

    UserStyleLevel(..)                      ,


-- ** WebProcessTerminationReason #enum:WebProcessTerminationReason#

    WebProcessTerminationReason(..)         ,




    ) 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.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
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 GHC.OverloadedLabels as OL
import qualified GHC.Records as R


-- Enum WebProcessTerminationReason
-- | Enum values used to specify the reason why the web process terminated abnormally.
-- 
-- /Since: 2.20/
data WebProcessTerminationReason = 
      WebProcessTerminationReasonCrashed
    -- ^ the web process crashed.
    | WebProcessTerminationReasonExceededMemoryLimit
    -- ^ the web process exceeded the memory limit.
    | AnotherWebProcessTerminationReason Int
    -- ^ Catch-all for unknown values
    deriving (Int -> WebProcessTerminationReason -> ShowS
[WebProcessTerminationReason] -> ShowS
WebProcessTerminationReason -> String
(Int -> WebProcessTerminationReason -> ShowS)
-> (WebProcessTerminationReason -> String)
-> ([WebProcessTerminationReason] -> ShowS)
-> Show WebProcessTerminationReason
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [WebProcessTerminationReason] -> ShowS
$cshowList :: [WebProcessTerminationReason] -> ShowS
show :: WebProcessTerminationReason -> String
$cshow :: WebProcessTerminationReason -> String
showsPrec :: Int -> WebProcessTerminationReason -> ShowS
$cshowsPrec :: Int -> WebProcessTerminationReason -> ShowS
Show, WebProcessTerminationReason -> WebProcessTerminationReason -> Bool
(WebProcessTerminationReason
 -> WebProcessTerminationReason -> Bool)
-> (WebProcessTerminationReason
    -> WebProcessTerminationReason -> Bool)
-> Eq WebProcessTerminationReason
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: WebProcessTerminationReason -> WebProcessTerminationReason -> Bool
$c/= :: WebProcessTerminationReason -> WebProcessTerminationReason -> Bool
== :: WebProcessTerminationReason -> WebProcessTerminationReason -> Bool
$c== :: WebProcessTerminationReason -> WebProcessTerminationReason -> Bool
Eq)

instance P.Enum WebProcessTerminationReason where
    fromEnum :: WebProcessTerminationReason -> Int
fromEnum WebProcessTerminationReason
WebProcessTerminationReasonCrashed = Int
0
    fromEnum WebProcessTerminationReason
WebProcessTerminationReasonExceededMemoryLimit = Int
1
    fromEnum (AnotherWebProcessTerminationReason Int
k) = Int
k

    toEnum :: Int -> WebProcessTerminationReason
toEnum Int
0 = WebProcessTerminationReason
WebProcessTerminationReasonCrashed
    toEnum Int
1 = WebProcessTerminationReason
WebProcessTerminationReasonExceededMemoryLimit
    toEnum Int
k = Int -> WebProcessTerminationReason
AnotherWebProcessTerminationReason Int
k

instance P.Ord WebProcessTerminationReason where
    compare :: WebProcessTerminationReason
-> WebProcessTerminationReason -> Ordering
compare WebProcessTerminationReason
a WebProcessTerminationReason
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (WebProcessTerminationReason -> Int
forall a. Enum a => a -> Int
P.fromEnum WebProcessTerminationReason
a) (WebProcessTerminationReason -> Int
forall a. Enum a => a -> Int
P.fromEnum WebProcessTerminationReason
b)

type instance O.ParentTypes WebProcessTerminationReason = '[]
instance O.HasParentTypes WebProcessTerminationReason

foreign import ccall "webkit_web_process_termination_reason_get_type" c_webkit_web_process_termination_reason_get_type :: 
    IO GType

instance B.Types.TypedObject WebProcessTerminationReason where
    glibType :: IO GType
glibType = IO GType
c_webkit_web_process_termination_reason_get_type

instance B.Types.BoxedEnum WebProcessTerminationReason

-- Enum UserStyleLevel
-- | Specifies how to treat an user style sheet.
-- 
-- /Since: 2.6/
data UserStyleLevel = 
      UserStyleLevelUser
    -- ^ The style sheet is an user style sheet,
    --   its contents always override other style sheets. This is the default.
    | UserStyleLevelAuthor
    -- ^ The style sheet will be treated as if
    --   it was provided by the loaded documents. That means other user style
    --   sheets may still override it.
    | AnotherUserStyleLevel Int
    -- ^ Catch-all for unknown values
    deriving (Int -> UserStyleLevel -> ShowS
[UserStyleLevel] -> ShowS
UserStyleLevel -> String
(Int -> UserStyleLevel -> ShowS)
-> (UserStyleLevel -> String)
-> ([UserStyleLevel] -> ShowS)
-> Show UserStyleLevel
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [UserStyleLevel] -> ShowS
$cshowList :: [UserStyleLevel] -> ShowS
show :: UserStyleLevel -> String
$cshow :: UserStyleLevel -> String
showsPrec :: Int -> UserStyleLevel -> ShowS
$cshowsPrec :: Int -> UserStyleLevel -> ShowS
Show, UserStyleLevel -> UserStyleLevel -> Bool
(UserStyleLevel -> UserStyleLevel -> Bool)
-> (UserStyleLevel -> UserStyleLevel -> Bool) -> Eq UserStyleLevel
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: UserStyleLevel -> UserStyleLevel -> Bool
$c/= :: UserStyleLevel -> UserStyleLevel -> Bool
== :: UserStyleLevel -> UserStyleLevel -> Bool
$c== :: UserStyleLevel -> UserStyleLevel -> Bool
Eq)

instance P.Enum UserStyleLevel where
    fromEnum :: UserStyleLevel -> Int
fromEnum UserStyleLevel
UserStyleLevelUser = Int
0
    fromEnum UserStyleLevel
UserStyleLevelAuthor = Int
1
    fromEnum (AnotherUserStyleLevel Int
k) = Int
k

    toEnum :: Int -> UserStyleLevel
toEnum Int
0 = UserStyleLevel
UserStyleLevelUser
    toEnum Int
1 = UserStyleLevel
UserStyleLevelAuthor
    toEnum Int
k = Int -> UserStyleLevel
AnotherUserStyleLevel Int
k

instance P.Ord UserStyleLevel where
    compare :: UserStyleLevel -> UserStyleLevel -> Ordering
compare UserStyleLevel
a UserStyleLevel
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (UserStyleLevel -> Int
forall a. Enum a => a -> Int
P.fromEnum UserStyleLevel
a) (UserStyleLevel -> Int
forall a. Enum a => a -> Int
P.fromEnum UserStyleLevel
b)

type instance O.ParentTypes UserStyleLevel = '[]
instance O.HasParentTypes UserStyleLevel

foreign import ccall "webkit_user_style_level_get_type" c_webkit_user_style_level_get_type :: 
    IO GType

instance B.Types.TypedObject UserStyleLevel where
    glibType :: IO GType
glibType = IO GType
c_webkit_user_style_level_get_type

instance B.Types.BoxedEnum UserStyleLevel

-- Enum UserScriptInjectionTime
-- | Specifies at which place of documents an user script will be inserted.
-- 
-- /Since: 2.6/
data UserScriptInjectionTime = 
      UserScriptInjectionTimeStart
    -- ^ Insert the code of the user
    --   script at the beginning of loaded documents. This is the default.
    | UserScriptInjectionTimeEnd
    -- ^ Insert the code of the user
    --   script at the end of the loaded documents.
    | AnotherUserScriptInjectionTime Int
    -- ^ Catch-all for unknown values
    deriving (Int -> UserScriptInjectionTime -> ShowS
[UserScriptInjectionTime] -> ShowS
UserScriptInjectionTime -> String
(Int -> UserScriptInjectionTime -> ShowS)
-> (UserScriptInjectionTime -> String)
-> ([UserScriptInjectionTime] -> ShowS)
-> Show UserScriptInjectionTime
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [UserScriptInjectionTime] -> ShowS
$cshowList :: [UserScriptInjectionTime] -> ShowS
show :: UserScriptInjectionTime -> String
$cshow :: UserScriptInjectionTime -> String
showsPrec :: Int -> UserScriptInjectionTime -> ShowS
$cshowsPrec :: Int -> UserScriptInjectionTime -> ShowS
Show, UserScriptInjectionTime -> UserScriptInjectionTime -> Bool
(UserScriptInjectionTime -> UserScriptInjectionTime -> Bool)
-> (UserScriptInjectionTime -> UserScriptInjectionTime -> Bool)
-> Eq UserScriptInjectionTime
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: UserScriptInjectionTime -> UserScriptInjectionTime -> Bool
$c/= :: UserScriptInjectionTime -> UserScriptInjectionTime -> Bool
== :: UserScriptInjectionTime -> UserScriptInjectionTime -> Bool
$c== :: UserScriptInjectionTime -> UserScriptInjectionTime -> Bool
Eq)

instance P.Enum UserScriptInjectionTime where
    fromEnum :: UserScriptInjectionTime -> Int
fromEnum UserScriptInjectionTime
UserScriptInjectionTimeStart = Int
0
    fromEnum UserScriptInjectionTime
UserScriptInjectionTimeEnd = Int
1
    fromEnum (AnotherUserScriptInjectionTime Int
k) = Int
k

    toEnum :: Int -> UserScriptInjectionTime
toEnum Int
0 = UserScriptInjectionTime
UserScriptInjectionTimeStart
    toEnum Int
1 = UserScriptInjectionTime
UserScriptInjectionTimeEnd
    toEnum Int
k = Int -> UserScriptInjectionTime
AnotherUserScriptInjectionTime Int
k

instance P.Ord UserScriptInjectionTime where
    compare :: UserScriptInjectionTime -> UserScriptInjectionTime -> Ordering
compare UserScriptInjectionTime
a UserScriptInjectionTime
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (UserScriptInjectionTime -> Int
forall a. Enum a => a -> Int
P.fromEnum UserScriptInjectionTime
a) (UserScriptInjectionTime -> Int
forall a. Enum a => a -> Int
P.fromEnum UserScriptInjectionTime
b)

type instance O.ParentTypes UserScriptInjectionTime = '[]
instance O.HasParentTypes UserScriptInjectionTime

foreign import ccall "webkit_user_script_injection_time_get_type" c_webkit_user_script_injection_time_get_type :: 
    IO GType

instance B.Types.TypedObject UserScriptInjectionTime where
    glibType :: IO GType
glibType = IO GType
c_webkit_user_script_injection_time_get_type

instance B.Types.BoxedEnum UserScriptInjectionTime

-- Enum UserMessageError
-- | Enum values used to denote errors happening when sending user messages.
-- 
-- /Since: 2.28/
data UserMessageError = 
      UserMessageErrorMessage
    -- ^ The message was not handled by the receiver.
    | AnotherUserMessageError Int
    -- ^ Catch-all for unknown values
    deriving (Int -> UserMessageError -> ShowS
[UserMessageError] -> ShowS
UserMessageError -> String
(Int -> UserMessageError -> ShowS)
-> (UserMessageError -> String)
-> ([UserMessageError] -> ShowS)
-> Show UserMessageError
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [UserMessageError] -> ShowS
$cshowList :: [UserMessageError] -> ShowS
show :: UserMessageError -> String
$cshow :: UserMessageError -> String
showsPrec :: Int -> UserMessageError -> ShowS
$cshowsPrec :: Int -> UserMessageError -> ShowS
Show, UserMessageError -> UserMessageError -> Bool
(UserMessageError -> UserMessageError -> Bool)
-> (UserMessageError -> UserMessageError -> Bool)
-> Eq UserMessageError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: UserMessageError -> UserMessageError -> Bool
$c/= :: UserMessageError -> UserMessageError -> Bool
== :: UserMessageError -> UserMessageError -> Bool
$c== :: UserMessageError -> UserMessageError -> Bool
Eq)

instance P.Enum UserMessageError where
    fromEnum :: UserMessageError -> Int
fromEnum UserMessageError
UserMessageErrorMessage = Int
0
    fromEnum (AnotherUserMessageError Int
k) = Int
k

    toEnum :: Int -> UserMessageError
toEnum Int
0 = UserMessageError
UserMessageErrorMessage
    toEnum Int
k = Int -> UserMessageError
AnotherUserMessageError Int
k

instance P.Ord UserMessageError where
    compare :: UserMessageError -> UserMessageError -> Ordering
compare UserMessageError
a UserMessageError
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (UserMessageError -> Int
forall a. Enum a => a -> Int
P.fromEnum UserMessageError
a) (UserMessageError -> Int
forall a. Enum a => a -> Int
P.fromEnum UserMessageError
b)

instance GErrorClass UserMessageError where
    gerrorClassDomain :: UserMessageError -> Text
gerrorClassDomain UserMessageError
_ = Text
"WebKitUserMessageError"

-- | Catch exceptions of type `UserMessageError`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`.
catchUserMessageError ::
    IO a ->
    (UserMessageError -> GErrorMessage -> IO a) ->
    IO a
catchUserMessageError :: forall a. IO a -> (UserMessageError -> Text -> IO a) -> IO a
catchUserMessageError = IO a -> (UserMessageError -> Text -> IO a) -> IO a
forall err a.
GErrorClass err =>
IO a -> (err -> Text -> IO a) -> IO a
catchGErrorJustDomain

-- | Handle exceptions of type `UserMessageError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`.
handleUserMessageError ::
    (UserMessageError -> GErrorMessage -> IO a) ->
    IO a ->
    IO a
handleUserMessageError :: forall a. (UserMessageError -> Text -> IO a) -> IO a -> IO a
handleUserMessageError = (UserMessageError -> Text -> IO a) -> IO a -> IO a
forall err a.
GErrorClass err =>
(err -> Text -> IO a) -> IO a -> IO a
handleGErrorJustDomain

type instance O.ParentTypes UserMessageError = '[]
instance O.HasParentTypes UserMessageError

foreign import ccall "webkit_user_message_error_get_type" c_webkit_user_message_error_get_type :: 
    IO GType

instance B.Types.TypedObject UserMessageError where
    glibType :: IO GType
glibType = IO GType
c_webkit_user_message_error_get_type

instance B.Types.BoxedEnum UserMessageError

-- Enum UserContentInjectedFrames
-- | Specifies in which frames user style sheets are to be inserted in.
-- 
-- /Since: 2.6/
data UserContentInjectedFrames = 
      UserContentInjectedFramesAllFrames
    -- ^ Insert the user style
    --   sheet in all the frames loaded by the web view, including
    --   nested frames. This is the default.
    | UserContentInjectedFramesTopFrame
    -- ^ Insert the user style
    --   sheet *only* in the top-level frame loaded by the web view,
    --   and *not* in the nested frames.
    | AnotherUserContentInjectedFrames Int
    -- ^ Catch-all for unknown values
    deriving (Int -> UserContentInjectedFrames -> ShowS
[UserContentInjectedFrames] -> ShowS
UserContentInjectedFrames -> String
(Int -> UserContentInjectedFrames -> ShowS)
-> (UserContentInjectedFrames -> String)
-> ([UserContentInjectedFrames] -> ShowS)
-> Show UserContentInjectedFrames
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [UserContentInjectedFrames] -> ShowS
$cshowList :: [UserContentInjectedFrames] -> ShowS
show :: UserContentInjectedFrames -> String
$cshow :: UserContentInjectedFrames -> String
showsPrec :: Int -> UserContentInjectedFrames -> ShowS
$cshowsPrec :: Int -> UserContentInjectedFrames -> ShowS
Show, UserContentInjectedFrames -> UserContentInjectedFrames -> Bool
(UserContentInjectedFrames -> UserContentInjectedFrames -> Bool)
-> (UserContentInjectedFrames -> UserContentInjectedFrames -> Bool)
-> Eq UserContentInjectedFrames
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: UserContentInjectedFrames -> UserContentInjectedFrames -> Bool
$c/= :: UserContentInjectedFrames -> UserContentInjectedFrames -> Bool
== :: UserContentInjectedFrames -> UserContentInjectedFrames -> Bool
$c== :: UserContentInjectedFrames -> UserContentInjectedFrames -> Bool
Eq)

instance P.Enum UserContentInjectedFrames where
    fromEnum :: UserContentInjectedFrames -> Int
fromEnum UserContentInjectedFrames
UserContentInjectedFramesAllFrames = Int
0
    fromEnum UserContentInjectedFrames
UserContentInjectedFramesTopFrame = Int
1
    fromEnum (AnotherUserContentInjectedFrames Int
k) = Int
k

    toEnum :: Int -> UserContentInjectedFrames
toEnum Int
0 = UserContentInjectedFrames
UserContentInjectedFramesAllFrames
    toEnum Int
1 = UserContentInjectedFrames
UserContentInjectedFramesTopFrame
    toEnum Int
k = Int -> UserContentInjectedFrames
AnotherUserContentInjectedFrames Int
k

instance P.Ord UserContentInjectedFrames where
    compare :: UserContentInjectedFrames -> UserContentInjectedFrames -> Ordering
compare UserContentInjectedFrames
a UserContentInjectedFrames
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (UserContentInjectedFrames -> Int
forall a. Enum a => a -> Int
P.fromEnum UserContentInjectedFrames
a) (UserContentInjectedFrames -> Int
forall a. Enum a => a -> Int
P.fromEnum UserContentInjectedFrames
b)

type instance O.ParentTypes UserContentInjectedFrames = '[]
instance O.HasParentTypes UserContentInjectedFrames

foreign import ccall "webkit_user_content_injected_frames_get_type" c_webkit_user_content_injected_frames_get_type :: 
    IO GType

instance B.Types.TypedObject UserContentInjectedFrames where
    glibType :: IO GType
glibType = IO GType
c_webkit_user_content_injected_frames_get_type

instance B.Types.BoxedEnum UserContentInjectedFrames

-- Enum UserContentFilterError
-- | /No description available in the introspection data./
-- 
-- /Since: 2.24/
data UserContentFilterError = 
      UserContentFilterErrorInvalidSource
    -- ^ The JSON source for a content filter is invalid.
    | UserContentFilterErrorNotFound
    -- ^ The requested content filter could not be found.
    | AnotherUserContentFilterError Int
    -- ^ Catch-all for unknown values
    deriving (Int -> UserContentFilterError -> ShowS
[UserContentFilterError] -> ShowS
UserContentFilterError -> String
(Int -> UserContentFilterError -> ShowS)
-> (UserContentFilterError -> String)
-> ([UserContentFilterError] -> ShowS)
-> Show UserContentFilterError
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [UserContentFilterError] -> ShowS
$cshowList :: [UserContentFilterError] -> ShowS
show :: UserContentFilterError -> String
$cshow :: UserContentFilterError -> String
showsPrec :: Int -> UserContentFilterError -> ShowS
$cshowsPrec :: Int -> UserContentFilterError -> ShowS
Show, UserContentFilterError -> UserContentFilterError -> Bool
(UserContentFilterError -> UserContentFilterError -> Bool)
-> (UserContentFilterError -> UserContentFilterError -> Bool)
-> Eq UserContentFilterError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: UserContentFilterError -> UserContentFilterError -> Bool
$c/= :: UserContentFilterError -> UserContentFilterError -> Bool
== :: UserContentFilterError -> UserContentFilterError -> Bool
$c== :: UserContentFilterError -> UserContentFilterError -> Bool
Eq)

instance P.Enum UserContentFilterError where
    fromEnum :: UserContentFilterError -> Int
fromEnum UserContentFilterError
UserContentFilterErrorInvalidSource = Int
0
    fromEnum UserContentFilterError
UserContentFilterErrorNotFound = Int
1
    fromEnum (AnotherUserContentFilterError Int
k) = Int
k

    toEnum :: Int -> UserContentFilterError
toEnum Int
0 = UserContentFilterError
UserContentFilterErrorInvalidSource
    toEnum Int
1 = UserContentFilterError
UserContentFilterErrorNotFound
    toEnum Int
k = Int -> UserContentFilterError
AnotherUserContentFilterError Int
k

instance P.Ord UserContentFilterError where
    compare :: UserContentFilterError -> UserContentFilterError -> Ordering
compare UserContentFilterError
a UserContentFilterError
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (UserContentFilterError -> Int
forall a. Enum a => a -> Int
P.fromEnum UserContentFilterError
a) (UserContentFilterError -> Int
forall a. Enum a => a -> Int
P.fromEnum UserContentFilterError
b)

instance GErrorClass UserContentFilterError where
    gerrorClassDomain :: UserContentFilterError -> Text
gerrorClassDomain UserContentFilterError
_ = Text
"WebKitUserContentFilterError"

-- | Catch exceptions of type `UserContentFilterError`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`.
catchUserContentFilterError ::
    IO a ->
    (UserContentFilterError -> GErrorMessage -> IO a) ->
    IO a
catchUserContentFilterError :: forall a. IO a -> (UserContentFilterError -> Text -> IO a) -> IO a
catchUserContentFilterError = IO a -> (UserContentFilterError -> Text -> IO a) -> IO a
forall err a.
GErrorClass err =>
IO a -> (err -> Text -> IO a) -> IO a
catchGErrorJustDomain

-- | Handle exceptions of type `UserContentFilterError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`.
handleUserContentFilterError ::
    (UserContentFilterError -> GErrorMessage -> IO a) ->
    IO a ->
    IO a
handleUserContentFilterError :: forall a. (UserContentFilterError -> Text -> IO a) -> IO a -> IO a
handleUserContentFilterError = (UserContentFilterError -> Text -> IO a) -> IO a -> IO a
forall err a.
GErrorClass err =>
(err -> Text -> IO a) -> IO a -> IO a
handleGErrorJustDomain

type instance O.ParentTypes UserContentFilterError = '[]
instance O.HasParentTypes UserContentFilterError

foreign import ccall "webkit_user_content_filter_error_get_type" c_webkit_user_content_filter_error_get_type :: 
    IO GType

instance B.Types.TypedObject UserContentFilterError where
    glibType :: IO GType
glibType = IO GType
c_webkit_user_content_filter_error_get_type

instance B.Types.BoxedEnum UserContentFilterError

-- Enum TLSErrorsPolicy
-- | Enum values used to denote the TLS errors policy.
data TLSErrorsPolicy = 
      TLSErrorsPolicyIgnore
    -- ^ Ignore TLS errors.
    | TLSErrorsPolicyFail
    -- ^ TLS errors will emit
    --   [loadFailedWithTlsErrors]("GI.WebKit2.Objects.WebView#g:signal:loadFailedWithTlsErrors") and, if the signal is handled,
    --   finish the load. In case the signal is not handled,
    --   [loadFailed]("GI.WebKit2.Objects.WebView#g:signal:loadFailed") is emitted before the load finishes.
    | AnotherTLSErrorsPolicy Int
    -- ^ Catch-all for unknown values
    deriving (Int -> TLSErrorsPolicy -> ShowS
[TLSErrorsPolicy] -> ShowS
TLSErrorsPolicy -> String
(Int -> TLSErrorsPolicy -> ShowS)
-> (TLSErrorsPolicy -> String)
-> ([TLSErrorsPolicy] -> ShowS)
-> Show TLSErrorsPolicy
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TLSErrorsPolicy] -> ShowS
$cshowList :: [TLSErrorsPolicy] -> ShowS
show :: TLSErrorsPolicy -> String
$cshow :: TLSErrorsPolicy -> String
showsPrec :: Int -> TLSErrorsPolicy -> ShowS
$cshowsPrec :: Int -> TLSErrorsPolicy -> ShowS
Show, TLSErrorsPolicy -> TLSErrorsPolicy -> Bool
(TLSErrorsPolicy -> TLSErrorsPolicy -> Bool)
-> (TLSErrorsPolicy -> TLSErrorsPolicy -> Bool)
-> Eq TLSErrorsPolicy
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TLSErrorsPolicy -> TLSErrorsPolicy -> Bool
$c/= :: TLSErrorsPolicy -> TLSErrorsPolicy -> Bool
== :: TLSErrorsPolicy -> TLSErrorsPolicy -> Bool
$c== :: TLSErrorsPolicy -> TLSErrorsPolicy -> Bool
Eq)

instance P.Enum TLSErrorsPolicy where
    fromEnum :: TLSErrorsPolicy -> Int
fromEnum TLSErrorsPolicy
TLSErrorsPolicyIgnore = Int
0
    fromEnum TLSErrorsPolicy
TLSErrorsPolicyFail = Int
1
    fromEnum (AnotherTLSErrorsPolicy Int
k) = Int
k

    toEnum :: Int -> TLSErrorsPolicy
toEnum Int
0 = TLSErrorsPolicy
TLSErrorsPolicyIgnore
    toEnum Int
1 = TLSErrorsPolicy
TLSErrorsPolicyFail
    toEnum Int
k = Int -> TLSErrorsPolicy
AnotherTLSErrorsPolicy Int
k

instance P.Ord TLSErrorsPolicy where
    compare :: TLSErrorsPolicy -> TLSErrorsPolicy -> Ordering
compare TLSErrorsPolicy
a TLSErrorsPolicy
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (TLSErrorsPolicy -> Int
forall a. Enum a => a -> Int
P.fromEnum TLSErrorsPolicy
a) (TLSErrorsPolicy -> Int
forall a. Enum a => a -> Int
P.fromEnum TLSErrorsPolicy
b)

type instance O.ParentTypes TLSErrorsPolicy = '[]
instance O.HasParentTypes TLSErrorsPolicy

foreign import ccall "webkit_tls_errors_policy_get_type" c_webkit_tls_errors_policy_get_type :: 
    IO GType

instance B.Types.TypedObject TLSErrorsPolicy where
    glibType :: IO GType
glibType = IO GType
c_webkit_tls_errors_policy_get_type

instance B.Types.BoxedEnum TLSErrorsPolicy

-- Enum SnapshotRegion
-- | Enum values used to specify the region from which to get a t'GI.WebKit2.Objects.WebView.WebView'
-- snapshot
data SnapshotRegion = 
      SnapshotRegionVisible
    -- ^ Specifies a snapshot only for the area that is
    -- visible in the webview
    | SnapshotRegionFullDocument
    -- ^ A snapshot of the entire document.
    | AnotherSnapshotRegion Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SnapshotRegion -> ShowS
[SnapshotRegion] -> ShowS
SnapshotRegion -> String
(Int -> SnapshotRegion -> ShowS)
-> (SnapshotRegion -> String)
-> ([SnapshotRegion] -> ShowS)
-> Show SnapshotRegion
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SnapshotRegion] -> ShowS
$cshowList :: [SnapshotRegion] -> ShowS
show :: SnapshotRegion -> String
$cshow :: SnapshotRegion -> String
showsPrec :: Int -> SnapshotRegion -> ShowS
$cshowsPrec :: Int -> SnapshotRegion -> ShowS
Show, SnapshotRegion -> SnapshotRegion -> Bool
(SnapshotRegion -> SnapshotRegion -> Bool)
-> (SnapshotRegion -> SnapshotRegion -> Bool) -> Eq SnapshotRegion
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SnapshotRegion -> SnapshotRegion -> Bool
$c/= :: SnapshotRegion -> SnapshotRegion -> Bool
== :: SnapshotRegion -> SnapshotRegion -> Bool
$c== :: SnapshotRegion -> SnapshotRegion -> Bool
Eq)

instance P.Enum SnapshotRegion where
    fromEnum :: SnapshotRegion -> Int
fromEnum SnapshotRegion
SnapshotRegionVisible = Int
0
    fromEnum SnapshotRegion
SnapshotRegionFullDocument = Int
1
    fromEnum (AnotherSnapshotRegion Int
k) = Int
k

    toEnum :: Int -> SnapshotRegion
toEnum Int
0 = SnapshotRegion
SnapshotRegionVisible
    toEnum Int
1 = SnapshotRegion
SnapshotRegionFullDocument
    toEnum Int
k = Int -> SnapshotRegion
AnotherSnapshotRegion Int
k

instance P.Ord SnapshotRegion where
    compare :: SnapshotRegion -> SnapshotRegion -> Ordering
compare SnapshotRegion
a SnapshotRegion
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (SnapshotRegion -> Int
forall a. Enum a => a -> Int
P.fromEnum SnapshotRegion
a) (SnapshotRegion -> Int
forall a. Enum a => a -> Int
P.fromEnum SnapshotRegion
b)

type instance O.ParentTypes SnapshotRegion = '[]
instance O.HasParentTypes SnapshotRegion

foreign import ccall "webkit_snapshot_region_get_type" c_webkit_snapshot_region_get_type :: 
    IO GType

instance B.Types.TypedObject SnapshotRegion where
    glibType :: IO GType
glibType = IO GType
c_webkit_snapshot_region_get_type

instance B.Types.BoxedEnum SnapshotRegion

-- Enum SnapshotError
-- | Enum values used to denote errors happening when creating snapshots of t'GI.WebKit2.Objects.WebView.WebView'
data SnapshotError = 
      SnapshotErrorCreate
    -- ^ An error occurred when creating a webpage snapshot.
    | AnotherSnapshotError Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SnapshotError -> ShowS
[SnapshotError] -> ShowS
SnapshotError -> String
(Int -> SnapshotError -> ShowS)
-> (SnapshotError -> String)
-> ([SnapshotError] -> ShowS)
-> Show SnapshotError
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SnapshotError] -> ShowS
$cshowList :: [SnapshotError] -> ShowS
show :: SnapshotError -> String
$cshow :: SnapshotError -> String
showsPrec :: Int -> SnapshotError -> ShowS
$cshowsPrec :: Int -> SnapshotError -> ShowS
Show, SnapshotError -> SnapshotError -> Bool
(SnapshotError -> SnapshotError -> Bool)
-> (SnapshotError -> SnapshotError -> Bool) -> Eq SnapshotError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SnapshotError -> SnapshotError -> Bool
$c/= :: SnapshotError -> SnapshotError -> Bool
== :: SnapshotError -> SnapshotError -> Bool
$c== :: SnapshotError -> SnapshotError -> Bool
Eq)

instance P.Enum SnapshotError where
    fromEnum :: SnapshotError -> Int
fromEnum SnapshotError
SnapshotErrorCreate = Int
799
    fromEnum (AnotherSnapshotError Int
k) = Int
k

    toEnum :: Int -> SnapshotError
toEnum Int
799 = SnapshotError
SnapshotErrorCreate
    toEnum Int
k = Int -> SnapshotError
AnotherSnapshotError Int
k

instance P.Ord SnapshotError where
    compare :: SnapshotError -> SnapshotError -> Ordering
compare SnapshotError
a SnapshotError
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (SnapshotError -> Int
forall a. Enum a => a -> Int
P.fromEnum SnapshotError
a) (SnapshotError -> Int
forall a. Enum a => a -> Int
P.fromEnum SnapshotError
b)

instance GErrorClass SnapshotError where
    gerrorClassDomain :: SnapshotError -> Text
gerrorClassDomain SnapshotError
_ = Text
"WebKitSnapshotError"

-- | Catch exceptions of type `SnapshotError`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`.
catchSnapshotError ::
    IO a ->
    (SnapshotError -> GErrorMessage -> IO a) ->
    IO a
catchSnapshotError :: forall a. IO a -> (SnapshotError -> Text -> IO a) -> IO a
catchSnapshotError = IO a -> (SnapshotError -> Text -> IO a) -> IO a
forall err a.
GErrorClass err =>
IO a -> (err -> Text -> IO a) -> IO a
catchGErrorJustDomain

-- | Handle exceptions of type `SnapshotError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`.
handleSnapshotError ::
    (SnapshotError -> GErrorMessage -> IO a) ->
    IO a ->
    IO a
handleSnapshotError :: forall a. (SnapshotError -> Text -> IO a) -> IO a -> IO a
handleSnapshotError = (SnapshotError -> Text -> IO a) -> IO a -> IO a
forall err a.
GErrorClass err =>
(err -> Text -> IO a) -> IO a -> IO a
handleGErrorJustDomain

type instance O.ParentTypes SnapshotError = '[]
instance O.HasParentTypes SnapshotError

foreign import ccall "webkit_snapshot_error_get_type" c_webkit_snapshot_error_get_type :: 
    IO GType

instance B.Types.TypedObject SnapshotError where
    glibType :: IO GType
glibType = IO GType
c_webkit_snapshot_error_get_type

instance B.Types.BoxedEnum SnapshotError

-- Enum ScriptDialogType
-- | Enum values used for determining the type of t'GI.WebKit2.Structs.ScriptDialog.ScriptDialog'
data ScriptDialogType = 
      ScriptDialogTypeAlert
    -- ^ Alert script dialog, used to show a
    -- message to the user.
    | ScriptDialogTypeConfirm
    -- ^ Confirm script dialog, used to ask
    -- confirmation to the user.
    | ScriptDialogTypePrompt
    -- ^ Prompt script dialog, used to ask
    -- information to the user.
    | ScriptDialogTypeBeforeUnloadConfirm
    -- ^ Before unload confirm dialog,
    -- used to ask confirmation to leave the current page to the user. Since 2.12
    | AnotherScriptDialogType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ScriptDialogType -> ShowS
[ScriptDialogType] -> ShowS
ScriptDialogType -> String
(Int -> ScriptDialogType -> ShowS)
-> (ScriptDialogType -> String)
-> ([ScriptDialogType] -> ShowS)
-> Show ScriptDialogType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ScriptDialogType] -> ShowS
$cshowList :: [ScriptDialogType] -> ShowS
show :: ScriptDialogType -> String
$cshow :: ScriptDialogType -> String
showsPrec :: Int -> ScriptDialogType -> ShowS
$cshowsPrec :: Int -> ScriptDialogType -> ShowS
Show, ScriptDialogType -> ScriptDialogType -> Bool
(ScriptDialogType -> ScriptDialogType -> Bool)
-> (ScriptDialogType -> ScriptDialogType -> Bool)
-> Eq ScriptDialogType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ScriptDialogType -> ScriptDialogType -> Bool
$c/= :: ScriptDialogType -> ScriptDialogType -> Bool
== :: ScriptDialogType -> ScriptDialogType -> Bool
$c== :: ScriptDialogType -> ScriptDialogType -> Bool
Eq)

instance P.Enum ScriptDialogType where
    fromEnum :: ScriptDialogType -> Int
fromEnum ScriptDialogType
ScriptDialogTypeAlert = Int
0
    fromEnum ScriptDialogType
ScriptDialogTypeConfirm = Int
1
    fromEnum ScriptDialogType
ScriptDialogTypePrompt = Int
2
    fromEnum ScriptDialogType
ScriptDialogTypeBeforeUnloadConfirm = Int
3
    fromEnum (AnotherScriptDialogType Int
k) = Int
k

    toEnum :: Int -> ScriptDialogType
toEnum Int
0 = ScriptDialogType
ScriptDialogTypeAlert
    toEnum Int
1 = ScriptDialogType
ScriptDialogTypeConfirm
    toEnum Int
2 = ScriptDialogType
ScriptDialogTypePrompt
    toEnum Int
3 = ScriptDialogType
ScriptDialogTypeBeforeUnloadConfirm
    toEnum Int
k = Int -> ScriptDialogType
AnotherScriptDialogType Int
k

instance P.Ord ScriptDialogType where
    compare :: ScriptDialogType -> ScriptDialogType -> Ordering
compare ScriptDialogType
a ScriptDialogType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (ScriptDialogType -> Int
forall a. Enum a => a -> Int
P.fromEnum ScriptDialogType
a) (ScriptDialogType -> Int
forall a. Enum a => a -> Int
P.fromEnum ScriptDialogType
b)

type instance O.ParentTypes ScriptDialogType = '[]
instance O.HasParentTypes ScriptDialogType

foreign import ccall "webkit_script_dialog_type_get_type" c_webkit_script_dialog_type_get_type :: 
    IO GType

instance B.Types.TypedObject ScriptDialogType where
    glibType :: IO GType
glibType = IO GType
c_webkit_script_dialog_type_get_type

instance B.Types.BoxedEnum ScriptDialogType

-- Enum SaveMode
-- | Enum values to specify the different ways in which a t'GI.WebKit2.Objects.WebView.WebView'
-- can save its current web page into a self-contained file.
data SaveMode = 
      SaveModeMhtml
    -- ^ Save the current page using the MHTML format.
    | AnotherSaveMode Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SaveMode -> ShowS
[SaveMode] -> ShowS
SaveMode -> String
(Int -> SaveMode -> ShowS)
-> (SaveMode -> String) -> ([SaveMode] -> ShowS) -> Show SaveMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SaveMode] -> ShowS
$cshowList :: [SaveMode] -> ShowS
show :: SaveMode -> String
$cshow :: SaveMode -> String
showsPrec :: Int -> SaveMode -> ShowS
$cshowsPrec :: Int -> SaveMode -> ShowS
Show, SaveMode -> SaveMode -> Bool
(SaveMode -> SaveMode -> Bool)
-> (SaveMode -> SaveMode -> Bool) -> Eq SaveMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SaveMode -> SaveMode -> Bool
$c/= :: SaveMode -> SaveMode -> Bool
== :: SaveMode -> SaveMode -> Bool
$c== :: SaveMode -> SaveMode -> Bool
Eq)

instance P.Enum SaveMode where
    fromEnum :: SaveMode -> Int
fromEnum SaveMode
SaveModeMhtml = Int
0
    fromEnum (AnotherSaveMode Int
k) = Int
k

    toEnum :: Int -> SaveMode
toEnum Int
0 = SaveMode
SaveModeMhtml
    toEnum Int
k = Int -> SaveMode
AnotherSaveMode Int
k

instance P.Ord SaveMode where
    compare :: SaveMode -> SaveMode -> Ordering
compare SaveMode
a SaveMode
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (SaveMode -> Int
forall a. Enum a => a -> Int
P.fromEnum SaveMode
a) (SaveMode -> Int
forall a. Enum a => a -> Int
P.fromEnum SaveMode
b)

type instance O.ParentTypes SaveMode = '[]
instance O.HasParentTypes SaveMode

foreign import ccall "webkit_save_mode_get_type" c_webkit_save_mode_get_type :: 
    IO GType

instance B.Types.TypedObject SaveMode where
    glibType :: IO GType
glibType = IO GType
c_webkit_save_mode_get_type

instance B.Types.BoxedEnum SaveMode

-- Enum ProcessModel
-- | Enum values used for determining the t'GI.WebKit2.Objects.WebContext.WebContext' process model.
-- 
-- /Since: 2.4/
data ProcessModel = 
      ProcessModelSharedSecondaryProcess
    -- ^ Deprecated 2.26.
    | ProcessModelMultipleSecondaryProcesses
    -- ^ Use one process
    --   for each t'GI.WebKit2.Objects.WebView.WebView', while still allowing for some of them to
    --   share a process in certain situations. The main advantage
    --   of this process model is that the rendering process for a web view
    --   can crash while the rest of the views keep working normally. This
    --   process model is indicated for applications which may use a number
    --   of web views and the content of in each must not interfere with the
    --   rest — for example a full-fledged web browser with support for
    --   multiple tabs.
    | AnotherProcessModel Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ProcessModel -> ShowS
[ProcessModel] -> ShowS
ProcessModel -> String
(Int -> ProcessModel -> ShowS)
-> (ProcessModel -> String)
-> ([ProcessModel] -> ShowS)
-> Show ProcessModel
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ProcessModel] -> ShowS
$cshowList :: [ProcessModel] -> ShowS
show :: ProcessModel -> String
$cshow :: ProcessModel -> String
showsPrec :: Int -> ProcessModel -> ShowS
$cshowsPrec :: Int -> ProcessModel -> ShowS
Show, ProcessModel -> ProcessModel -> Bool
(ProcessModel -> ProcessModel -> Bool)
-> (ProcessModel -> ProcessModel -> Bool) -> Eq ProcessModel
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ProcessModel -> ProcessModel -> Bool
$c/= :: ProcessModel -> ProcessModel -> Bool
== :: ProcessModel -> ProcessModel -> Bool
$c== :: ProcessModel -> ProcessModel -> Bool
Eq)

instance P.Enum ProcessModel where
    fromEnum :: ProcessModel -> Int
fromEnum ProcessModel
ProcessModelSharedSecondaryProcess = Int
0
    fromEnum ProcessModel
ProcessModelMultipleSecondaryProcesses = Int
1
    fromEnum (AnotherProcessModel Int
k) = Int
k

    toEnum :: Int -> ProcessModel
toEnum Int
0 = ProcessModel
ProcessModelSharedSecondaryProcess
    toEnum Int
1 = ProcessModel
ProcessModelMultipleSecondaryProcesses
    toEnum Int
k = Int -> ProcessModel
AnotherProcessModel Int
k

instance P.Ord ProcessModel where
    compare :: ProcessModel -> ProcessModel -> Ordering
compare ProcessModel
a ProcessModel
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (ProcessModel -> Int
forall a. Enum a => a -> Int
P.fromEnum ProcessModel
a) (ProcessModel -> Int
forall a. Enum a => a -> Int
P.fromEnum ProcessModel
b)

type instance O.ParentTypes ProcessModel = '[]
instance O.HasParentTypes ProcessModel

foreign import ccall "webkit_process_model_get_type" c_webkit_process_model_get_type :: 
    IO GType

instance B.Types.TypedObject ProcessModel where
    glibType :: IO GType
glibType = IO GType
c_webkit_process_model_get_type

instance B.Types.BoxedEnum ProcessModel

-- Enum PrintOperationResponse
-- | Enum values representing the response of the print dialog shown with
-- 'GI.WebKit2.Objects.PrintOperation.printOperationRunDialog'.
data PrintOperationResponse = 
      PrintOperationResponsePrint
    -- ^ Print button was clicked in print dialog
    | PrintOperationResponseCancel
    -- ^ Print dialog was cancelled
    | AnotherPrintOperationResponse Int
    -- ^ Catch-all for unknown values
    deriving (Int -> PrintOperationResponse -> ShowS
[PrintOperationResponse] -> ShowS
PrintOperationResponse -> String
(Int -> PrintOperationResponse -> ShowS)
-> (PrintOperationResponse -> String)
-> ([PrintOperationResponse] -> ShowS)
-> Show PrintOperationResponse
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PrintOperationResponse] -> ShowS
$cshowList :: [PrintOperationResponse] -> ShowS
show :: PrintOperationResponse -> String
$cshow :: PrintOperationResponse -> String
showsPrec :: Int -> PrintOperationResponse -> ShowS
$cshowsPrec :: Int -> PrintOperationResponse -> ShowS
Show, PrintOperationResponse -> PrintOperationResponse -> Bool
(PrintOperationResponse -> PrintOperationResponse -> Bool)
-> (PrintOperationResponse -> PrintOperationResponse -> Bool)
-> Eq PrintOperationResponse
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PrintOperationResponse -> PrintOperationResponse -> Bool
$c/= :: PrintOperationResponse -> PrintOperationResponse -> Bool
== :: PrintOperationResponse -> PrintOperationResponse -> Bool
$c== :: PrintOperationResponse -> PrintOperationResponse -> Bool
Eq)

instance P.Enum PrintOperationResponse where
    fromEnum :: PrintOperationResponse -> Int
fromEnum PrintOperationResponse
PrintOperationResponsePrint = Int
0
    fromEnum PrintOperationResponse
PrintOperationResponseCancel = Int
1
    fromEnum (AnotherPrintOperationResponse Int
k) = Int
k

    toEnum :: Int -> PrintOperationResponse
toEnum Int
0 = PrintOperationResponse
PrintOperationResponsePrint
    toEnum Int
1 = PrintOperationResponse
PrintOperationResponseCancel
    toEnum Int
k = Int -> PrintOperationResponse
AnotherPrintOperationResponse Int
k

instance P.Ord PrintOperationResponse where
    compare :: PrintOperationResponse -> PrintOperationResponse -> Ordering
compare PrintOperationResponse
a PrintOperationResponse
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (PrintOperationResponse -> Int
forall a. Enum a => a -> Int
P.fromEnum PrintOperationResponse
a) (PrintOperationResponse -> Int
forall a. Enum a => a -> Int
P.fromEnum PrintOperationResponse
b)

type instance O.ParentTypes PrintOperationResponse = '[]
instance O.HasParentTypes PrintOperationResponse

foreign import ccall "webkit_print_operation_response_get_type" c_webkit_print_operation_response_get_type :: 
    IO GType

instance B.Types.TypedObject PrintOperationResponse where
    glibType :: IO GType
glibType = IO GType
c_webkit_print_operation_response_get_type

instance B.Types.BoxedEnum PrintOperationResponse

-- Enum PrintError
-- | Enum values used to denote the various print errors.
data PrintError = 
      PrintErrorGeneral
    -- ^ Unspecified error during a print operation
    | PrintErrorPrinterNotFound
    -- ^ Selected printer cannot be found
    | PrintErrorInvalidPageRange
    -- ^ Invalid page range
    | AnotherPrintError Int
    -- ^ Catch-all for unknown values
    deriving (Int -> PrintError -> ShowS
[PrintError] -> ShowS
PrintError -> String
(Int -> PrintError -> ShowS)
-> (PrintError -> String)
-> ([PrintError] -> ShowS)
-> Show PrintError
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PrintError] -> ShowS
$cshowList :: [PrintError] -> ShowS
show :: PrintError -> String
$cshow :: PrintError -> String
showsPrec :: Int -> PrintError -> ShowS
$cshowsPrec :: Int -> PrintError -> ShowS
Show, PrintError -> PrintError -> Bool
(PrintError -> PrintError -> Bool)
-> (PrintError -> PrintError -> Bool) -> Eq PrintError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PrintError -> PrintError -> Bool
$c/= :: PrintError -> PrintError -> Bool
== :: PrintError -> PrintError -> Bool
$c== :: PrintError -> PrintError -> Bool
Eq)

instance P.Enum PrintError where
    fromEnum :: PrintError -> Int
fromEnum PrintError
PrintErrorGeneral = Int
599
    fromEnum PrintError
PrintErrorPrinterNotFound = Int
500
    fromEnum PrintError
PrintErrorInvalidPageRange = Int
501
    fromEnum (AnotherPrintError Int
k) = Int
k

    toEnum :: Int -> PrintError
toEnum Int
599 = PrintError
PrintErrorGeneral
    toEnum Int
500 = PrintError
PrintErrorPrinterNotFound
    toEnum Int
501 = PrintError
PrintErrorInvalidPageRange
    toEnum Int
k = Int -> PrintError
AnotherPrintError Int
k

instance P.Ord PrintError where
    compare :: PrintError -> PrintError -> Ordering
compare PrintError
a PrintError
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (PrintError -> Int
forall a. Enum a => a -> Int
P.fromEnum PrintError
a) (PrintError -> Int
forall a. Enum a => a -> Int
P.fromEnum PrintError
b)

instance GErrorClass PrintError where
    gerrorClassDomain :: PrintError -> Text
gerrorClassDomain PrintError
_ = Text
"WebKitPrintError"

-- | Catch exceptions of type `PrintError`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`.
catchPrintError ::
    IO a ->
    (PrintError -> GErrorMessage -> IO a) ->
    IO a
catchPrintError :: forall a. IO a -> (PrintError -> Text -> IO a) -> IO a
catchPrintError = IO a -> (PrintError -> Text -> IO a) -> IO a
forall err a.
GErrorClass err =>
IO a -> (err -> Text -> IO a) -> IO a
catchGErrorJustDomain

-- | Handle exceptions of type `PrintError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`.
handlePrintError ::
    (PrintError -> GErrorMessage -> IO a) ->
    IO a ->
    IO a
handlePrintError :: forall a. (PrintError -> Text -> IO a) -> IO a -> IO a
handlePrintError = (PrintError -> Text -> IO a) -> IO a -> IO a
forall err a.
GErrorClass err =>
(err -> Text -> IO a) -> IO a -> IO a
handleGErrorJustDomain

type instance O.ParentTypes PrintError = '[]
instance O.HasParentTypes PrintError

foreign import ccall "webkit_print_error_get_type" c_webkit_print_error_get_type :: 
    IO GType

instance B.Types.TypedObject PrintError where
    glibType :: IO GType
glibType = IO GType
c_webkit_print_error_get_type

instance B.Types.BoxedEnum PrintError

-- Enum PolicyError
-- | Enum values used to denote the various policy errors.
data PolicyError = 
      PolicyErrorFailed
    -- ^ Generic load failure due to policy error
    | PolicyErrorCannotShowMimeType
    -- ^ Load failure due to unsupported mime type
    | PolicyErrorCannotShowUri
    -- ^ Load failure due to URI that can not be shown
    | PolicyErrorFrameLoadInterruptedByPolicyChange
    -- ^ Load failure due to frame load interruption by policy change
    | PolicyErrorCannotUseRestrictedPort
    -- ^ Load failure due to port restriction
    | AnotherPolicyError Int
    -- ^ Catch-all for unknown values
    deriving (Int -> PolicyError -> ShowS
[PolicyError] -> ShowS
PolicyError -> String
(Int -> PolicyError -> ShowS)
-> (PolicyError -> String)
-> ([PolicyError] -> ShowS)
-> Show PolicyError
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PolicyError] -> ShowS
$cshowList :: [PolicyError] -> ShowS
show :: PolicyError -> String
$cshow :: PolicyError -> String
showsPrec :: Int -> PolicyError -> ShowS
$cshowsPrec :: Int -> PolicyError -> ShowS
Show, PolicyError -> PolicyError -> Bool
(PolicyError -> PolicyError -> Bool)
-> (PolicyError -> PolicyError -> Bool) -> Eq PolicyError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PolicyError -> PolicyError -> Bool
$c/= :: PolicyError -> PolicyError -> Bool
== :: PolicyError -> PolicyError -> Bool
$c== :: PolicyError -> PolicyError -> Bool
Eq)

instance P.Enum PolicyError where
    fromEnum :: PolicyError -> Int
fromEnum PolicyError
PolicyErrorFailed = Int
199
    fromEnum PolicyError
PolicyErrorCannotShowMimeType = Int
100
    fromEnum PolicyError
PolicyErrorCannotShowUri = Int
101
    fromEnum PolicyError
PolicyErrorFrameLoadInterruptedByPolicyChange = Int
102
    fromEnum PolicyError
PolicyErrorCannotUseRestrictedPort = Int
103
    fromEnum (AnotherPolicyError Int
k) = Int
k

    toEnum :: Int -> PolicyError
toEnum Int
199 = PolicyError
PolicyErrorFailed
    toEnum Int
100 = PolicyError
PolicyErrorCannotShowMimeType
    toEnum Int
101 = PolicyError
PolicyErrorCannotShowUri
    toEnum Int
102 = PolicyError
PolicyErrorFrameLoadInterruptedByPolicyChange
    toEnum Int
103 = PolicyError
PolicyErrorCannotUseRestrictedPort
    toEnum Int
k = Int -> PolicyError
AnotherPolicyError Int
k

instance P.Ord PolicyError where
    compare :: PolicyError -> PolicyError -> Ordering
compare PolicyError
a PolicyError
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (PolicyError -> Int
forall a. Enum a => a -> Int
P.fromEnum PolicyError
a) (PolicyError -> Int
forall a. Enum a => a -> Int
P.fromEnum PolicyError
b)

instance GErrorClass PolicyError where
    gerrorClassDomain :: PolicyError -> Text
gerrorClassDomain PolicyError
_ = Text
"WebKitPolicyError"

-- | Catch exceptions of type `PolicyError`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`.
catchPolicyError ::
    IO a ->
    (PolicyError -> GErrorMessage -> IO a) ->
    IO a
catchPolicyError :: forall a. IO a -> (PolicyError -> Text -> IO a) -> IO a
catchPolicyError = IO a -> (PolicyError -> Text -> IO a) -> IO a
forall err a.
GErrorClass err =>
IO a -> (err -> Text -> IO a) -> IO a
catchGErrorJustDomain

-- | Handle exceptions of type `PolicyError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`.
handlePolicyError ::
    (PolicyError -> GErrorMessage -> IO a) ->
    IO a ->
    IO a
handlePolicyError :: forall a. (PolicyError -> Text -> IO a) -> IO a -> IO a
handlePolicyError = (PolicyError -> Text -> IO a) -> IO a -> IO a
forall err a.
GErrorClass err =>
(err -> Text -> IO a) -> IO a -> IO a
handleGErrorJustDomain

type instance O.ParentTypes PolicyError = '[]
instance O.HasParentTypes PolicyError

foreign import ccall "webkit_policy_error_get_type" c_webkit_policy_error_get_type :: 
    IO GType

instance B.Types.TypedObject PolicyError where
    glibType :: IO GType
glibType = IO GType
c_webkit_policy_error_get_type

instance B.Types.BoxedEnum PolicyError

-- Enum PolicyDecisionType
-- | Enum values used for determining the type of a policy decision during
-- [decidePolicy]("GI.WebKit2.Objects.WebView#g:signal:decidePolicy").
data PolicyDecisionType = 
      PolicyDecisionTypeNavigationAction
    -- ^ This type of policy decision
    --   is requested when WebKit is about to navigate to a new page in either the
    --   main frame or a subframe. Acceptable policy decisions are either
    --   'GI.WebKit2.Objects.PolicyDecision.policyDecisionUse' or 'GI.WebKit2.Objects.PolicyDecision.policyDecisionIgnore'. This
    --   type of policy decision is always a t'GI.WebKit2.Objects.NavigationPolicyDecision.NavigationPolicyDecision'.
    | PolicyDecisionTypeNewWindowAction
    -- ^ This type of policy decision
    --   is requested when WebKit is about to create a new window. Acceptable policy
    --   decisions are either 'GI.WebKit2.Objects.PolicyDecision.policyDecisionUse' or
    --   'GI.WebKit2.Objects.PolicyDecision.policyDecisionIgnore'. This type of policy decision is always
    --   a t'GI.WebKit2.Objects.NavigationPolicyDecision.NavigationPolicyDecision'. These decisions are useful for implementing
    --   special actions for new windows, such as forcing the new window to open
    --   in a tab when a keyboard modifier is active or handling a special
    --   target attribute on <a> elements.
    | PolicyDecisionTypeResponse
    -- ^ This type of decision is used when WebKit has
    --   received a response for a network resource and is about to start the load.
    --   Note that these resources include all subresources of a page such as images
    --   and stylesheets as well as main documents. Appropriate policy responses to
    --   this decision are 'GI.WebKit2.Objects.PolicyDecision.policyDecisionUse', 'GI.WebKit2.Objects.PolicyDecision.policyDecisionIgnore',
    --   or 'GI.WebKit2.Objects.PolicyDecision.policyDecisionDownload'. This type of policy decision is always
    --   a t'GI.WebKit2.Objects.ResponsePolicyDecision.ResponsePolicyDecision'. This decision is useful for forcing
    --   some types of resources to be downloaded rather than rendered in the WebView
    --   or to block the transfer of resources entirely.
    | AnotherPolicyDecisionType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> PolicyDecisionType -> ShowS
[PolicyDecisionType] -> ShowS
PolicyDecisionType -> String
(Int -> PolicyDecisionType -> ShowS)
-> (PolicyDecisionType -> String)
-> ([PolicyDecisionType] -> ShowS)
-> Show PolicyDecisionType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PolicyDecisionType] -> ShowS
$cshowList :: [PolicyDecisionType] -> ShowS
show :: PolicyDecisionType -> String
$cshow :: PolicyDecisionType -> String
showsPrec :: Int -> PolicyDecisionType -> ShowS
$cshowsPrec :: Int -> PolicyDecisionType -> ShowS
Show, PolicyDecisionType -> PolicyDecisionType -> Bool
(PolicyDecisionType -> PolicyDecisionType -> Bool)
-> (PolicyDecisionType -> PolicyDecisionType -> Bool)
-> Eq PolicyDecisionType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PolicyDecisionType -> PolicyDecisionType -> Bool
$c/= :: PolicyDecisionType -> PolicyDecisionType -> Bool
== :: PolicyDecisionType -> PolicyDecisionType -> Bool
$c== :: PolicyDecisionType -> PolicyDecisionType -> Bool
Eq)

instance P.Enum PolicyDecisionType where
    fromEnum :: PolicyDecisionType -> Int
fromEnum PolicyDecisionType
PolicyDecisionTypeNavigationAction = Int
0
    fromEnum PolicyDecisionType
PolicyDecisionTypeNewWindowAction = Int
1
    fromEnum PolicyDecisionType
PolicyDecisionTypeResponse = Int
2
    fromEnum (AnotherPolicyDecisionType Int
k) = Int
k

    toEnum :: Int -> PolicyDecisionType
toEnum Int
0 = PolicyDecisionType
PolicyDecisionTypeNavigationAction
    toEnum Int
1 = PolicyDecisionType
PolicyDecisionTypeNewWindowAction
    toEnum Int
2 = PolicyDecisionType
PolicyDecisionTypeResponse
    toEnum Int
k = Int -> PolicyDecisionType
AnotherPolicyDecisionType Int
k

instance P.Ord PolicyDecisionType where
    compare :: PolicyDecisionType -> PolicyDecisionType -> Ordering
compare PolicyDecisionType
a PolicyDecisionType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (PolicyDecisionType -> Int
forall a. Enum a => a -> Int
P.fromEnum PolicyDecisionType
a) (PolicyDecisionType -> Int
forall a. Enum a => a -> Int
P.fromEnum PolicyDecisionType
b)

type instance O.ParentTypes PolicyDecisionType = '[]
instance O.HasParentTypes PolicyDecisionType

foreign import ccall "webkit_policy_decision_type_get_type" c_webkit_policy_decision_type_get_type :: 
    IO GType

instance B.Types.TypedObject PolicyDecisionType where
    glibType :: IO GType
glibType = IO GType
c_webkit_policy_decision_type_get_type

instance B.Types.BoxedEnum PolicyDecisionType

-- Enum PluginError
-- | Enum values used to denote the various plugin errors.
data PluginError = 
      PluginErrorFailed
    -- ^ Generic plugin load failure
    | PluginErrorCannotFindPlugin
    -- ^ Load failure due to missing plugin
    | PluginErrorCannotLoadPlugin
    -- ^ Load failure due to inability to load plugin
    | PluginErrorJavaUnavailable
    -- ^ Load failure due to missing Java support that is required to load plugin
    | PluginErrorConnectionCancelled
    -- ^ Load failure due to connection cancellation
    | PluginErrorWillHandleLoad
    -- ^ Load failure since plugin handles the load
    | AnotherPluginError Int
    -- ^ Catch-all for unknown values
    deriving (Int -> PluginError -> ShowS
[PluginError] -> ShowS
PluginError -> String
(Int -> PluginError -> ShowS)
-> (PluginError -> String)
-> ([PluginError] -> ShowS)
-> Show PluginError
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PluginError] -> ShowS
$cshowList :: [PluginError] -> ShowS
show :: PluginError -> String
$cshow :: PluginError -> String
showsPrec :: Int -> PluginError -> ShowS
$cshowsPrec :: Int -> PluginError -> ShowS
Show, PluginError -> PluginError -> Bool
(PluginError -> PluginError -> Bool)
-> (PluginError -> PluginError -> Bool) -> Eq PluginError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PluginError -> PluginError -> Bool
$c/= :: PluginError -> PluginError -> Bool
== :: PluginError -> PluginError -> Bool
$c== :: PluginError -> PluginError -> Bool
Eq)

instance P.Enum PluginError where
    fromEnum :: PluginError -> Int
fromEnum PluginError
PluginErrorFailed = Int
299
    fromEnum PluginError
PluginErrorCannotFindPlugin = Int
200
    fromEnum PluginError
PluginErrorCannotLoadPlugin = Int
201
    fromEnum PluginError
PluginErrorJavaUnavailable = Int
202
    fromEnum PluginError
PluginErrorConnectionCancelled = Int
203
    fromEnum PluginError
PluginErrorWillHandleLoad = Int
204
    fromEnum (AnotherPluginError Int
k) = Int
k

    toEnum :: Int -> PluginError
toEnum Int
299 = PluginError
PluginErrorFailed
    toEnum Int
200 = PluginError
PluginErrorCannotFindPlugin
    toEnum Int
201 = PluginError
PluginErrorCannotLoadPlugin
    toEnum Int
202 = PluginError
PluginErrorJavaUnavailable
    toEnum Int
203 = PluginError
PluginErrorConnectionCancelled
    toEnum Int
204 = PluginError
PluginErrorWillHandleLoad
    toEnum Int
k = Int -> PluginError
AnotherPluginError Int
k

instance P.Ord PluginError where
    compare :: PluginError -> PluginError -> Ordering
compare PluginError
a PluginError
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (PluginError -> Int
forall a. Enum a => a -> Int
P.fromEnum PluginError
a) (PluginError -> Int
forall a. Enum a => a -> Int
P.fromEnum PluginError
b)

instance GErrorClass PluginError where
    gerrorClassDomain :: PluginError -> Text
gerrorClassDomain PluginError
_ = Text
"WebKitPluginError"

-- | Catch exceptions of type `PluginError`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`.
catchPluginError ::
    IO a ->
    (PluginError -> GErrorMessage -> IO a) ->
    IO a
catchPluginError :: forall a. IO a -> (PluginError -> Text -> IO a) -> IO a
catchPluginError = IO a -> (PluginError -> Text -> IO a) -> IO a
forall err a.
GErrorClass err =>
IO a -> (err -> Text -> IO a) -> IO a
catchGErrorJustDomain

-- | Handle exceptions of type `PluginError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`.
handlePluginError ::
    (PluginError -> GErrorMessage -> IO a) ->
    IO a ->
    IO a
handlePluginError :: forall a. (PluginError -> Text -> IO a) -> IO a -> IO a
handlePluginError = (PluginError -> Text -> IO a) -> IO a -> IO a
forall err a.
GErrorClass err =>
(err -> Text -> IO a) -> IO a -> IO a
handleGErrorJustDomain

type instance O.ParentTypes PluginError = '[]
instance O.HasParentTypes PluginError

foreign import ccall "webkit_plugin_error_get_type" c_webkit_plugin_error_get_type :: 
    IO GType

instance B.Types.TypedObject PluginError where
    glibType :: IO GType
glibType = IO GType
c_webkit_plugin_error_get_type

instance B.Types.BoxedEnum PluginError

-- Enum NetworkProxyMode
-- | Enum values used to set the network proxy mode.
-- 
-- /Since: 2.16/
data NetworkProxyMode = 
      NetworkProxyModeDefault
    -- ^ Use the default proxy of the system.
    | NetworkProxyModeNoProxy
    -- ^ Do not use any proxy.
    | NetworkProxyModeCustom
    -- ^ Use custom proxy settings.
    | AnotherNetworkProxyMode Int
    -- ^ Catch-all for unknown values
    deriving (Int -> NetworkProxyMode -> ShowS
[NetworkProxyMode] -> ShowS
NetworkProxyMode -> String
(Int -> NetworkProxyMode -> ShowS)
-> (NetworkProxyMode -> String)
-> ([NetworkProxyMode] -> ShowS)
-> Show NetworkProxyMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [NetworkProxyMode] -> ShowS
$cshowList :: [NetworkProxyMode] -> ShowS
show :: NetworkProxyMode -> String
$cshow :: NetworkProxyMode -> String
showsPrec :: Int -> NetworkProxyMode -> ShowS
$cshowsPrec :: Int -> NetworkProxyMode -> ShowS
Show, NetworkProxyMode -> NetworkProxyMode -> Bool
(NetworkProxyMode -> NetworkProxyMode -> Bool)
-> (NetworkProxyMode -> NetworkProxyMode -> Bool)
-> Eq NetworkProxyMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NetworkProxyMode -> NetworkProxyMode -> Bool
$c/= :: NetworkProxyMode -> NetworkProxyMode -> Bool
== :: NetworkProxyMode -> NetworkProxyMode -> Bool
$c== :: NetworkProxyMode -> NetworkProxyMode -> Bool
Eq)

instance P.Enum NetworkProxyMode where
    fromEnum :: NetworkProxyMode -> Int
fromEnum NetworkProxyMode
NetworkProxyModeDefault = Int
0
    fromEnum NetworkProxyMode
NetworkProxyModeNoProxy = Int
1
    fromEnum NetworkProxyMode
NetworkProxyModeCustom = Int
2
    fromEnum (AnotherNetworkProxyMode Int
k) = Int
k

    toEnum :: Int -> NetworkProxyMode
toEnum Int
0 = NetworkProxyMode
NetworkProxyModeDefault
    toEnum Int
1 = NetworkProxyMode
NetworkProxyModeNoProxy
    toEnum Int
2 = NetworkProxyMode
NetworkProxyModeCustom
    toEnum Int
k = Int -> NetworkProxyMode
AnotherNetworkProxyMode Int
k

instance P.Ord NetworkProxyMode where
    compare :: NetworkProxyMode -> NetworkProxyMode -> Ordering
compare NetworkProxyMode
a NetworkProxyMode
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (NetworkProxyMode -> Int
forall a. Enum a => a -> Int
P.fromEnum NetworkProxyMode
a) (NetworkProxyMode -> Int
forall a. Enum a => a -> Int
P.fromEnum NetworkProxyMode
b)

type instance O.ParentTypes NetworkProxyMode = '[]
instance O.HasParentTypes NetworkProxyMode

foreign import ccall "webkit_network_proxy_mode_get_type" c_webkit_network_proxy_mode_get_type :: 
    IO GType

instance B.Types.TypedObject NetworkProxyMode where
    glibType :: IO GType
glibType = IO GType
c_webkit_network_proxy_mode_get_type

instance B.Types.BoxedEnum NetworkProxyMode

-- Enum NetworkError
-- | Enum values used to denote the various network errors.
data NetworkError = 
      NetworkErrorFailed
    -- ^ Generic load failure
    | NetworkErrorTransport
    -- ^ Load failure due to transport error
    | NetworkErrorUnknownProtocol
    -- ^ Load failure due to unknown protocol
    | NetworkErrorCancelled
    -- ^ Load failure due to cancellation
    | NetworkErrorFileDoesNotExist
    -- ^ Load failure due to missing file
    | AnotherNetworkError Int
    -- ^ Catch-all for unknown values
    deriving (Int -> NetworkError -> ShowS
[NetworkError] -> ShowS
NetworkError -> String
(Int -> NetworkError -> ShowS)
-> (NetworkError -> String)
-> ([NetworkError] -> ShowS)
-> Show NetworkError
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [NetworkError] -> ShowS
$cshowList :: [NetworkError] -> ShowS
show :: NetworkError -> String
$cshow :: NetworkError -> String
showsPrec :: Int -> NetworkError -> ShowS
$cshowsPrec :: Int -> NetworkError -> ShowS
Show, NetworkError -> NetworkError -> Bool
(NetworkError -> NetworkError -> Bool)
-> (NetworkError -> NetworkError -> Bool) -> Eq NetworkError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NetworkError -> NetworkError -> Bool
$c/= :: NetworkError -> NetworkError -> Bool
== :: NetworkError -> NetworkError -> Bool
$c== :: NetworkError -> NetworkError -> Bool
Eq)

instance P.Enum NetworkError where
    fromEnum :: NetworkError -> Int
fromEnum NetworkError
NetworkErrorFailed = Int
399
    fromEnum NetworkError
NetworkErrorTransport = Int
300
    fromEnum NetworkError
NetworkErrorUnknownProtocol = Int
301
    fromEnum NetworkError
NetworkErrorCancelled = Int
302
    fromEnum NetworkError
NetworkErrorFileDoesNotExist = Int
303
    fromEnum (AnotherNetworkError Int
k) = Int
k

    toEnum :: Int -> NetworkError
toEnum Int
399 = NetworkError
NetworkErrorFailed
    toEnum Int
300 = NetworkError
NetworkErrorTransport
    toEnum Int
301 = NetworkError
NetworkErrorUnknownProtocol
    toEnum Int
302 = NetworkError
NetworkErrorCancelled
    toEnum Int
303 = NetworkError
NetworkErrorFileDoesNotExist
    toEnum Int
k = Int -> NetworkError
AnotherNetworkError Int
k

instance P.Ord NetworkError where
    compare :: NetworkError -> NetworkError -> Ordering
compare NetworkError
a NetworkError
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (NetworkError -> Int
forall a. Enum a => a -> Int
P.fromEnum NetworkError
a) (NetworkError -> Int
forall a. Enum a => a -> Int
P.fromEnum NetworkError
b)

instance GErrorClass NetworkError where
    gerrorClassDomain :: NetworkError -> Text
gerrorClassDomain NetworkError
_ = Text
"WebKitNetworkError"

-- | Catch exceptions of type `NetworkError`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`.
catchNetworkError ::
    IO a ->
    (NetworkError -> GErrorMessage -> IO a) ->
    IO a
catchNetworkError :: forall a. IO a -> (NetworkError -> Text -> IO a) -> IO a
catchNetworkError = IO a -> (NetworkError -> Text -> IO a) -> IO a
forall err a.
GErrorClass err =>
IO a -> (err -> Text -> IO a) -> IO a
catchGErrorJustDomain

-- | Handle exceptions of type `NetworkError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`.
handleNetworkError ::
    (NetworkError -> GErrorMessage -> IO a) ->
    IO a ->
    IO a
handleNetworkError :: forall a. (NetworkError -> Text -> IO a) -> IO a -> IO a
handleNetworkError = (NetworkError -> Text -> IO a) -> IO a -> IO a
forall err a.
GErrorClass err =>
(err -> Text -> IO a) -> IO a -> IO a
handleGErrorJustDomain

type instance O.ParentTypes NetworkError = '[]
instance O.HasParentTypes NetworkError

foreign import ccall "webkit_network_error_get_type" c_webkit_network_error_get_type :: 
    IO GType

instance B.Types.TypedObject NetworkError where
    glibType :: IO GType
glibType = IO GType
c_webkit_network_error_get_type

instance B.Types.BoxedEnum NetworkError

-- Enum NavigationType
-- | Enum values used to denote the various navigation types.
data NavigationType = 
      NavigationTypeLinkClicked
    -- ^ The navigation was triggered by clicking a link.
    | NavigationTypeFormSubmitted
    -- ^ The navigation was triggered by submitting a form.
    | NavigationTypeBackForward
    -- ^ The navigation was triggered by navigating forward or backward.
    | NavigationTypeReload
    -- ^ The navigation was triggered by reloading.
    | NavigationTypeFormResubmitted
    -- ^ The navigation was triggered by resubmitting a form.
    | NavigationTypeOther
    -- ^ The navigation was triggered by some other action.
    | AnotherNavigationType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> NavigationType -> ShowS
[NavigationType] -> ShowS
NavigationType -> String
(Int -> NavigationType -> ShowS)
-> (NavigationType -> String)
-> ([NavigationType] -> ShowS)
-> Show NavigationType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [NavigationType] -> ShowS
$cshowList :: [NavigationType] -> ShowS
show :: NavigationType -> String
$cshow :: NavigationType -> String
showsPrec :: Int -> NavigationType -> ShowS
$cshowsPrec :: Int -> NavigationType -> ShowS
Show, NavigationType -> NavigationType -> Bool
(NavigationType -> NavigationType -> Bool)
-> (NavigationType -> NavigationType -> Bool) -> Eq NavigationType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NavigationType -> NavigationType -> Bool
$c/= :: NavigationType -> NavigationType -> Bool
== :: NavigationType -> NavigationType -> Bool
$c== :: NavigationType -> NavigationType -> Bool
Eq)

instance P.Enum NavigationType where
    fromEnum :: NavigationType -> Int
fromEnum NavigationType
NavigationTypeLinkClicked = Int
0
    fromEnum NavigationType
NavigationTypeFormSubmitted = Int
1
    fromEnum NavigationType
NavigationTypeBackForward = Int
2
    fromEnum NavigationType
NavigationTypeReload = Int
3
    fromEnum NavigationType
NavigationTypeFormResubmitted = Int
4
    fromEnum NavigationType
NavigationTypeOther = Int
5
    fromEnum (AnotherNavigationType Int
k) = Int
k

    toEnum :: Int -> NavigationType
toEnum Int
0 = NavigationType
NavigationTypeLinkClicked
    toEnum Int
1 = NavigationType
NavigationTypeFormSubmitted
    toEnum Int
2 = NavigationType
NavigationTypeBackForward
    toEnum Int
3 = NavigationType
NavigationTypeReload
    toEnum Int
4 = NavigationType
NavigationTypeFormResubmitted
    toEnum Int
5 = NavigationType
NavigationTypeOther
    toEnum Int
k = Int -> NavigationType
AnotherNavigationType Int
k

instance P.Ord NavigationType where
    compare :: NavigationType -> NavigationType -> Ordering
compare NavigationType
a NavigationType
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (NavigationType -> Int
forall a. Enum a => a -> Int
P.fromEnum NavigationType
a) (NavigationType -> Int
forall a. Enum a => a -> Int
P.fromEnum NavigationType
b)

type instance O.ParentTypes NavigationType = '[]
instance O.HasParentTypes NavigationType

foreign import ccall "webkit_navigation_type_get_type" c_webkit_navigation_type_get_type :: 
    IO GType

instance B.Types.TypedObject NavigationType where
    glibType :: IO GType
glibType = IO GType
c_webkit_navigation_type_get_type

instance B.Types.BoxedEnum NavigationType

-- Enum LoadEvent
-- | Enum values used to denote the different events that happen during a
-- t'GI.WebKit2.Objects.WebView.WebView' load operation.
data LoadEvent = 
      LoadEventStarted
    -- ^ A new load request has been made.
    -- No data has been received yet, empty structures have
    -- been allocated to perform the load; the load may still
    -- fail due to transport issues such as not being able to
    -- resolve a name, or connect to a port.
    | LoadEventRedirected
    -- ^ A provisional data source received
    -- a server redirect.
    | LoadEventCommitted
    -- ^ The content started arriving for a page load.
    -- The necessary transport requirements are established, and the
    -- load is being performed.
    | LoadEventFinished
    -- ^ Load completed. All resources are done loading
    -- or there was an error during the load operation.
    | AnotherLoadEvent Int
    -- ^ Catch-all for unknown values
    deriving (Int -> LoadEvent -> ShowS
[LoadEvent] -> ShowS
LoadEvent -> String
(Int -> LoadEvent -> ShowS)
-> (LoadEvent -> String)
-> ([LoadEvent] -> ShowS)
-> Show LoadEvent
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [LoadEvent] -> ShowS
$cshowList :: [LoadEvent] -> ShowS
show :: LoadEvent -> String
$cshow :: LoadEvent -> String
showsPrec :: Int -> LoadEvent -> ShowS
$cshowsPrec :: Int -> LoadEvent -> ShowS
Show, LoadEvent -> LoadEvent -> Bool
(LoadEvent -> LoadEvent -> Bool)
-> (LoadEvent -> LoadEvent -> Bool) -> Eq LoadEvent
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: LoadEvent -> LoadEvent -> Bool
$c/= :: LoadEvent -> LoadEvent -> Bool
== :: LoadEvent -> LoadEvent -> Bool
$c== :: LoadEvent -> LoadEvent -> Bool
Eq)

instance P.Enum LoadEvent where
    fromEnum :: LoadEvent -> Int
fromEnum LoadEvent
LoadEventStarted = Int
0
    fromEnum LoadEvent
LoadEventRedirected = Int
1
    fromEnum LoadEvent
LoadEventCommitted = Int
2
    fromEnum LoadEvent
LoadEventFinished = Int
3
    fromEnum (AnotherLoadEvent Int
k) = Int
k

    toEnum :: Int -> LoadEvent
toEnum Int
0 = LoadEvent
LoadEventStarted
    toEnum Int
1 = LoadEvent
LoadEventRedirected
    toEnum Int
2 = LoadEvent
LoadEventCommitted
    toEnum Int
3 = LoadEvent
LoadEventFinished
    toEnum Int
k = Int -> LoadEvent
AnotherLoadEvent Int
k

instance P.Ord LoadEvent where
    compare :: LoadEvent -> LoadEvent -> Ordering
compare LoadEvent
a LoadEvent
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (LoadEvent -> Int
forall a. Enum a => a -> Int
P.fromEnum LoadEvent
a) (LoadEvent -> Int
forall a. Enum a => a -> Int
P.fromEnum LoadEvent
b)

type instance O.ParentTypes LoadEvent = '[]
instance O.HasParentTypes LoadEvent

foreign import ccall "webkit_load_event_get_type" c_webkit_load_event_get_type :: 
    IO GType

instance B.Types.TypedObject LoadEvent where
    glibType :: IO GType
glibType = IO GType
c_webkit_load_event_get_type

instance B.Types.BoxedEnum LoadEvent

-- Enum JavascriptError
-- | Enum values used to denote errors happening when executing JavaScript
data JavascriptError = 
      JavascriptErrorFailed
    -- ^ An exception was raised in JavaScript execution
    | AnotherJavascriptError Int
    -- ^ Catch-all for unknown values
    deriving (Int -> JavascriptError -> ShowS
[JavascriptError] -> ShowS
JavascriptError -> String
(Int -> JavascriptError -> ShowS)
-> (JavascriptError -> String)
-> ([JavascriptError] -> ShowS)
-> Show JavascriptError
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [JavascriptError] -> ShowS
$cshowList :: [JavascriptError] -> ShowS
show :: JavascriptError -> String
$cshow :: JavascriptError -> String
showsPrec :: Int -> JavascriptError -> ShowS
$cshowsPrec :: Int -> JavascriptError -> ShowS
Show, JavascriptError -> JavascriptError -> Bool
(JavascriptError -> JavascriptError -> Bool)
-> (JavascriptError -> JavascriptError -> Bool)
-> Eq JavascriptError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: JavascriptError -> JavascriptError -> Bool
$c/= :: JavascriptError -> JavascriptError -> Bool
== :: JavascriptError -> JavascriptError -> Bool
$c== :: JavascriptError -> JavascriptError -> Bool
Eq)

instance P.Enum JavascriptError where
    fromEnum :: JavascriptError -> Int
fromEnum JavascriptError
JavascriptErrorFailed = Int
699
    fromEnum (AnotherJavascriptError Int
k) = Int
k

    toEnum :: Int -> JavascriptError
toEnum Int
699 = JavascriptError
JavascriptErrorFailed
    toEnum Int
k = Int -> JavascriptError
AnotherJavascriptError Int
k

instance P.Ord JavascriptError where
    compare :: JavascriptError -> JavascriptError -> Ordering
compare JavascriptError
a JavascriptError
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (JavascriptError -> Int
forall a. Enum a => a -> Int
P.fromEnum JavascriptError
a) (JavascriptError -> Int
forall a. Enum a => a -> Int
P.fromEnum JavascriptError
b)

instance GErrorClass JavascriptError where
    gerrorClassDomain :: JavascriptError -> Text
gerrorClassDomain JavascriptError
_ = Text
"WebKitJavascriptError"

-- | Catch exceptions of type `JavascriptError`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`.
catchJavascriptError ::
    IO a ->
    (JavascriptError -> GErrorMessage -> IO a) ->
    IO a
catchJavascriptError :: forall a. IO a -> (JavascriptError -> Text -> IO a) -> IO a
catchJavascriptError = IO a -> (JavascriptError -> Text -> IO a) -> IO a
forall err a.
GErrorClass err =>
IO a -> (err -> Text -> IO a) -> IO a
catchGErrorJustDomain

-- | Handle exceptions of type `JavascriptError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`.
handleJavascriptError ::
    (JavascriptError -> GErrorMessage -> IO a) ->
    IO a ->
    IO a
handleJavascriptError :: forall a. (JavascriptError -> Text -> IO a) -> IO a -> IO a
handleJavascriptError = (JavascriptError -> Text -> IO a) -> IO a -> IO a
forall err a.
GErrorClass err =>
(err -> Text -> IO a) -> IO a -> IO a
handleGErrorJustDomain

type instance O.ParentTypes JavascriptError = '[]
instance O.HasParentTypes JavascriptError

foreign import ccall "webkit_javascript_error_get_type" c_webkit_javascript_error_get_type :: 
    IO GType

instance B.Types.TypedObject JavascriptError where
    glibType :: IO GType
glibType = IO GType
c_webkit_javascript_error_get_type

instance B.Types.BoxedEnum JavascriptError

-- Enum InsecureContentEvent
-- | Enum values used to denote the different events which can trigger
-- the detection of insecure content.
data InsecureContentEvent = 
      InsecureContentEventRun
    -- ^ Insecure content has been detected by
    -- trying to execute any kind of logic (e.g. a script) from an
    -- untrusted source.
    | InsecureContentEventDisplayed
    -- ^ Insecure content has been
    -- detected by trying to display any kind of resource (e.g. an image)
    -- from an untrusted source.
    | AnotherInsecureContentEvent Int
    -- ^ Catch-all for unknown values
    deriving (Int -> InsecureContentEvent -> ShowS
[InsecureContentEvent] -> ShowS
InsecureContentEvent -> String
(Int -> InsecureContentEvent -> ShowS)
-> (InsecureContentEvent -> String)
-> ([InsecureContentEvent] -> ShowS)
-> Show InsecureContentEvent
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [InsecureContentEvent] -> ShowS
$cshowList :: [InsecureContentEvent] -> ShowS
show :: InsecureContentEvent -> String
$cshow :: InsecureContentEvent -> String
showsPrec :: Int -> InsecureContentEvent -> ShowS
$cshowsPrec :: Int -> InsecureContentEvent -> ShowS
Show, InsecureContentEvent -> InsecureContentEvent -> Bool
(InsecureContentEvent -> InsecureContentEvent -> Bool)
-> (InsecureContentEvent -> InsecureContentEvent -> Bool)
-> Eq InsecureContentEvent
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: InsecureContentEvent -> InsecureContentEvent -> Bool
$c/= :: InsecureContentEvent -> InsecureContentEvent -> Bool
== :: InsecureContentEvent -> InsecureContentEvent -> Bool
$c== :: InsecureContentEvent -> InsecureContentEvent -> Bool
Eq)

instance P.Enum InsecureContentEvent where
    fromEnum :: InsecureContentEvent -> Int
fromEnum InsecureContentEvent
InsecureContentEventRun = Int
0
    fromEnum InsecureContentEvent
InsecureContentEventDisplayed = Int
1
    fromEnum (AnotherInsecureContentEvent Int
k) = Int
k

    toEnum :: Int -> InsecureContentEvent
toEnum Int
0 = InsecureContentEvent
InsecureContentEventRun
    toEnum Int
1 = InsecureContentEvent
InsecureContentEventDisplayed
    toEnum Int
k = Int -> InsecureContentEvent
AnotherInsecureContentEvent Int
k

instance P.Ord InsecureContentEvent where
    compare :: InsecureContentEvent -> InsecureContentEvent -> Ordering
compare InsecureContentEvent
a InsecureContentEvent
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (InsecureContentEvent -> Int
forall a. Enum a => a -> Int
P.fromEnum InsecureContentEvent
a) (InsecureContentEvent -> Int
forall a. Enum a => a -> Int
P.fromEnum InsecureContentEvent
b)

type instance O.ParentTypes InsecureContentEvent = '[]
instance O.HasParentTypes InsecureContentEvent

foreign import ccall "webkit_insecure_content_event_get_type" c_webkit_insecure_content_event_get_type :: 
    IO GType

instance B.Types.TypedObject InsecureContentEvent where
    glibType :: IO GType
glibType = IO GType
c_webkit_insecure_content_event_get_type

instance B.Types.BoxedEnum InsecureContentEvent

-- Enum InputPurpose
-- | Enum values used to describe the primary purpose of the active editable element.
-- 
-- /Since: 2.28/
data InputPurpose = 
      InputPurposeFreeForm
    -- ^ Editable element expects any characters
    | InputPurposeDigits
    -- ^ Editable element expects digits
    | InputPurposeNumber
    -- ^ Editable element expects a number
    | InputPurposePhone
    -- ^ Editable element expects a telephone
    | InputPurposeUrl
    -- ^ Editable element expects a URL
    | InputPurposeEmail
    -- ^ Editable element expects an email
    | InputPurposePassword
    -- ^ Editable element expects a password
    | AnotherInputPurpose Int
    -- ^ Catch-all for unknown values
    deriving (Int -> InputPurpose -> ShowS
[InputPurpose] -> ShowS
InputPurpose -> String
(Int -> InputPurpose -> ShowS)
-> (InputPurpose -> String)
-> ([InputPurpose] -> ShowS)
-> Show InputPurpose
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [InputPurpose] -> ShowS
$cshowList :: [InputPurpose] -> ShowS
show :: InputPurpose -> String
$cshow :: InputPurpose -> String
showsPrec :: Int -> InputPurpose -> ShowS
$cshowsPrec :: Int -> InputPurpose -> ShowS
Show, InputPurpose -> InputPurpose -> Bool
(InputPurpose -> InputPurpose -> Bool)
-> (InputPurpose -> InputPurpose -> Bool) -> Eq InputPurpose
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: InputPurpose -> InputPurpose -> Bool
$c/= :: InputPurpose -> InputPurpose -> Bool
== :: InputPurpose -> InputPurpose -> Bool
$c== :: InputPurpose -> InputPurpose -> Bool
Eq)

instance P.Enum InputPurpose where
    fromEnum :: InputPurpose -> Int
fromEnum InputPurpose
InputPurposeFreeForm = Int
0
    fromEnum InputPurpose
InputPurposeDigits = Int
1
    fromEnum InputPurpose
InputPurposeNumber = Int
2
    fromEnum InputPurpose
InputPurposePhone = Int
3
    fromEnum InputPurpose
InputPurposeUrl = Int
4
    fromEnum InputPurpose
InputPurposeEmail = Int
5
    fromEnum InputPurpose
InputPurposePassword = Int
6
    fromEnum (AnotherInputPurpose Int
k) = Int
k

    toEnum :: Int -> InputPurpose
toEnum Int
0 = InputPurpose
InputPurposeFreeForm
    toEnum Int
1 = InputPurpose
InputPurposeDigits
    toEnum Int
2 = InputPurpose
InputPurposeNumber
    toEnum Int
3 = InputPurpose
InputPurposePhone
    toEnum Int
4 = InputPurpose
InputPurposeUrl
    toEnum Int
5 = InputPurpose
InputPurposeEmail
    toEnum Int
6 = InputPurpose
InputPurposePassword
    toEnum Int
k = Int -> InputPurpose
AnotherInputPurpose Int
k

instance P.Ord InputPurpose where
    compare :: InputPurpose -> InputPurpose -> Ordering
compare InputPurpose
a InputPurpose
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (InputPurpose -> Int
forall a. Enum a => a -> Int
P.fromEnum InputPurpose
a) (InputPurpose -> Int
forall a. Enum a => a -> Int
P.fromEnum InputPurpose
b)

type instance O.ParentTypes InputPurpose = '[]
instance O.HasParentTypes InputPurpose

foreign import ccall "webkit_input_purpose_get_type" c_webkit_input_purpose_get_type :: 
    IO GType

instance B.Types.TypedObject InputPurpose where
    glibType :: IO GType
glibType = IO GType
c_webkit_input_purpose_get_type

instance B.Types.BoxedEnum InputPurpose

-- Enum HardwareAccelerationPolicy
-- | Enum values used for determining the hardware acceleration policy.
-- 
-- /Since: 2.16/
data HardwareAccelerationPolicy = 
      HardwareAccelerationPolicyOnDemand
    -- ^ Hardware acceleration is enabled\/disabled as request by web contents.
    | HardwareAccelerationPolicyAlways
    -- ^ Hardware acceleration is always enabled, even for websites not requesting it.
    | HardwareAccelerationPolicyNever
    -- ^ Hardware acceleration is always disabled, even for websites requesting it.
    | AnotherHardwareAccelerationPolicy Int
    -- ^ Catch-all for unknown values
    deriving (Int -> HardwareAccelerationPolicy -> ShowS
[HardwareAccelerationPolicy] -> ShowS
HardwareAccelerationPolicy -> String
(Int -> HardwareAccelerationPolicy -> ShowS)
-> (HardwareAccelerationPolicy -> String)
-> ([HardwareAccelerationPolicy] -> ShowS)
-> Show HardwareAccelerationPolicy
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [HardwareAccelerationPolicy] -> ShowS
$cshowList :: [HardwareAccelerationPolicy] -> ShowS
show :: HardwareAccelerationPolicy -> String
$cshow :: HardwareAccelerationPolicy -> String
showsPrec :: Int -> HardwareAccelerationPolicy -> ShowS
$cshowsPrec :: Int -> HardwareAccelerationPolicy -> ShowS
Show, HardwareAccelerationPolicy -> HardwareAccelerationPolicy -> Bool
(HardwareAccelerationPolicy -> HardwareAccelerationPolicy -> Bool)
-> (HardwareAccelerationPolicy
    -> HardwareAccelerationPolicy -> Bool)
-> Eq HardwareAccelerationPolicy
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: HardwareAccelerationPolicy -> HardwareAccelerationPolicy -> Bool
$c/= :: HardwareAccelerationPolicy -> HardwareAccelerationPolicy -> Bool
== :: HardwareAccelerationPolicy -> HardwareAccelerationPolicy -> Bool
$c== :: HardwareAccelerationPolicy -> HardwareAccelerationPolicy -> Bool
Eq)

instance P.Enum HardwareAccelerationPolicy where
    fromEnum :: HardwareAccelerationPolicy -> Int
fromEnum HardwareAccelerationPolicy
HardwareAccelerationPolicyOnDemand = Int
0
    fromEnum HardwareAccelerationPolicy
HardwareAccelerationPolicyAlways = Int
1
    fromEnum HardwareAccelerationPolicy
HardwareAccelerationPolicyNever = Int
2
    fromEnum (AnotherHardwareAccelerationPolicy Int
k) = Int
k

    toEnum :: Int -> HardwareAccelerationPolicy
toEnum Int
0 = HardwareAccelerationPolicy
HardwareAccelerationPolicyOnDemand
    toEnum Int
1 = HardwareAccelerationPolicy
HardwareAccelerationPolicyAlways
    toEnum Int
2 = HardwareAccelerationPolicy
HardwareAccelerationPolicyNever
    toEnum Int
k = Int -> HardwareAccelerationPolicy
AnotherHardwareAccelerationPolicy Int
k

instance P.Ord HardwareAccelerationPolicy where
    compare :: HardwareAccelerationPolicy
-> HardwareAccelerationPolicy -> Ordering
compare HardwareAccelerationPolicy
a HardwareAccelerationPolicy
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (HardwareAccelerationPolicy -> Int
forall a. Enum a => a -> Int
P.fromEnum HardwareAccelerationPolicy
a) (HardwareAccelerationPolicy -> Int
forall a. Enum a => a -> Int
P.fromEnum HardwareAccelerationPolicy
b)

type instance O.ParentTypes HardwareAccelerationPolicy = '[]
instance O.HasParentTypes HardwareAccelerationPolicy

foreign import ccall "webkit_hardware_acceleration_policy_get_type" c_webkit_hardware_acceleration_policy_get_type :: 
    IO GType

instance B.Types.TypedObject HardwareAccelerationPolicy where
    glibType :: IO GType
glibType = IO GType
c_webkit_hardware_acceleration_policy_get_type

instance B.Types.BoxedEnum HardwareAccelerationPolicy

-- Enum FaviconDatabaseError
-- | Enum values used to denote the various errors related to the t'GI.WebKit2.Objects.FaviconDatabase.FaviconDatabase'.
data FaviconDatabaseError = 
      FaviconDatabaseErrorNotInitialized
    -- ^ The t'GI.WebKit2.Objects.FaviconDatabase.FaviconDatabase' has not been initialized yet
    | FaviconDatabaseErrorFaviconNotFound
    -- ^ There is not an icon available for the requested URL
    | FaviconDatabaseErrorFaviconUnknown
    -- ^ There might be an icon for the requested URL, but its data is unknown at the moment
    | AnotherFaviconDatabaseError Int
    -- ^ Catch-all for unknown values
    deriving (Int -> FaviconDatabaseError -> ShowS
[FaviconDatabaseError] -> ShowS
FaviconDatabaseError -> String
(Int -> FaviconDatabaseError -> ShowS)
-> (FaviconDatabaseError -> String)
-> ([FaviconDatabaseError] -> ShowS)
-> Show FaviconDatabaseError
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FaviconDatabaseError] -> ShowS
$cshowList :: [FaviconDatabaseError] -> ShowS
show :: FaviconDatabaseError -> String
$cshow :: FaviconDatabaseError -> String
showsPrec :: Int -> FaviconDatabaseError -> ShowS
$cshowsPrec :: Int -> FaviconDatabaseError -> ShowS
Show, FaviconDatabaseError -> FaviconDatabaseError -> Bool
(FaviconDatabaseError -> FaviconDatabaseError -> Bool)
-> (FaviconDatabaseError -> FaviconDatabaseError -> Bool)
-> Eq FaviconDatabaseError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FaviconDatabaseError -> FaviconDatabaseError -> Bool
$c/= :: FaviconDatabaseError -> FaviconDatabaseError -> Bool
== :: FaviconDatabaseError -> FaviconDatabaseError -> Bool
$c== :: FaviconDatabaseError -> FaviconDatabaseError -> Bool
Eq)

instance P.Enum FaviconDatabaseError where
    fromEnum :: FaviconDatabaseError -> Int
fromEnum FaviconDatabaseError
FaviconDatabaseErrorNotInitialized = Int
0
    fromEnum FaviconDatabaseError
FaviconDatabaseErrorFaviconNotFound = Int
1
    fromEnum FaviconDatabaseError
FaviconDatabaseErrorFaviconUnknown = Int
2
    fromEnum (AnotherFaviconDatabaseError Int
k) = Int
k

    toEnum :: Int -> FaviconDatabaseError
toEnum Int
0 = FaviconDatabaseError
FaviconDatabaseErrorNotInitialized
    toEnum Int
1 = FaviconDatabaseError
FaviconDatabaseErrorFaviconNotFound
    toEnum Int
2 = FaviconDatabaseError
FaviconDatabaseErrorFaviconUnknown
    toEnum Int
k = Int -> FaviconDatabaseError
AnotherFaviconDatabaseError Int
k

instance P.Ord FaviconDatabaseError where
    compare :: FaviconDatabaseError -> FaviconDatabaseError -> Ordering
compare FaviconDatabaseError
a FaviconDatabaseError
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (FaviconDatabaseError -> Int
forall a. Enum a => a -> Int
P.fromEnum FaviconDatabaseError
a) (FaviconDatabaseError -> Int
forall a. Enum a => a -> Int
P.fromEnum FaviconDatabaseError
b)

instance GErrorClass FaviconDatabaseError where
    gerrorClassDomain :: FaviconDatabaseError -> Text
gerrorClassDomain FaviconDatabaseError
_ = Text
"WebKitFaviconDatabaseError"

-- | Catch exceptions of type `FaviconDatabaseError`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`.
catchFaviconDatabaseError ::
    IO a ->
    (FaviconDatabaseError -> GErrorMessage -> IO a) ->
    IO a
catchFaviconDatabaseError :: forall a. IO a -> (FaviconDatabaseError -> Text -> IO a) -> IO a
catchFaviconDatabaseError = IO a -> (FaviconDatabaseError -> Text -> IO a) -> IO a
forall err a.
GErrorClass err =>
IO a -> (err -> Text -> IO a) -> IO a
catchGErrorJustDomain

-- | Handle exceptions of type `FaviconDatabaseError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`.
handleFaviconDatabaseError ::
    (FaviconDatabaseError -> GErrorMessage -> IO a) ->
    IO a ->
    IO a
handleFaviconDatabaseError :: forall a. (FaviconDatabaseError -> Text -> IO a) -> IO a -> IO a
handleFaviconDatabaseError = (FaviconDatabaseError -> Text -> IO a) -> IO a -> IO a
forall err a.
GErrorClass err =>
(err -> Text -> IO a) -> IO a -> IO a
handleGErrorJustDomain

type instance O.ParentTypes FaviconDatabaseError = '[]
instance O.HasParentTypes FaviconDatabaseError

foreign import ccall "webkit_favicon_database_error_get_type" c_webkit_favicon_database_error_get_type :: 
    IO GType

instance B.Types.TypedObject FaviconDatabaseError where
    glibType :: IO GType
glibType = IO GType
c_webkit_favicon_database_error_get_type

instance B.Types.BoxedEnum FaviconDatabaseError

-- Enum DownloadError
-- | Enum values used to denote the various download errors.
data DownloadError = 
      DownloadErrorNetwork
    -- ^ Download failure due to network error
    | DownloadErrorCancelledByUser
    -- ^ Download was cancelled by user
    | DownloadErrorDestination
    -- ^ Download failure due to destination error
    | AnotherDownloadError Int
    -- ^ Catch-all for unknown values
    deriving (Int -> DownloadError -> ShowS
[DownloadError] -> ShowS
DownloadError -> String
(Int -> DownloadError -> ShowS)
-> (DownloadError -> String)
-> ([DownloadError] -> ShowS)
-> Show DownloadError
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DownloadError] -> ShowS
$cshowList :: [DownloadError] -> ShowS
show :: DownloadError -> String
$cshow :: DownloadError -> String
showsPrec :: Int -> DownloadError -> ShowS
$cshowsPrec :: Int -> DownloadError -> ShowS
Show, DownloadError -> DownloadError -> Bool
(DownloadError -> DownloadError -> Bool)
-> (DownloadError -> DownloadError -> Bool) -> Eq DownloadError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DownloadError -> DownloadError -> Bool
$c/= :: DownloadError -> DownloadError -> Bool
== :: DownloadError -> DownloadError -> Bool
$c== :: DownloadError -> DownloadError -> Bool
Eq)

instance P.Enum DownloadError where
    fromEnum :: DownloadError -> Int
fromEnum DownloadError
DownloadErrorNetwork = Int
499
    fromEnum DownloadError
DownloadErrorCancelledByUser = Int
400
    fromEnum DownloadError
DownloadErrorDestination = Int
401
    fromEnum (AnotherDownloadError Int
k) = Int
k

    toEnum :: Int -> DownloadError
toEnum Int
499 = DownloadError
DownloadErrorNetwork
    toEnum Int
400 = DownloadError
DownloadErrorCancelledByUser
    toEnum Int
401 = DownloadError
DownloadErrorDestination
    toEnum Int
k = Int -> DownloadError
AnotherDownloadError Int
k

instance P.Ord DownloadError where
    compare :: DownloadError -> DownloadError -> Ordering
compare DownloadError
a DownloadError
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (DownloadError -> Int
forall a. Enum a => a -> Int
P.fromEnum DownloadError
a) (DownloadError -> Int
forall a. Enum a => a -> Int
P.fromEnum DownloadError
b)

instance GErrorClass DownloadError where
    gerrorClassDomain :: DownloadError -> Text
gerrorClassDomain DownloadError
_ = Text
"WebKitDownloadError"

-- | Catch exceptions of type `DownloadError`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`.
catchDownloadError ::
    IO a ->
    (DownloadError -> GErrorMessage -> IO a) ->
    IO a
catchDownloadError :: forall a. IO a -> (DownloadError -> Text -> IO a) -> IO a
catchDownloadError = IO a -> (DownloadError -> Text -> IO a) -> IO a
forall err a.
GErrorClass err =>
IO a -> (err -> Text -> IO a) -> IO a
catchGErrorJustDomain

-- | Handle exceptions of type `DownloadError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`.
handleDownloadError ::
    (DownloadError -> GErrorMessage -> IO a) ->
    IO a ->
    IO a
handleDownloadError :: forall a. (DownloadError -> Text -> IO a) -> IO a -> IO a
handleDownloadError = (DownloadError -> Text -> IO a) -> IO a -> IO a
forall err a.
GErrorClass err =>
(err -> Text -> IO a) -> IO a -> IO a
handleGErrorJustDomain

type instance O.ParentTypes DownloadError = '[]
instance O.HasParentTypes DownloadError

foreign import ccall "webkit_download_error_get_type" c_webkit_download_error_get_type :: 
    IO GType

instance B.Types.TypedObject DownloadError where
    glibType :: IO GType
glibType = IO GType
c_webkit_download_error_get_type

instance B.Types.BoxedEnum DownloadError

-- Enum CredentialPersistence
-- | Enum values representing the duration for which a credential persists.
-- 
-- /Since: 2.2/
data CredentialPersistence = 
      CredentialPersistenceNone
    -- ^ Credential does not persist
    | CredentialPersistenceForSession
    -- ^ Credential persists for session only
    | CredentialPersistencePermanent
    -- ^ Credential persists permanently
    | AnotherCredentialPersistence Int
    -- ^ Catch-all for unknown values
    deriving (Int -> CredentialPersistence -> ShowS
[CredentialPersistence] -> ShowS
CredentialPersistence -> String
(Int -> CredentialPersistence -> ShowS)
-> (CredentialPersistence -> String)
-> ([CredentialPersistence] -> ShowS)
-> Show CredentialPersistence
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CredentialPersistence] -> ShowS
$cshowList :: [CredentialPersistence] -> ShowS
show :: CredentialPersistence -> String
$cshow :: CredentialPersistence -> String
showsPrec :: Int -> CredentialPersistence -> ShowS
$cshowsPrec :: Int -> CredentialPersistence -> ShowS
Show, CredentialPersistence -> CredentialPersistence -> Bool
(CredentialPersistence -> CredentialPersistence -> Bool)
-> (CredentialPersistence -> CredentialPersistence -> Bool)
-> Eq CredentialPersistence
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CredentialPersistence -> CredentialPersistence -> Bool
$c/= :: CredentialPersistence -> CredentialPersistence -> Bool
== :: CredentialPersistence -> CredentialPersistence -> Bool
$c== :: CredentialPersistence -> CredentialPersistence -> Bool
Eq)

instance P.Enum CredentialPersistence where
    fromEnum :: CredentialPersistence -> Int
fromEnum CredentialPersistence
CredentialPersistenceNone = Int
0
    fromEnum CredentialPersistence
CredentialPersistenceForSession = Int
1
    fromEnum CredentialPersistence
CredentialPersistencePermanent = Int
2
    fromEnum (AnotherCredentialPersistence Int
k) = Int
k

    toEnum :: Int -> CredentialPersistence
toEnum Int
0 = CredentialPersistence
CredentialPersistenceNone
    toEnum Int
1 = CredentialPersistence
CredentialPersistenceForSession
    toEnum Int
2 = CredentialPersistence
CredentialPersistencePermanent
    toEnum Int
k = Int -> CredentialPersistence
AnotherCredentialPersistence Int
k

instance P.Ord CredentialPersistence where
    compare :: CredentialPersistence -> CredentialPersistence -> Ordering
compare CredentialPersistence
a CredentialPersistence
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (CredentialPersistence -> Int
forall a. Enum a => a -> Int
P.fromEnum CredentialPersistence
a) (CredentialPersistence -> Int
forall a. Enum a => a -> Int
P.fromEnum CredentialPersistence
b)

type instance O.ParentTypes CredentialPersistence = '[]
instance O.HasParentTypes CredentialPersistence

foreign import ccall "webkit_credential_persistence_get_type" c_webkit_credential_persistence_get_type :: 
    IO GType

instance B.Types.TypedObject CredentialPersistence where
    glibType :: IO GType
glibType = IO GType
c_webkit_credential_persistence_get_type

instance B.Types.BoxedEnum CredentialPersistence

-- Enum CookiePersistentStorage
-- | Enum values used to denote the cookie persistent storage types.
data CookiePersistentStorage = 
      CookiePersistentStorageText
    -- ^ Cookies are stored in a text
    --  file in the Mozilla \"cookies.txt\" format.
    | CookiePersistentStorageSqlite
    -- ^ Cookies are stored in a SQLite
    --  file in the current Mozilla format.
    | AnotherCookiePersistentStorage Int
    -- ^ Catch-all for unknown values
    deriving (Int -> CookiePersistentStorage -> ShowS
[CookiePersistentStorage] -> ShowS
CookiePersistentStorage -> String
(Int -> CookiePersistentStorage -> ShowS)
-> (CookiePersistentStorage -> String)
-> ([CookiePersistentStorage] -> ShowS)
-> Show CookiePersistentStorage
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CookiePersistentStorage] -> ShowS
$cshowList :: [CookiePersistentStorage] -> ShowS
show :: CookiePersistentStorage -> String
$cshow :: CookiePersistentStorage -> String
showsPrec :: Int -> CookiePersistentStorage -> ShowS
$cshowsPrec :: Int -> CookiePersistentStorage -> ShowS
Show, CookiePersistentStorage -> CookiePersistentStorage -> Bool
(CookiePersistentStorage -> CookiePersistentStorage -> Bool)
-> (CookiePersistentStorage -> CookiePersistentStorage -> Bool)
-> Eq CookiePersistentStorage
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CookiePersistentStorage -> CookiePersistentStorage -> Bool
$c/= :: CookiePersistentStorage -> CookiePersistentStorage -> Bool
== :: CookiePersistentStorage -> CookiePersistentStorage -> Bool
$c== :: CookiePersistentStorage -> CookiePersistentStorage -> Bool
Eq)

instance P.Enum CookiePersistentStorage where
    fromEnum :: CookiePersistentStorage -> Int
fromEnum CookiePersistentStorage
CookiePersistentStorageText = Int
0
    fromEnum CookiePersistentStorage
CookiePersistentStorageSqlite = Int
1
    fromEnum (AnotherCookiePersistentStorage Int
k) = Int
k

    toEnum :: Int -> CookiePersistentStorage
toEnum Int
0 = CookiePersistentStorage
CookiePersistentStorageText
    toEnum Int
1 = CookiePersistentStorage
CookiePersistentStorageSqlite
    toEnum Int
k = Int -> CookiePersistentStorage
AnotherCookiePersistentStorage Int
k

instance P.Ord CookiePersistentStorage where
    compare :: CookiePersistentStorage -> CookiePersistentStorage -> Ordering
compare CookiePersistentStorage
a CookiePersistentStorage
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (CookiePersistentStorage -> Int
forall a. Enum a => a -> Int
P.fromEnum CookiePersistentStorage
a) (CookiePersistentStorage -> Int
forall a. Enum a => a -> Int
P.fromEnum CookiePersistentStorage
b)

type instance O.ParentTypes CookiePersistentStorage = '[]
instance O.HasParentTypes CookiePersistentStorage

foreign import ccall "webkit_cookie_persistent_storage_get_type" c_webkit_cookie_persistent_storage_get_type :: 
    IO GType

instance B.Types.TypedObject CookiePersistentStorage where
    glibType :: IO GType
glibType = IO GType
c_webkit_cookie_persistent_storage_get_type

instance B.Types.BoxedEnum CookiePersistentStorage

-- Enum CookieAcceptPolicy
-- | Enum values used to denote the cookie acceptance policies.
data CookieAcceptPolicy = 
      CookieAcceptPolicyAlways
    -- ^ Accept all cookies unconditionally.
    | CookieAcceptPolicyNever
    -- ^ Reject all cookies unconditionally.
    | CookieAcceptPolicyNoThirdParty
    -- ^ Accept only cookies set by the main document loaded.
    | AnotherCookieAcceptPolicy Int
    -- ^ Catch-all for unknown values
    deriving (Int -> CookieAcceptPolicy -> ShowS
[CookieAcceptPolicy] -> ShowS
CookieAcceptPolicy -> String
(Int -> CookieAcceptPolicy -> ShowS)
-> (CookieAcceptPolicy -> String)
-> ([CookieAcceptPolicy] -> ShowS)
-> Show CookieAcceptPolicy
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CookieAcceptPolicy] -> ShowS
$cshowList :: [CookieAcceptPolicy] -> ShowS
show :: CookieAcceptPolicy -> String
$cshow :: CookieAcceptPolicy -> String
showsPrec :: Int -> CookieAcceptPolicy -> ShowS
$cshowsPrec :: Int -> CookieAcceptPolicy -> ShowS
Show, CookieAcceptPolicy -> CookieAcceptPolicy -> Bool
(CookieAcceptPolicy -> CookieAcceptPolicy -> Bool)
-> (CookieAcceptPolicy -> CookieAcceptPolicy -> Bool)
-> Eq CookieAcceptPolicy
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CookieAcceptPolicy -> CookieAcceptPolicy -> Bool
$c/= :: CookieAcceptPolicy -> CookieAcceptPolicy -> Bool
== :: CookieAcceptPolicy -> CookieAcceptPolicy -> Bool
$c== :: CookieAcceptPolicy -> CookieAcceptPolicy -> Bool
Eq)

instance P.Enum CookieAcceptPolicy where
    fromEnum :: CookieAcceptPolicy -> Int
fromEnum CookieAcceptPolicy
CookieAcceptPolicyAlways = Int
0
    fromEnum CookieAcceptPolicy
CookieAcceptPolicyNever = Int
1
    fromEnum CookieAcceptPolicy
CookieAcceptPolicyNoThirdParty = Int
2
    fromEnum (AnotherCookieAcceptPolicy Int
k) = Int
k

    toEnum :: Int -> CookieAcceptPolicy
toEnum Int
0 = CookieAcceptPolicy
CookieAcceptPolicyAlways
    toEnum Int
1 = CookieAcceptPolicy
CookieAcceptPolicyNever
    toEnum Int
2 = CookieAcceptPolicy
CookieAcceptPolicyNoThirdParty
    toEnum Int
k = Int -> CookieAcceptPolicy
AnotherCookieAcceptPolicy Int
k

instance P.Ord CookieAcceptPolicy where
    compare :: CookieAcceptPolicy -> CookieAcceptPolicy -> Ordering
compare CookieAcceptPolicy
a CookieAcceptPolicy
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (CookieAcceptPolicy -> Int
forall a. Enum a => a -> Int
P.fromEnum CookieAcceptPolicy
a) (CookieAcceptPolicy -> Int
forall a. Enum a => a -> Int
P.fromEnum CookieAcceptPolicy
b)

type instance O.ParentTypes CookieAcceptPolicy = '[]
instance O.HasParentTypes CookieAcceptPolicy

foreign import ccall "webkit_cookie_accept_policy_get_type" c_webkit_cookie_accept_policy_get_type :: 
    IO GType

instance B.Types.TypedObject CookieAcceptPolicy where
    glibType :: IO GType
glibType = IO GType
c_webkit_cookie_accept_policy_get_type

instance B.Types.BoxedEnum CookieAcceptPolicy

-- Enum ContextMenuAction
-- | Enum values used to denote the stock actions for
-- t'GI.WebKit2.Objects.ContextMenuItem.ContextMenuItem's
data ContextMenuAction = 
      ContextMenuActionNoAction
    -- ^ No action, used by separator menu items.
    | ContextMenuActionOpenLink
    -- ^ Open current link.
    | ContextMenuActionOpenLinkInNewWindow
    -- ^ Open current link in a new window.
    | ContextMenuActionDownloadLinkToDisk
    -- ^ Download link destination.
    | ContextMenuActionCopyLinkToClipboard
    -- ^ Copy link location to the clipboard.
    | ContextMenuActionOpenImageInNewWindow
    -- ^ Open current image in a new window.
    | ContextMenuActionDownloadImageToDisk
    -- ^ Download current image.
    | ContextMenuActionCopyImageToClipboard
    -- ^ Copy current image to the clipboard.
    | ContextMenuActionCopyImageUrlToClipboard
    -- ^ Copy current image location to the clipboard.
    | ContextMenuActionOpenFrameInNewWindow
    -- ^ Open current frame in a new window.
    | ContextMenuActionGoBack
    -- ^ Load the previous history item.
    | ContextMenuActionGoForward
    -- ^ Load the next history item.
    | ContextMenuActionStop
    -- ^ Stop any ongoing loading operation.
    | ContextMenuActionReload
    -- ^ Reload the contents of current view.
    | ContextMenuActionCopy
    -- ^ Copy current selection the clipboard.
    | ContextMenuActionCut
    -- ^ Cut current selection to the clipboard.
    | ContextMenuActionPaste
    -- ^ Paste clipboard contents.
    | ContextMenuActionDelete
    -- ^ Delete current selection.
    | ContextMenuActionSelectAll
    -- ^ Select all text.
    | ContextMenuActionInputMethods
    -- ^ Input methods menu.
    | ContextMenuActionUnicode
    -- ^ Unicode menu.
    | ContextMenuActionSpellingGuess
    -- ^ A proposed replacement for a misspelled word.
    | ContextMenuActionNoGuessesFound
    -- ^ An indicator that spellchecking found no proposed replacements.
    | ContextMenuActionIgnoreSpelling
    -- ^ Causes the spellchecker to ignore the word for this session.
    | ContextMenuActionLearnSpelling
    -- ^ Causes the spellchecker to add the word to the dictionary.
    | ContextMenuActionIgnoreGrammar
    -- ^ Ignore grammar.
    | ContextMenuActionFontMenu
    -- ^ Font options menu.
    | ContextMenuActionBold
    -- ^ Bold.
    | ContextMenuActionItalic
    -- ^ Italic.
    | ContextMenuActionUnderline
    -- ^ Underline.
    | ContextMenuActionOutline
    -- ^ Outline.
    | ContextMenuActionInspectElement
    -- ^ Open current element in the inspector.
    | ContextMenuActionOpenVideoInNewWindow
    -- ^ Open current video element in a new window.
    | ContextMenuActionOpenAudioInNewWindow
    -- ^ Open current audio element in a new window.
    | ContextMenuActionCopyVideoLinkToClipboard
    -- ^ Copy video link location in to the clipboard.
    | ContextMenuActionCopyAudioLinkToClipboard
    -- ^ Copy audio link location in to the clipboard.
    | ContextMenuActionToggleMediaControls
    -- ^ Enable or disable media controls.
    | ContextMenuActionToggleMediaLoop
    -- ^ Enable or disable media loop.
    | ContextMenuActionEnterVideoFullscreen
    -- ^ Show current video element in fullscreen mode.
    | ContextMenuActionMediaPlay
    -- ^ Play current media element.
    | ContextMenuActionMediaPause
    -- ^ Pause current media element.
    | ContextMenuActionMediaMute
    -- ^ Mute current media element.
    | ContextMenuActionDownloadVideoToDisk
    -- ^ Download video to disk. Since 2.2
    | ContextMenuActionDownloadAudioToDisk
    -- ^ Download audio to disk. Since 2.2
    | ContextMenuActionInsertEmoji
    -- ^ Insert an emoji. Since 2.26
    | ContextMenuActionPasteAsPlainText
    -- ^ Paste clipboard contents as plain text. Since 2.30
    | ContextMenuActionCustom
    -- ^ Custom action defined by applications.
    | AnotherContextMenuAction Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ContextMenuAction -> ShowS
[ContextMenuAction] -> ShowS
ContextMenuAction -> String
(Int -> ContextMenuAction -> ShowS)
-> (ContextMenuAction -> String)
-> ([ContextMenuAction] -> ShowS)
-> Show ContextMenuAction
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ContextMenuAction] -> ShowS
$cshowList :: [ContextMenuAction] -> ShowS
show :: ContextMenuAction -> String
$cshow :: ContextMenuAction -> String
showsPrec :: Int -> ContextMenuAction -> ShowS
$cshowsPrec :: Int -> ContextMenuAction -> ShowS
Show, ContextMenuAction -> ContextMenuAction -> Bool
(ContextMenuAction -> ContextMenuAction -> Bool)
-> (ContextMenuAction -> ContextMenuAction -> Bool)
-> Eq ContextMenuAction
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ContextMenuAction -> ContextMenuAction -> Bool
$c/= :: ContextMenuAction -> ContextMenuAction -> Bool
== :: ContextMenuAction -> ContextMenuAction -> Bool
$c== :: ContextMenuAction -> ContextMenuAction -> Bool
Eq)

instance P.Enum ContextMenuAction where
    fromEnum :: ContextMenuAction -> Int
fromEnum ContextMenuAction
ContextMenuActionNoAction = Int
0
    fromEnum ContextMenuAction
ContextMenuActionOpenLink = Int
1
    fromEnum ContextMenuAction
ContextMenuActionOpenLinkInNewWindow = Int
2
    fromEnum ContextMenuAction
ContextMenuActionDownloadLinkToDisk = Int
3
    fromEnum ContextMenuAction
ContextMenuActionCopyLinkToClipboard = Int
4
    fromEnum ContextMenuAction
ContextMenuActionOpenImageInNewWindow = Int
5
    fromEnum ContextMenuAction
ContextMenuActionDownloadImageToDisk = Int
6
    fromEnum ContextMenuAction
ContextMenuActionCopyImageToClipboard = Int
7
    fromEnum ContextMenuAction
ContextMenuActionCopyImageUrlToClipboard = Int
8
    fromEnum ContextMenuAction
ContextMenuActionOpenFrameInNewWindow = Int
9
    fromEnum ContextMenuAction
ContextMenuActionGoBack = Int
10
    fromEnum ContextMenuAction
ContextMenuActionGoForward = Int
11
    fromEnum ContextMenuAction
ContextMenuActionStop = Int
12
    fromEnum ContextMenuAction
ContextMenuActionReload = Int
13
    fromEnum ContextMenuAction
ContextMenuActionCopy = Int
14
    fromEnum ContextMenuAction
ContextMenuActionCut = Int
15
    fromEnum ContextMenuAction
ContextMenuActionPaste = Int
16
    fromEnum ContextMenuAction
ContextMenuActionDelete = Int
17
    fromEnum ContextMenuAction
ContextMenuActionSelectAll = Int
18
    fromEnum ContextMenuAction
ContextMenuActionInputMethods = Int
19
    fromEnum ContextMenuAction
ContextMenuActionUnicode = Int
20
    fromEnum ContextMenuAction
ContextMenuActionSpellingGuess = Int
21
    fromEnum ContextMenuAction
ContextMenuActionNoGuessesFound = Int
22
    fromEnum ContextMenuAction
ContextMenuActionIgnoreSpelling = Int
23
    fromEnum ContextMenuAction
ContextMenuActionLearnSpelling = Int
24
    fromEnum ContextMenuAction
ContextMenuActionIgnoreGrammar = Int
25
    fromEnum ContextMenuAction
ContextMenuActionFontMenu = Int
26
    fromEnum ContextMenuAction
ContextMenuActionBold = Int
27
    fromEnum ContextMenuAction
ContextMenuActionItalic = Int
28
    fromEnum ContextMenuAction
ContextMenuActionUnderline = Int
29
    fromEnum ContextMenuAction
ContextMenuActionOutline = Int
30
    fromEnum ContextMenuAction
ContextMenuActionInspectElement = Int
31
    fromEnum ContextMenuAction
ContextMenuActionOpenVideoInNewWindow = Int
32
    fromEnum ContextMenuAction
ContextMenuActionOpenAudioInNewWindow = Int
33
    fromEnum ContextMenuAction
ContextMenuActionCopyVideoLinkToClipboard = Int
34
    fromEnum ContextMenuAction
ContextMenuActionCopyAudioLinkToClipboard = Int
35
    fromEnum ContextMenuAction
ContextMenuActionToggleMediaControls = Int
36
    fromEnum ContextMenuAction
ContextMenuActionToggleMediaLoop = Int
37
    fromEnum ContextMenuAction
ContextMenuActionEnterVideoFullscreen = Int
38
    fromEnum ContextMenuAction
ContextMenuActionMediaPlay = Int
39
    fromEnum ContextMenuAction
ContextMenuActionMediaPause = Int
40
    fromEnum ContextMenuAction
ContextMenuActionMediaMute = Int
41
    fromEnum ContextMenuAction
ContextMenuActionDownloadVideoToDisk = Int
42
    fromEnum ContextMenuAction
ContextMenuActionDownloadAudioToDisk = Int
43
    fromEnum ContextMenuAction
ContextMenuActionInsertEmoji = Int
44
    fromEnum ContextMenuAction
ContextMenuActionPasteAsPlainText = Int
45
    fromEnum ContextMenuAction
ContextMenuActionCustom = Int
10000
    fromEnum (AnotherContextMenuAction Int
k) = Int
k

    toEnum :: Int -> ContextMenuAction
toEnum Int
0 = ContextMenuAction
ContextMenuActionNoAction
    toEnum Int
1 = ContextMenuAction
ContextMenuActionOpenLink
    toEnum Int
2 = ContextMenuAction
ContextMenuActionOpenLinkInNewWindow
    toEnum Int
3 = ContextMenuAction
ContextMenuActionDownloadLinkToDisk
    toEnum Int
4 = ContextMenuAction
ContextMenuActionCopyLinkToClipboard
    toEnum Int
5 = ContextMenuAction
ContextMenuActionOpenImageInNewWindow
    toEnum Int
6 = ContextMenuAction
ContextMenuActionDownloadImageToDisk
    toEnum Int
7 = ContextMenuAction
ContextMenuActionCopyImageToClipboard
    toEnum Int
8 = ContextMenuAction
ContextMenuActionCopyImageUrlToClipboard
    toEnum Int
9 = ContextMenuAction
ContextMenuActionOpenFrameInNewWindow
    toEnum Int
10 = ContextMenuAction
ContextMenuActionGoBack
    toEnum Int
11 = ContextMenuAction
ContextMenuActionGoForward
    toEnum Int
12 = ContextMenuAction
ContextMenuActionStop
    toEnum Int
13 = ContextMenuAction
ContextMenuActionReload
    toEnum Int
14 = ContextMenuAction
ContextMenuActionCopy
    toEnum Int
15 = ContextMenuAction
ContextMenuActionCut
    toEnum Int
16 = ContextMenuAction
ContextMenuActionPaste
    toEnum Int
17 = ContextMenuAction
ContextMenuActionDelete
    toEnum Int
18 = ContextMenuAction
ContextMenuActionSelectAll
    toEnum Int
19 = ContextMenuAction
ContextMenuActionInputMethods
    toEnum Int
20 = ContextMenuAction
ContextMenuActionUnicode
    toEnum Int
21 = ContextMenuAction
ContextMenuActionSpellingGuess
    toEnum Int
22 = ContextMenuAction
ContextMenuActionNoGuessesFound
    toEnum Int
23 = ContextMenuAction
ContextMenuActionIgnoreSpelling
    toEnum Int
24 = ContextMenuAction
ContextMenuActionLearnSpelling
    toEnum Int
25 = ContextMenuAction
ContextMenuActionIgnoreGrammar
    toEnum Int
26 = ContextMenuAction
ContextMenuActionFontMenu
    toEnum Int
27 = ContextMenuAction
ContextMenuActionBold
    toEnum Int
28 = ContextMenuAction
ContextMenuActionItalic
    toEnum Int
29 = ContextMenuAction
ContextMenuActionUnderline
    toEnum Int
30 = ContextMenuAction
ContextMenuActionOutline
    toEnum Int
31 = ContextMenuAction
ContextMenuActionInspectElement
    toEnum Int
32 = ContextMenuAction
ContextMenuActionOpenVideoInNewWindow
    toEnum Int
33 = ContextMenuAction
ContextMenuActionOpenAudioInNewWindow
    toEnum Int
34 = ContextMenuAction
ContextMenuActionCopyVideoLinkToClipboard
    toEnum Int
35 = ContextMenuAction
ContextMenuActionCopyAudioLinkToClipboard
    toEnum Int
36 = ContextMenuAction
ContextMenuActionToggleMediaControls
    toEnum Int
37 = ContextMenuAction
ContextMenuActionToggleMediaLoop
    toEnum Int
38 = ContextMenuAction
ContextMenuActionEnterVideoFullscreen
    toEnum Int
39 = ContextMenuAction
ContextMenuActionMediaPlay
    toEnum Int
40 = ContextMenuAction
ContextMenuActionMediaPause
    toEnum Int
41 = ContextMenuAction
ContextMenuActionMediaMute
    toEnum Int
42 = ContextMenuAction
ContextMenuActionDownloadVideoToDisk
    toEnum Int
43 = ContextMenuAction
ContextMenuActionDownloadAudioToDisk
    toEnum Int
44 = ContextMenuAction
ContextMenuActionInsertEmoji
    toEnum Int
45 = ContextMenuAction
ContextMenuActionPasteAsPlainText
    toEnum Int
10000 = ContextMenuAction
ContextMenuActionCustom
    toEnum Int
k = Int -> ContextMenuAction
AnotherContextMenuAction Int
k

instance P.Ord ContextMenuAction where
    compare :: ContextMenuAction -> ContextMenuAction -> Ordering
compare ContextMenuAction
a ContextMenuAction
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (ContextMenuAction -> Int
forall a. Enum a => a -> Int
P.fromEnum ContextMenuAction
a) (ContextMenuAction -> Int
forall a. Enum a => a -> Int
P.fromEnum ContextMenuAction
b)

type instance O.ParentTypes ContextMenuAction = '[]
instance O.HasParentTypes ContextMenuAction

foreign import ccall "webkit_context_menu_action_get_type" c_webkit_context_menu_action_get_type :: 
    IO GType

instance B.Types.TypedObject ContextMenuAction where
    glibType :: IO GType
glibType = IO GType
c_webkit_context_menu_action_get_type

instance B.Types.BoxedEnum ContextMenuAction

-- Enum CacheModel
-- | Enum values used for determining the t'GI.WebKit2.Objects.WebContext.WebContext' cache model.
data CacheModel = 
      CacheModelDocumentViewer
    -- ^ Disable the cache completely, which
    --   substantially reduces memory usage. Useful for applications that only
    --   access a single local file, with no navigation to other pages. No remote
    --   resources will be cached.
    | CacheModelWebBrowser
    -- ^ Improve document load speed substantially
    --   by caching a very large number of resources and previously viewed content.
    | CacheModelDocumentBrowser
    -- ^ A cache model optimized for viewing
    --   a series of local files -- for example, a documentation viewer or a website
    --   designer. WebKit will cache a moderate number of resources.
    | AnotherCacheModel Int
    -- ^ Catch-all for unknown values
    deriving (Int -> CacheModel -> ShowS
[CacheModel] -> ShowS
CacheModel -> String
(Int -> CacheModel -> ShowS)
-> (CacheModel -> String)
-> ([CacheModel] -> ShowS)
-> Show CacheModel
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CacheModel] -> ShowS
$cshowList :: [CacheModel] -> ShowS
show :: CacheModel -> String
$cshow :: CacheModel -> String
showsPrec :: Int -> CacheModel -> ShowS
$cshowsPrec :: Int -> CacheModel -> ShowS
Show, CacheModel -> CacheModel -> Bool
(CacheModel -> CacheModel -> Bool)
-> (CacheModel -> CacheModel -> Bool) -> Eq CacheModel
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CacheModel -> CacheModel -> Bool
$c/= :: CacheModel -> CacheModel -> Bool
== :: CacheModel -> CacheModel -> Bool
$c== :: CacheModel -> CacheModel -> Bool
Eq)

instance P.Enum CacheModel where
    fromEnum :: CacheModel -> Int
fromEnum CacheModel
CacheModelDocumentViewer = Int
0
    fromEnum CacheModel
CacheModelWebBrowser = Int
1
    fromEnum CacheModel
CacheModelDocumentBrowser = Int
2
    fromEnum (AnotherCacheModel Int
k) = Int
k

    toEnum :: Int -> CacheModel
toEnum Int
0 = CacheModel
CacheModelDocumentViewer
    toEnum Int
1 = CacheModel
CacheModelWebBrowser
    toEnum Int
2 = CacheModel
CacheModelDocumentBrowser
    toEnum Int
k = Int -> CacheModel
AnotherCacheModel Int
k

instance P.Ord CacheModel where
    compare :: CacheModel -> CacheModel -> Ordering
compare CacheModel
a CacheModel
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (CacheModel -> Int
forall a. Enum a => a -> Int
P.fromEnum CacheModel
a) (CacheModel -> Int
forall a. Enum a => a -> Int
P.fromEnum CacheModel
b)

type instance O.ParentTypes CacheModel = '[]
instance O.HasParentTypes CacheModel

foreign import ccall "webkit_cache_model_get_type" c_webkit_cache_model_get_type :: 
    IO GType

instance B.Types.TypedObject CacheModel where
    glibType :: IO GType
glibType = IO GType
c_webkit_cache_model_get_type

instance B.Types.BoxedEnum CacheModel

-- Enum AutoplayPolicy
-- | Enum values used to specify autoplay policies.
-- 
-- /Since: 2.30/
data AutoplayPolicy = 
      AutoplayPolicyAllow
    -- ^ Do not restrict autoplay.
    | AutoplayPolicyAllowWithoutSound
    -- ^ Allow videos to autoplay if
    --     they have no audio track, or if their audio track is muted.
    | AutoplayPolicyDeny
    -- ^ Never allow autoplay.
    | AnotherAutoplayPolicy Int
    -- ^ Catch-all for unknown values
    deriving (Int -> AutoplayPolicy -> ShowS
[AutoplayPolicy] -> ShowS
AutoplayPolicy -> String
(Int -> AutoplayPolicy -> ShowS)
-> (AutoplayPolicy -> String)
-> ([AutoplayPolicy] -> ShowS)
-> Show AutoplayPolicy
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AutoplayPolicy] -> ShowS
$cshowList :: [AutoplayPolicy] -> ShowS
show :: AutoplayPolicy -> String
$cshow :: AutoplayPolicy -> String
showsPrec :: Int -> AutoplayPolicy -> ShowS
$cshowsPrec :: Int -> AutoplayPolicy -> ShowS
Show, AutoplayPolicy -> AutoplayPolicy -> Bool
(AutoplayPolicy -> AutoplayPolicy -> Bool)
-> (AutoplayPolicy -> AutoplayPolicy -> Bool) -> Eq AutoplayPolicy
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AutoplayPolicy -> AutoplayPolicy -> Bool
$c/= :: AutoplayPolicy -> AutoplayPolicy -> Bool
== :: AutoplayPolicy -> AutoplayPolicy -> Bool
$c== :: AutoplayPolicy -> AutoplayPolicy -> Bool
Eq)

instance P.Enum AutoplayPolicy where
    fromEnum :: AutoplayPolicy -> Int
fromEnum AutoplayPolicy
AutoplayPolicyAllow = Int
0
    fromEnum AutoplayPolicy
AutoplayPolicyAllowWithoutSound = Int
1
    fromEnum AutoplayPolicy
AutoplayPolicyDeny = Int
2
    fromEnum (AnotherAutoplayPolicy Int
k) = Int
k

    toEnum :: Int -> AutoplayPolicy
toEnum Int
0 = AutoplayPolicy
AutoplayPolicyAllow
    toEnum Int
1 = AutoplayPolicy
AutoplayPolicyAllowWithoutSound
    toEnum Int
2 = AutoplayPolicy
AutoplayPolicyDeny
    toEnum Int
k = Int -> AutoplayPolicy
AnotherAutoplayPolicy Int
k

instance P.Ord AutoplayPolicy where
    compare :: AutoplayPolicy -> AutoplayPolicy -> Ordering
compare AutoplayPolicy
a AutoplayPolicy
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (AutoplayPolicy -> Int
forall a. Enum a => a -> Int
P.fromEnum AutoplayPolicy
a) (AutoplayPolicy -> Int
forall a. Enum a => a -> Int
P.fromEnum AutoplayPolicy
b)

type instance O.ParentTypes AutoplayPolicy = '[]
instance O.HasParentTypes AutoplayPolicy

foreign import ccall "webkit_autoplay_policy_get_type" c_webkit_autoplay_policy_get_type :: 
    IO GType

instance B.Types.TypedObject AutoplayPolicy where
    glibType :: IO GType
glibType = IO GType
c_webkit_autoplay_policy_get_type

instance B.Types.BoxedEnum AutoplayPolicy

-- Enum AutomationBrowsingContextPresentation
-- | Enum values used for determining the automation browsing context presentation.
-- 
-- /Since: 2.28/
data AutomationBrowsingContextPresentation = 
      AutomationBrowsingContextPresentationWindow
    -- ^ a window
    | AutomationBrowsingContextPresentationTab
    -- ^ a tab
    | AnotherAutomationBrowsingContextPresentation Int
    -- ^ Catch-all for unknown values
    deriving (Int -> AutomationBrowsingContextPresentation -> ShowS
[AutomationBrowsingContextPresentation] -> ShowS
AutomationBrowsingContextPresentation -> String
(Int -> AutomationBrowsingContextPresentation -> ShowS)
-> (AutomationBrowsingContextPresentation -> String)
-> ([AutomationBrowsingContextPresentation] -> ShowS)
-> Show AutomationBrowsingContextPresentation
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AutomationBrowsingContextPresentation] -> ShowS
$cshowList :: [AutomationBrowsingContextPresentation] -> ShowS
show :: AutomationBrowsingContextPresentation -> String
$cshow :: AutomationBrowsingContextPresentation -> String
showsPrec :: Int -> AutomationBrowsingContextPresentation -> ShowS
$cshowsPrec :: Int -> AutomationBrowsingContextPresentation -> ShowS
Show, AutomationBrowsingContextPresentation
-> AutomationBrowsingContextPresentation -> Bool
(AutomationBrowsingContextPresentation
 -> AutomationBrowsingContextPresentation -> Bool)
-> (AutomationBrowsingContextPresentation
    -> AutomationBrowsingContextPresentation -> Bool)
-> Eq AutomationBrowsingContextPresentation
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AutomationBrowsingContextPresentation
-> AutomationBrowsingContextPresentation -> Bool
$c/= :: AutomationBrowsingContextPresentation
-> AutomationBrowsingContextPresentation -> Bool
== :: AutomationBrowsingContextPresentation
-> AutomationBrowsingContextPresentation -> Bool
$c== :: AutomationBrowsingContextPresentation
-> AutomationBrowsingContextPresentation -> Bool
Eq)

instance P.Enum AutomationBrowsingContextPresentation where
    fromEnum :: AutomationBrowsingContextPresentation -> Int
fromEnum AutomationBrowsingContextPresentation
AutomationBrowsingContextPresentationWindow = Int
0
    fromEnum AutomationBrowsingContextPresentation
AutomationBrowsingContextPresentationTab = Int
1
    fromEnum (AnotherAutomationBrowsingContextPresentation Int
k) = Int
k

    toEnum :: Int -> AutomationBrowsingContextPresentation
toEnum Int
0 = AutomationBrowsingContextPresentation
AutomationBrowsingContextPresentationWindow
    toEnum Int
1 = AutomationBrowsingContextPresentation
AutomationBrowsingContextPresentationTab
    toEnum Int
k = Int -> AutomationBrowsingContextPresentation
AnotherAutomationBrowsingContextPresentation Int
k

instance P.Ord AutomationBrowsingContextPresentation where
    compare :: AutomationBrowsingContextPresentation
-> AutomationBrowsingContextPresentation -> Ordering
compare AutomationBrowsingContextPresentation
a AutomationBrowsingContextPresentation
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (AutomationBrowsingContextPresentation -> Int
forall a. Enum a => a -> Int
P.fromEnum AutomationBrowsingContextPresentation
a) (AutomationBrowsingContextPresentation -> Int
forall a. Enum a => a -> Int
P.fromEnum AutomationBrowsingContextPresentation
b)

type instance O.ParentTypes AutomationBrowsingContextPresentation = '[]
instance O.HasParentTypes AutomationBrowsingContextPresentation

foreign import ccall "webkit_automation_browsing_context_presentation_get_type" c_webkit_automation_browsing_context_presentation_get_type :: 
    IO GType

instance B.Types.TypedObject AutomationBrowsingContextPresentation where
    glibType :: IO GType
glibType = IO GType
c_webkit_automation_browsing_context_presentation_get_type

instance B.Types.BoxedEnum AutomationBrowsingContextPresentation

-- Enum AuthenticationScheme
-- | Enum values representing the authentication scheme.
-- 
-- /Since: 2.2/
data AuthenticationScheme = 
      AuthenticationSchemeDefault
    -- ^ The default authentication scheme of WebKit.
    | AuthenticationSchemeHttpBasic
    -- ^ Basic authentication scheme as defined in RFC 2617.
    | AuthenticationSchemeHttpDigest
    -- ^ Digest authentication scheme as defined in RFC 2617.
    | AuthenticationSchemeHtmlForm
    -- ^ HTML Form authentication.
    | AuthenticationSchemeNtlm
    -- ^ NTLM Microsoft proprietary authentication scheme.
    | AuthenticationSchemeNegotiate
    -- ^ Negotiate (or SPNEGO) authentication scheme as defined in RFC 4559.
    | AuthenticationSchemeClientCertificateRequested
    -- ^ Client Certificate Authentication (see RFC 2246).
    | AuthenticationSchemeServerTrustEvaluationRequested
    -- ^ Server Trust Authentication.
    | AuthenticationSchemeUnknown
    -- ^ Authentication scheme unknown.
    | AnotherAuthenticationScheme Int
    -- ^ Catch-all for unknown values
    deriving (Int -> AuthenticationScheme -> ShowS
[AuthenticationScheme] -> ShowS
AuthenticationScheme -> String
(Int -> AuthenticationScheme -> ShowS)
-> (AuthenticationScheme -> String)
-> ([AuthenticationScheme] -> ShowS)
-> Show AuthenticationScheme
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AuthenticationScheme] -> ShowS
$cshowList :: [AuthenticationScheme] -> ShowS
show :: AuthenticationScheme -> String
$cshow :: AuthenticationScheme -> String
showsPrec :: Int -> AuthenticationScheme -> ShowS
$cshowsPrec :: Int -> AuthenticationScheme -> ShowS
Show, AuthenticationScheme -> AuthenticationScheme -> Bool
(AuthenticationScheme -> AuthenticationScheme -> Bool)
-> (AuthenticationScheme -> AuthenticationScheme -> Bool)
-> Eq AuthenticationScheme
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AuthenticationScheme -> AuthenticationScheme -> Bool
$c/= :: AuthenticationScheme -> AuthenticationScheme -> Bool
== :: AuthenticationScheme -> AuthenticationScheme -> Bool
$c== :: AuthenticationScheme -> AuthenticationScheme -> Bool
Eq)

instance P.Enum AuthenticationScheme where
    fromEnum :: AuthenticationScheme -> Int
fromEnum AuthenticationScheme
AuthenticationSchemeDefault = Int
1
    fromEnum AuthenticationScheme
AuthenticationSchemeHttpBasic = Int
2
    fromEnum AuthenticationScheme
AuthenticationSchemeHttpDigest = Int
3
    fromEnum AuthenticationScheme
AuthenticationSchemeHtmlForm = Int
4
    fromEnum AuthenticationScheme
AuthenticationSchemeNtlm = Int
5
    fromEnum AuthenticationScheme
AuthenticationSchemeNegotiate = Int
6
    fromEnum AuthenticationScheme
AuthenticationSchemeClientCertificateRequested = Int
7
    fromEnum AuthenticationScheme
AuthenticationSchemeServerTrustEvaluationRequested = Int
8
    fromEnum AuthenticationScheme
AuthenticationSchemeUnknown = Int
100
    fromEnum (AnotherAuthenticationScheme Int
k) = Int
k

    toEnum :: Int -> AuthenticationScheme
toEnum Int
1 = AuthenticationScheme
AuthenticationSchemeDefault
    toEnum Int
2 = AuthenticationScheme
AuthenticationSchemeHttpBasic
    toEnum Int
3 = AuthenticationScheme
AuthenticationSchemeHttpDigest
    toEnum Int
4 = AuthenticationScheme
AuthenticationSchemeHtmlForm
    toEnum Int
5 = AuthenticationScheme
AuthenticationSchemeNtlm
    toEnum Int
6 = AuthenticationScheme
AuthenticationSchemeNegotiate
    toEnum Int
7 = AuthenticationScheme
AuthenticationSchemeClientCertificateRequested
    toEnum Int
8 = AuthenticationScheme
AuthenticationSchemeServerTrustEvaluationRequested
    toEnum Int
100 = AuthenticationScheme
AuthenticationSchemeUnknown
    toEnum Int
k = Int -> AuthenticationScheme
AnotherAuthenticationScheme Int
k

instance P.Ord AuthenticationScheme where
    compare :: AuthenticationScheme -> AuthenticationScheme -> Ordering
compare AuthenticationScheme
a AuthenticationScheme
b = Int -> Int -> Ordering
forall a. Ord a => a -> a -> Ordering
P.compare (AuthenticationScheme -> Int
forall a. Enum a => a -> Int
P.fromEnum AuthenticationScheme
a) (AuthenticationScheme -> Int
forall a. Enum a => a -> Int
P.fromEnum AuthenticationScheme
b)

type instance O.ParentTypes AuthenticationScheme = '[]
instance O.HasParentTypes AuthenticationScheme

foreign import ccall "webkit_authentication_scheme_get_type" c_webkit_authentication_scheme_get_type :: 
    IO GType

instance B.Types.TypedObject AuthenticationScheme where
    glibType :: IO GType
glibType = IO GType
c_webkit_authentication_scheme_get_type

instance B.Types.BoxedEnum AuthenticationScheme