-- | 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(..)                ,


-- ** 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(..)          ,


-- ** 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(..)           ,


-- ** 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.ManagedPtr as B.ManagedPtr
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 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


-- 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 WebProcessTerminationReasonCrashed = 0
    fromEnum WebProcessTerminationReasonExceededMemoryLimit = 1
    fromEnum (AnotherWebProcessTerminationReason k :: Int
k) = Int
k

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

instance P.Ord WebProcessTerminationReason where
    compare :: WebProcessTerminationReason
-> WebProcessTerminationReason -> Ordering
compare a :: WebProcessTerminationReason
a b :: 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)

foreign import ccall "webkit_web_process_termination_reason_get_type" c_webkit_web_process_termination_reason_get_type :: 
    IO GType

instance BoxedEnum WebProcessTerminationReason where
    boxedEnumType :: WebProcessTerminationReason -> IO GType
boxedEnumType _ = IO GType
c_webkit_web_process_termination_reason_get_type

-- 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 UserStyleLevelUser = 0
    fromEnum UserStyleLevelAuthor = 1
    fromEnum (AnotherUserStyleLevel k :: Int
k) = Int
k

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

instance P.Ord UserStyleLevel where
    compare :: UserStyleLevel -> UserStyleLevel -> Ordering
compare a :: UserStyleLevel
a b :: 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)

foreign import ccall "webkit_user_style_level_get_type" c_webkit_user_style_level_get_type :: 
    IO GType

instance BoxedEnum UserStyleLevel where
    boxedEnumType :: UserStyleLevel -> IO GType
boxedEnumType _ = IO GType
c_webkit_user_style_level_get_type

-- 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 UserScriptInjectionTimeStart = 0
    fromEnum UserScriptInjectionTimeEnd = 1
    fromEnum (AnotherUserScriptInjectionTime k :: Int
k) = Int
k

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

instance P.Ord UserScriptInjectionTime where
    compare :: UserScriptInjectionTime -> UserScriptInjectionTime -> Ordering
compare a :: UserScriptInjectionTime
a b :: 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)

foreign import ccall "webkit_user_script_injection_time_get_type" c_webkit_user_script_injection_time_get_type :: 
    IO GType

instance BoxedEnum UserScriptInjectionTime where
    boxedEnumType :: UserScriptInjectionTime -> IO GType
boxedEnumType _ = IO GType
c_webkit_user_script_injection_time_get_type

-- 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 UserContentInjectedFramesAllFrames = 0
    fromEnum UserContentInjectedFramesTopFrame = 1
    fromEnum (AnotherUserContentInjectedFrames k :: Int
k) = Int
k

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

instance P.Ord UserContentInjectedFrames where
    compare :: UserContentInjectedFrames -> UserContentInjectedFrames -> Ordering
compare a :: UserContentInjectedFrames
a b :: 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)

foreign import ccall "webkit_user_content_injected_frames_get_type" c_webkit_user_content_injected_frames_get_type :: 
    IO GType

instance BoxedEnum UserContentInjectedFrames where
    boxedEnumType :: UserContentInjectedFrames -> IO GType
boxedEnumType _ = IO GType
c_webkit_user_content_injected_frames_get_type

-- 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 UserContentFilterErrorInvalidSource = 0
    fromEnum UserContentFilterErrorNotFound = 1
    fromEnum (AnotherUserContentFilterError k :: Int
k) = Int
k

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

instance P.Ord UserContentFilterError where
    compare :: UserContentFilterError -> UserContentFilterError -> Ordering
compare a :: UserContentFilterError
a b :: 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 _ = "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 :: 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 :: (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

foreign import ccall "webkit_user_content_filter_error_get_type" c_webkit_user_content_filter_error_get_type :: 
    IO GType

instance BoxedEnum UserContentFilterError where
    boxedEnumType :: UserContentFilterError -> IO GType
boxedEnumType _ = IO GType
c_webkit_user_content_filter_error_get_type

-- 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#signal:loadFailedWithTlsErrors") and, if the signal is handled,
    --   finish the load. In case the signal is not handled,
    --   [loadFailed]("GI.WebKit2.Objects.WebView#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 TLSErrorsPolicyIgnore = 0
    fromEnum TLSErrorsPolicyFail = 1
    fromEnum (AnotherTLSErrorsPolicy k :: Int
k) = Int
k

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

instance P.Ord TLSErrorsPolicy where
    compare :: TLSErrorsPolicy -> TLSErrorsPolicy -> Ordering
compare a :: TLSErrorsPolicy
a b :: 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)

foreign import ccall "webkit_tls_errors_policy_get_type" c_webkit_tls_errors_policy_get_type :: 
    IO GType

instance BoxedEnum TLSErrorsPolicy where
    boxedEnumType :: TLSErrorsPolicy -> IO GType
boxedEnumType _ = IO GType
c_webkit_tls_errors_policy_get_type

-- 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 SnapshotRegionVisible = 0
    fromEnum SnapshotRegionFullDocument = 1
    fromEnum (AnotherSnapshotRegion k :: Int
k) = Int
k

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

instance P.Ord SnapshotRegion where
    compare :: SnapshotRegion -> SnapshotRegion -> Ordering
compare a :: SnapshotRegion
a b :: 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)

foreign import ccall "webkit_snapshot_region_get_type" c_webkit_snapshot_region_get_type :: 
    IO GType

instance BoxedEnum SnapshotRegion where
    boxedEnumType :: SnapshotRegion -> IO GType
boxedEnumType _ = IO GType
c_webkit_snapshot_region_get_type

-- 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 SnapshotErrorCreate = 799
    fromEnum (AnotherSnapshotError k :: Int
k) = Int
k

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

instance P.Ord SnapshotError where
    compare :: SnapshotError -> SnapshotError -> Ordering
compare a :: SnapshotError
a b :: 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 _ = "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 :: 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 :: (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

foreign import ccall "webkit_snapshot_error_get_type" c_webkit_snapshot_error_get_type :: 
    IO GType

instance BoxedEnum SnapshotError where
    boxedEnumType :: SnapshotError -> IO GType
boxedEnumType _ = IO GType
c_webkit_snapshot_error_get_type

-- 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 ScriptDialogTypeAlert = 0
    fromEnum ScriptDialogTypeConfirm = 1
    fromEnum ScriptDialogTypePrompt = 2
    fromEnum ScriptDialogTypeBeforeUnloadConfirm = 3
    fromEnum (AnotherScriptDialogType k :: Int
k) = Int
k

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

instance P.Ord ScriptDialogType where
    compare :: ScriptDialogType -> ScriptDialogType -> Ordering
compare a :: ScriptDialogType
a b :: 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)

foreign import ccall "webkit_script_dialog_type_get_type" c_webkit_script_dialog_type_get_type :: 
    IO GType

instance BoxedEnum ScriptDialogType where
    boxedEnumType :: ScriptDialogType -> IO GType
boxedEnumType _ = IO GType
c_webkit_script_dialog_type_get_type

-- 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 SaveModeMhtml = 0
    fromEnum (AnotherSaveMode k :: Int
k) = Int
k

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

instance P.Ord SaveMode where
    compare :: SaveMode -> SaveMode -> Ordering
compare a :: SaveMode
a b :: 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)

foreign import ccall "webkit_save_mode_get_type" c_webkit_save_mode_get_type :: 
    IO GType

instance BoxedEnum SaveMode where
    boxedEnumType :: SaveMode -> IO GType
boxedEnumType _ = IO GType
c_webkit_save_mode_get_type

-- Enum ProcessModel
-- | Enum values used for determining the t'GI.WebKit2.Objects.WebContext.WebContext' process model.
-- 
-- /Since: 2.4/
data ProcessModel = 
      ProcessModelSharedSecondaryProcess
    -- ^ Use a single process to
    --   perform content rendering. The process is shared among all the
    --   t'GI.WebKit2.Objects.WebView.WebView' instances created by the application: if the process
    --   hangs or crashes all the web views in the application will be affected.
    --   This is the default process model, and it should suffice for most cases.
    | 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 ProcessModelSharedSecondaryProcess = 0
    fromEnum ProcessModelMultipleSecondaryProcesses = 1
    fromEnum (AnotherProcessModel k :: Int
k) = Int
k

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

instance P.Ord ProcessModel where
    compare :: ProcessModel -> ProcessModel -> Ordering
compare a :: ProcessModel
a b :: 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)

foreign import ccall "webkit_process_model_get_type" c_webkit_process_model_get_type :: 
    IO GType

instance BoxedEnum ProcessModel where
    boxedEnumType :: ProcessModel -> IO GType
boxedEnumType _ = IO GType
c_webkit_process_model_get_type

-- 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 PrintOperationResponsePrint = 0
    fromEnum PrintOperationResponseCancel = 1
    fromEnum (AnotherPrintOperationResponse k :: Int
k) = Int
k

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

instance P.Ord PrintOperationResponse where
    compare :: PrintOperationResponse -> PrintOperationResponse -> Ordering
compare a :: PrintOperationResponse
a b :: 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)

foreign import ccall "webkit_print_operation_response_get_type" c_webkit_print_operation_response_get_type :: 
    IO GType

instance BoxedEnum PrintOperationResponse where
    boxedEnumType :: PrintOperationResponse -> IO GType
boxedEnumType _ = IO GType
c_webkit_print_operation_response_get_type

-- 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 PrintErrorGeneral = 599
    fromEnum PrintErrorPrinterNotFound = 500
    fromEnum PrintErrorInvalidPageRange = 501
    fromEnum (AnotherPrintError k :: Int
k) = Int
k

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

instance P.Ord PrintError where
    compare :: PrintError -> PrintError -> Ordering
compare a :: PrintError
a b :: 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 _ = "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 :: 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 :: (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

foreign import ccall "webkit_print_error_get_type" c_webkit_print_error_get_type :: 
    IO GType

instance BoxedEnum PrintError where
    boxedEnumType :: PrintError -> IO GType
boxedEnumType _ = IO GType
c_webkit_print_error_get_type

-- 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 PolicyErrorFailed = 199
    fromEnum PolicyErrorCannotShowMimeType = 100
    fromEnum PolicyErrorCannotShowUri = 101
    fromEnum PolicyErrorFrameLoadInterruptedByPolicyChange = 102
    fromEnum PolicyErrorCannotUseRestrictedPort = 103
    fromEnum (AnotherPolicyError k :: Int
k) = Int
k

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

instance P.Ord PolicyError where
    compare :: PolicyError -> PolicyError -> Ordering
compare a :: PolicyError
a b :: 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 _ = "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 :: 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 :: (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

foreign import ccall "webkit_policy_error_get_type" c_webkit_policy_error_get_type :: 
    IO GType

instance BoxedEnum PolicyError where
    boxedEnumType :: PolicyError -> IO GType
boxedEnumType _ = IO GType
c_webkit_policy_error_get_type

-- Enum PolicyDecisionType
-- | Enum values used for determining the type of a policy decision during
-- [decidePolicy]("GI.WebKit2.Objects.WebView#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 PolicyDecisionTypeNavigationAction = 0
    fromEnum PolicyDecisionTypeNewWindowAction = 1
    fromEnum PolicyDecisionTypeResponse = 2
    fromEnum (AnotherPolicyDecisionType k :: Int
k) = Int
k

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

instance P.Ord PolicyDecisionType where
    compare :: PolicyDecisionType -> PolicyDecisionType -> Ordering
compare a :: PolicyDecisionType
a b :: 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)

foreign import ccall "webkit_policy_decision_type_get_type" c_webkit_policy_decision_type_get_type :: 
    IO GType

instance BoxedEnum PolicyDecisionType where
    boxedEnumType :: PolicyDecisionType -> IO GType
boxedEnumType _ = IO GType
c_webkit_policy_decision_type_get_type

-- 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 PluginErrorFailed = 299
    fromEnum PluginErrorCannotFindPlugin = 200
    fromEnum PluginErrorCannotLoadPlugin = 201
    fromEnum PluginErrorJavaUnavailable = 202
    fromEnum PluginErrorConnectionCancelled = 203
    fromEnum PluginErrorWillHandleLoad = 204
    fromEnum (AnotherPluginError k :: Int
k) = Int
k

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

instance P.Ord PluginError where
    compare :: PluginError -> PluginError -> Ordering
compare a :: PluginError
a b :: 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 _ = "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 :: 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 :: (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

foreign import ccall "webkit_plugin_error_get_type" c_webkit_plugin_error_get_type :: 
    IO GType

instance BoxedEnum PluginError where
    boxedEnumType :: PluginError -> IO GType
boxedEnumType _ = IO GType
c_webkit_plugin_error_get_type

-- 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 NetworkProxyModeDefault = 0
    fromEnum NetworkProxyModeNoProxy = 1
    fromEnum NetworkProxyModeCustom = 2
    fromEnum (AnotherNetworkProxyMode k :: Int
k) = Int
k

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

instance P.Ord NetworkProxyMode where
    compare :: NetworkProxyMode -> NetworkProxyMode -> Ordering
compare a :: NetworkProxyMode
a b :: 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)

foreign import ccall "webkit_network_proxy_mode_get_type" c_webkit_network_proxy_mode_get_type :: 
    IO GType

instance BoxedEnum NetworkProxyMode where
    boxedEnumType :: NetworkProxyMode -> IO GType
boxedEnumType _ = IO GType
c_webkit_network_proxy_mode_get_type

-- 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 NetworkErrorFailed = 399
    fromEnum NetworkErrorTransport = 300
    fromEnum NetworkErrorUnknownProtocol = 301
    fromEnum NetworkErrorCancelled = 302
    fromEnum NetworkErrorFileDoesNotExist = 303
    fromEnum (AnotherNetworkError k :: Int
k) = Int
k

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

instance P.Ord NetworkError where
    compare :: NetworkError -> NetworkError -> Ordering
compare a :: NetworkError
a b :: 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 _ = "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 :: 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 :: (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

foreign import ccall "webkit_network_error_get_type" c_webkit_network_error_get_type :: 
    IO GType

instance BoxedEnum NetworkError where
    boxedEnumType :: NetworkError -> IO GType
boxedEnumType _ = IO GType
c_webkit_network_error_get_type

-- 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 NavigationTypeLinkClicked = 0
    fromEnum NavigationTypeFormSubmitted = 1
    fromEnum NavigationTypeBackForward = 2
    fromEnum NavigationTypeReload = 3
    fromEnum NavigationTypeFormResubmitted = 4
    fromEnum NavigationTypeOther = 5
    fromEnum (AnotherNavigationType k :: Int
k) = Int
k

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

instance P.Ord NavigationType where
    compare :: NavigationType -> NavigationType -> Ordering
compare a :: NavigationType
a b :: 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)

foreign import ccall "webkit_navigation_type_get_type" c_webkit_navigation_type_get_type :: 
    IO GType

instance BoxedEnum NavigationType where
    boxedEnumType :: NavigationType -> IO GType
boxedEnumType _ = IO GType
c_webkit_navigation_type_get_type

-- 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 LoadEventStarted = 0
    fromEnum LoadEventRedirected = 1
    fromEnum LoadEventCommitted = 2
    fromEnum LoadEventFinished = 3
    fromEnum (AnotherLoadEvent k :: Int
k) = Int
k

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

instance P.Ord LoadEvent where
    compare :: LoadEvent -> LoadEvent -> Ordering
compare a :: LoadEvent
a b :: 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)

foreign import ccall "webkit_load_event_get_type" c_webkit_load_event_get_type :: 
    IO GType

instance BoxedEnum LoadEvent where
    boxedEnumType :: LoadEvent -> IO GType
boxedEnumType _ = IO GType
c_webkit_load_event_get_type

-- 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 JavascriptErrorFailed = 699
    fromEnum (AnotherJavascriptError k :: Int
k) = Int
k

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

instance P.Ord JavascriptError where
    compare :: JavascriptError -> JavascriptError -> Ordering
compare a :: JavascriptError
a b :: 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 _ = "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 :: 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 :: (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

foreign import ccall "webkit_javascript_error_get_type" c_webkit_javascript_error_get_type :: 
    IO GType

instance BoxedEnum JavascriptError where
    boxedEnumType :: JavascriptError -> IO GType
boxedEnumType _ = IO GType
c_webkit_javascript_error_get_type

-- 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 InsecureContentEventRun = 0
    fromEnum InsecureContentEventDisplayed = 1
    fromEnum (AnotherInsecureContentEvent k :: Int
k) = Int
k

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

instance P.Ord InsecureContentEvent where
    compare :: InsecureContentEvent -> InsecureContentEvent -> Ordering
compare a :: InsecureContentEvent
a b :: 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)

foreign import ccall "webkit_insecure_content_event_get_type" c_webkit_insecure_content_event_get_type :: 
    IO GType

instance BoxedEnum InsecureContentEvent where
    boxedEnumType :: InsecureContentEvent -> IO GType
boxedEnumType _ = IO GType
c_webkit_insecure_content_event_get_type

-- 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 HardwareAccelerationPolicyOnDemand = 0
    fromEnum HardwareAccelerationPolicyAlways = 1
    fromEnum HardwareAccelerationPolicyNever = 2
    fromEnum (AnotherHardwareAccelerationPolicy k :: Int
k) = Int
k

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

instance P.Ord HardwareAccelerationPolicy where
    compare :: HardwareAccelerationPolicy
-> HardwareAccelerationPolicy -> Ordering
compare a :: HardwareAccelerationPolicy
a b :: 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)

foreign import ccall "webkit_hardware_acceleration_policy_get_type" c_webkit_hardware_acceleration_policy_get_type :: 
    IO GType

instance BoxedEnum HardwareAccelerationPolicy where
    boxedEnumType :: HardwareAccelerationPolicy -> IO GType
boxedEnumType _ = IO GType
c_webkit_hardware_acceleration_policy_get_type

-- 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 FaviconDatabaseErrorNotInitialized = 0
    fromEnum FaviconDatabaseErrorFaviconNotFound = 1
    fromEnum FaviconDatabaseErrorFaviconUnknown = 2
    fromEnum (AnotherFaviconDatabaseError k :: Int
k) = Int
k

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

instance P.Ord FaviconDatabaseError where
    compare :: FaviconDatabaseError -> FaviconDatabaseError -> Ordering
compare a :: FaviconDatabaseError
a b :: 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 _ = "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 :: 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 :: (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

foreign import ccall "webkit_favicon_database_error_get_type" c_webkit_favicon_database_error_get_type :: 
    IO GType

instance BoxedEnum FaviconDatabaseError where
    boxedEnumType :: FaviconDatabaseError -> IO GType
boxedEnumType _ = IO GType
c_webkit_favicon_database_error_get_type

-- 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 DownloadErrorNetwork = 499
    fromEnum DownloadErrorCancelledByUser = 400
    fromEnum DownloadErrorDestination = 401
    fromEnum (AnotherDownloadError k :: Int
k) = Int
k

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

instance P.Ord DownloadError where
    compare :: DownloadError -> DownloadError -> Ordering
compare a :: DownloadError
a b :: 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 _ = "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 :: 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 :: (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

foreign import ccall "webkit_download_error_get_type" c_webkit_download_error_get_type :: 
    IO GType

instance BoxedEnum DownloadError where
    boxedEnumType :: DownloadError -> IO GType
boxedEnumType _ = IO GType
c_webkit_download_error_get_type

-- 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 CredentialPersistenceNone = 0
    fromEnum CredentialPersistenceForSession = 1
    fromEnum CredentialPersistencePermanent = 2
    fromEnum (AnotherCredentialPersistence k :: Int
k) = Int
k

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

instance P.Ord CredentialPersistence where
    compare :: CredentialPersistence -> CredentialPersistence -> Ordering
compare a :: CredentialPersistence
a b :: 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)

foreign import ccall "webkit_credential_persistence_get_type" c_webkit_credential_persistence_get_type :: 
    IO GType

instance BoxedEnum CredentialPersistence where
    boxedEnumType :: CredentialPersistence -> IO GType
boxedEnumType _ = IO GType
c_webkit_credential_persistence_get_type

-- 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 CookiePersistentStorageText = 0
    fromEnum CookiePersistentStorageSqlite = 1
    fromEnum (AnotherCookiePersistentStorage k :: Int
k) = Int
k

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

instance P.Ord CookiePersistentStorage where
    compare :: CookiePersistentStorage -> CookiePersistentStorage -> Ordering
compare a :: CookiePersistentStorage
a b :: 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)

foreign import ccall "webkit_cookie_persistent_storage_get_type" c_webkit_cookie_persistent_storage_get_type :: 
    IO GType

instance BoxedEnum CookiePersistentStorage where
    boxedEnumType :: CookiePersistentStorage -> IO GType
boxedEnumType _ = IO GType
c_webkit_cookie_persistent_storage_get_type

-- 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 CookieAcceptPolicyAlways = 0
    fromEnum CookieAcceptPolicyNever = 1
    fromEnum CookieAcceptPolicyNoThirdParty = 2
    fromEnum (AnotherCookieAcceptPolicy k :: Int
k) = Int
k

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

instance P.Ord CookieAcceptPolicy where
    compare :: CookieAcceptPolicy -> CookieAcceptPolicy -> Ordering
compare a :: CookieAcceptPolicy
a b :: 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)

foreign import ccall "webkit_cookie_accept_policy_get_type" c_webkit_cookie_accept_policy_get_type :: 
    IO GType

instance BoxedEnum CookieAcceptPolicy where
    boxedEnumType :: CookieAcceptPolicy -> IO GType
boxedEnumType _ = IO GType
c_webkit_cookie_accept_policy_get_type

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

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

instance P.Ord ContextMenuAction where
    compare :: ContextMenuAction -> ContextMenuAction -> Ordering
compare a :: ContextMenuAction
a b :: 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)

foreign import ccall "webkit_context_menu_action_get_type" c_webkit_context_menu_action_get_type :: 
    IO GType

instance BoxedEnum ContextMenuAction where
    boxedEnumType :: ContextMenuAction -> IO GType
boxedEnumType _ = IO GType
c_webkit_context_menu_action_get_type

-- 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 CacheModelDocumentViewer = 0
    fromEnum CacheModelWebBrowser = 1
    fromEnum CacheModelDocumentBrowser = 2
    fromEnum (AnotherCacheModel k :: Int
k) = Int
k

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

instance P.Ord CacheModel where
    compare :: CacheModel -> CacheModel -> Ordering
compare a :: CacheModel
a b :: 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)

foreign import ccall "webkit_cache_model_get_type" c_webkit_cache_model_get_type :: 
    IO GType

instance BoxedEnum CacheModel where
    boxedEnumType :: CacheModel -> IO GType
boxedEnumType _ = IO GType
c_webkit_cache_model_get_type

-- 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 AuthenticationSchemeDefault = 1
    fromEnum AuthenticationSchemeHttpBasic = 2
    fromEnum AuthenticationSchemeHttpDigest = 3
    fromEnum AuthenticationSchemeHtmlForm = 4
    fromEnum AuthenticationSchemeNtlm = 5
    fromEnum AuthenticationSchemeNegotiate = 6
    fromEnum AuthenticationSchemeClientCertificateRequested = 7
    fromEnum AuthenticationSchemeServerTrustEvaluationRequested = 8
    fromEnum AuthenticationSchemeUnknown = 100
    fromEnum (AnotherAuthenticationScheme k :: Int
k) = Int
k

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

instance P.Ord AuthenticationScheme where
    compare :: AuthenticationScheme -> AuthenticationScheme -> Ordering
compare a :: AuthenticationScheme
a b :: 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)

foreign import ccall "webkit_authentication_scheme_get_type" c_webkit_authentication_scheme_get_type :: 
    IO GType

instance BoxedEnum AuthenticationScheme where
    boxedEnumType :: AuthenticationScheme -> IO GType
boxedEnumType _ = IO GType
c_webkit_authentication_scheme_get_type