{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)
-}

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

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

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

    toEnum 0 = WebProcessTerminationReasonCrashed
    toEnum 1 = WebProcessTerminationReasonExceededMemoryLimit
    toEnum k = AnotherWebProcessTerminationReason k

instance P.Ord WebProcessTerminationReason where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum 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 _ = 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 (Show, Eq)

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

    toEnum 0 = UserStyleLevelUser
    toEnum 1 = UserStyleLevelAuthor
    toEnum k = AnotherUserStyleLevel k

instance P.Ord UserStyleLevel where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "webkit_user_style_level_get_type" c_webkit_user_style_level_get_type :: 
    IO GType

instance BoxedEnum UserStyleLevel where
    boxedEnumType _ = 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 (Show, Eq)

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

    toEnum 0 = UserScriptInjectionTimeStart
    toEnum 1 = UserScriptInjectionTimeEnd
    toEnum k = AnotherUserScriptInjectionTime k

instance P.Ord UserScriptInjectionTime where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum 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 _ = 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 (Show, Eq)

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

    toEnum 0 = UserContentInjectedFramesAllFrames
    toEnum 1 = UserContentInjectedFramesTopFrame
    toEnum k = AnotherUserContentInjectedFrames k

instance P.Ord UserContentInjectedFrames where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum 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 _ = 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 (Show, Eq)

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

    toEnum 0 = UserContentFilterErrorInvalidSource
    toEnum 1 = UserContentFilterErrorNotFound
    toEnum k = AnotherUserContentFilterError k

instance P.Ord UserContentFilterError where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

instance GErrorClass UserContentFilterError where
    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 = 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 = 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 _ = 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
      'GI.WebKit2.Objects.WebView.WebView'::@/load-failed-with-tls-errors/@ and, if the signal is handled,
      finish the load. In case the signal is not handled,
      'GI.WebKit2.Objects.WebView.WebView'::@/load-failed/@ is emitted before the load finishes.
    -}
    | AnotherTLSErrorsPolicy Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

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

    toEnum 0 = TLSErrorsPolicyIgnore
    toEnum 1 = TLSErrorsPolicyFail
    toEnum k = AnotherTLSErrorsPolicy k

instance P.Ord TLSErrorsPolicy where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "webkit_tls_errors_policy_get_type" c_webkit_tls_errors_policy_get_type :: 
    IO GType

instance BoxedEnum TLSErrorsPolicy where
    boxedEnumType _ = c_webkit_tls_errors_policy_get_type

-- Enum SnapshotRegion
{- |
Enum values used to specify the region from which to get a '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 (Show, Eq)

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

    toEnum 0 = SnapshotRegionVisible
    toEnum 1 = SnapshotRegionFullDocument
    toEnum k = AnotherSnapshotRegion k

instance P.Ord SnapshotRegion where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "webkit_snapshot_region_get_type" c_webkit_snapshot_region_get_type :: 
    IO GType

instance BoxedEnum SnapshotRegion where
    boxedEnumType _ = c_webkit_snapshot_region_get_type

-- Enum SnapshotError
{- |
Enum values used to denote errors happening when creating snapshots of 'GI.WebKit2.Objects.WebView.WebView'
-}
data SnapshotError = 
      SnapshotErrorCreate
    {- ^
    An error occurred when creating a webpage snapshot.
    -}
    | AnotherSnapshotError Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum SnapshotError where
    fromEnum SnapshotErrorCreate = 799
    fromEnum (AnotherSnapshotError k) = k

    toEnum 799 = SnapshotErrorCreate
    toEnum k = AnotherSnapshotError k

instance P.Ord SnapshotError where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

instance GErrorClass SnapshotError where
    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 = 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 = handleGErrorJustDomain

foreign import ccall "webkit_snapshot_error_get_type" c_webkit_snapshot_error_get_type :: 
    IO GType

instance BoxedEnum SnapshotError where
    boxedEnumType _ = c_webkit_snapshot_error_get_type

-- Enum ScriptDialogType
{- |
Enum values used for determining the type of '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 (Show, Eq)

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

    toEnum 0 = ScriptDialogTypeAlert
    toEnum 1 = ScriptDialogTypeConfirm
    toEnum 2 = ScriptDialogTypePrompt
    toEnum 3 = ScriptDialogTypeBeforeUnloadConfirm
    toEnum k = AnotherScriptDialogType k

instance P.Ord ScriptDialogType where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "webkit_script_dialog_type_get_type" c_webkit_script_dialog_type_get_type :: 
    IO GType

instance BoxedEnum ScriptDialogType where
    boxedEnumType _ = c_webkit_script_dialog_type_get_type

-- Enum SaveMode
{- |
Enum values to specify the different ways in which a '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 (Show, Eq)

instance P.Enum SaveMode where
    fromEnum SaveModeMhtml = 0
    fromEnum (AnotherSaveMode k) = k

    toEnum 0 = SaveModeMhtml
    toEnum k = AnotherSaveMode k

instance P.Ord SaveMode where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "webkit_save_mode_get_type" c_webkit_save_mode_get_type :: 
    IO GType

instance BoxedEnum SaveMode where
    boxedEnumType _ = c_webkit_save_mode_get_type

-- Enum ProcessModel
{- |
Enum values used for determining the '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
      '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 '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 (Show, Eq)

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

    toEnum 0 = ProcessModelSharedSecondaryProcess
    toEnum 1 = ProcessModelMultipleSecondaryProcesses
    toEnum k = AnotherProcessModel k

instance P.Ord ProcessModel where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "webkit_process_model_get_type" c_webkit_process_model_get_type :: 
    IO GType

instance BoxedEnum ProcessModel where
    boxedEnumType _ = 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 (Show, Eq)

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

    toEnum 0 = PrintOperationResponsePrint
    toEnum 1 = PrintOperationResponseCancel
    toEnum k = AnotherPrintOperationResponse k

instance P.Ord PrintOperationResponse where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "webkit_print_operation_response_get_type" c_webkit_print_operation_response_get_type :: 
    IO GType

instance BoxedEnum PrintOperationResponse where
    boxedEnumType _ = 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 (Show, Eq)

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

    toEnum 599 = PrintErrorGeneral
    toEnum 500 = PrintErrorPrinterNotFound
    toEnum 501 = PrintErrorInvalidPageRange
    toEnum k = AnotherPrintError k

instance P.Ord PrintError where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

instance GErrorClass PrintError where
    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 = 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 = handleGErrorJustDomain

foreign import ccall "webkit_print_error_get_type" c_webkit_print_error_get_type :: 
    IO GType

instance BoxedEnum PrintError where
    boxedEnumType _ = 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 (Show, Eq)

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

    toEnum 199 = PolicyErrorFailed
    toEnum 100 = PolicyErrorCannotShowMimeType
    toEnum 101 = PolicyErrorCannotShowUri
    toEnum 102 = PolicyErrorFrameLoadInterruptedByPolicyChange
    toEnum 103 = PolicyErrorCannotUseRestrictedPort
    toEnum k = AnotherPolicyError k

instance P.Ord PolicyError where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

instance GErrorClass PolicyError where
    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 = 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 = handleGErrorJustDomain

foreign import ccall "webkit_policy_error_get_type" c_webkit_policy_error_get_type :: 
    IO GType

instance BoxedEnum PolicyError where
    boxedEnumType _ = c_webkit_policy_error_get_type

-- Enum PolicyDecisionType
{- |
Enum values used for determining the type of a policy decision during
'GI.WebKit2.Objects.WebView.WebView'::@/decide-policy/@.
-}
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 '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 '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 '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 (Show, Eq)

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

    toEnum 0 = PolicyDecisionTypeNavigationAction
    toEnum 1 = PolicyDecisionTypeNewWindowAction
    toEnum 2 = PolicyDecisionTypeResponse
    toEnum k = AnotherPolicyDecisionType k

instance P.Ord PolicyDecisionType where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "webkit_policy_decision_type_get_type" c_webkit_policy_decision_type_get_type :: 
    IO GType

instance BoxedEnum PolicyDecisionType where
    boxedEnumType _ = 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 (Show, Eq)

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

    toEnum 299 = PluginErrorFailed
    toEnum 200 = PluginErrorCannotFindPlugin
    toEnum 201 = PluginErrorCannotLoadPlugin
    toEnum 202 = PluginErrorJavaUnavailable
    toEnum 203 = PluginErrorConnectionCancelled
    toEnum 204 = PluginErrorWillHandleLoad
    toEnum k = AnotherPluginError k

instance P.Ord PluginError where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

instance GErrorClass PluginError where
    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 = 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 = handleGErrorJustDomain

foreign import ccall "webkit_plugin_error_get_type" c_webkit_plugin_error_get_type :: 
    IO GType

instance BoxedEnum PluginError where
    boxedEnumType _ = 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 (Show, Eq)

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

    toEnum 0 = NetworkProxyModeDefault
    toEnum 1 = NetworkProxyModeNoProxy
    toEnum 2 = NetworkProxyModeCustom
    toEnum k = AnotherNetworkProxyMode k

instance P.Ord NetworkProxyMode where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "webkit_network_proxy_mode_get_type" c_webkit_network_proxy_mode_get_type :: 
    IO GType

instance BoxedEnum NetworkProxyMode where
    boxedEnumType _ = 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 (Show, Eq)

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

    toEnum 399 = NetworkErrorFailed
    toEnum 300 = NetworkErrorTransport
    toEnum 301 = NetworkErrorUnknownProtocol
    toEnum 302 = NetworkErrorCancelled
    toEnum 303 = NetworkErrorFileDoesNotExist
    toEnum k = AnotherNetworkError k

instance P.Ord NetworkError where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

instance GErrorClass NetworkError where
    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 = 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 = handleGErrorJustDomain

foreign import ccall "webkit_network_error_get_type" c_webkit_network_error_get_type :: 
    IO GType

instance BoxedEnum NetworkError where
    boxedEnumType _ = 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 (Show, Eq)

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

    toEnum 0 = NavigationTypeLinkClicked
    toEnum 1 = NavigationTypeFormSubmitted
    toEnum 2 = NavigationTypeBackForward
    toEnum 3 = NavigationTypeReload
    toEnum 4 = NavigationTypeFormResubmitted
    toEnum 5 = NavigationTypeOther
    toEnum k = AnotherNavigationType k

instance P.Ord NavigationType where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "webkit_navigation_type_get_type" c_webkit_navigation_type_get_type :: 
    IO GType

instance BoxedEnum NavigationType where
    boxedEnumType _ = c_webkit_navigation_type_get_type

-- Enum LoadEvent
{- |
Enum values used to denote the different events that happen during a
'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 (Show, Eq)

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

    toEnum 0 = LoadEventStarted
    toEnum 1 = LoadEventRedirected
    toEnum 2 = LoadEventCommitted
    toEnum 3 = LoadEventFinished
    toEnum k = AnotherLoadEvent k

instance P.Ord LoadEvent where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "webkit_load_event_get_type" c_webkit_load_event_get_type :: 
    IO GType

instance BoxedEnum LoadEvent where
    boxedEnumType _ = 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 (Show, Eq)

instance P.Enum JavascriptError where
    fromEnum JavascriptErrorFailed = 699
    fromEnum (AnotherJavascriptError k) = k

    toEnum 699 = JavascriptErrorFailed
    toEnum k = AnotherJavascriptError k

instance P.Ord JavascriptError where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

instance GErrorClass JavascriptError where
    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 = 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 = handleGErrorJustDomain

foreign import ccall "webkit_javascript_error_get_type" c_webkit_javascript_error_get_type :: 
    IO GType

instance BoxedEnum JavascriptError where
    boxedEnumType _ = 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 (Show, Eq)

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

    toEnum 0 = InsecureContentEventRun
    toEnum 1 = InsecureContentEventDisplayed
    toEnum k = AnotherInsecureContentEvent k

instance P.Ord InsecureContentEvent where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "webkit_insecure_content_event_get_type" c_webkit_insecure_content_event_get_type :: 
    IO GType

instance BoxedEnum InsecureContentEvent where
    boxedEnumType _ = 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 (Show, Eq)

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

    toEnum 0 = HardwareAccelerationPolicyOnDemand
    toEnum 1 = HardwareAccelerationPolicyAlways
    toEnum 2 = HardwareAccelerationPolicyNever
    toEnum k = AnotherHardwareAccelerationPolicy k

instance P.Ord HardwareAccelerationPolicy where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "webkit_hardware_acceleration_policy_get_type" c_webkit_hardware_acceleration_policy_get_type :: 
    IO GType

instance BoxedEnum HardwareAccelerationPolicy where
    boxedEnumType _ = c_webkit_hardware_acceleration_policy_get_type

-- Enum FaviconDatabaseError
{- |
Enum values used to denote the various errors related to the 'GI.WebKit2.Objects.FaviconDatabase.FaviconDatabase'.
-}
data FaviconDatabaseError = 
      FaviconDatabaseErrorNotInitialized
    {- ^
    The '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 (Show, Eq)

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

    toEnum 0 = FaviconDatabaseErrorNotInitialized
    toEnum 1 = FaviconDatabaseErrorFaviconNotFound
    toEnum 2 = FaviconDatabaseErrorFaviconUnknown
    toEnum k = AnotherFaviconDatabaseError k

instance P.Ord FaviconDatabaseError where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

instance GErrorClass FaviconDatabaseError where
    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 = 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 = handleGErrorJustDomain

foreign import ccall "webkit_favicon_database_error_get_type" c_webkit_favicon_database_error_get_type :: 
    IO GType

instance BoxedEnum FaviconDatabaseError where
    boxedEnumType _ = 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 (Show, Eq)

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

    toEnum 499 = DownloadErrorNetwork
    toEnum 400 = DownloadErrorCancelledByUser
    toEnum 401 = DownloadErrorDestination
    toEnum k = AnotherDownloadError k

instance P.Ord DownloadError where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

instance GErrorClass DownloadError where
    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 = 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 = handleGErrorJustDomain

foreign import ccall "webkit_download_error_get_type" c_webkit_download_error_get_type :: 
    IO GType

instance BoxedEnum DownloadError where
    boxedEnumType _ = 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 (Show, Eq)

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

    toEnum 0 = CredentialPersistenceNone
    toEnum 1 = CredentialPersistenceForSession
    toEnum 2 = CredentialPersistencePermanent
    toEnum k = AnotherCredentialPersistence k

instance P.Ord CredentialPersistence where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "webkit_credential_persistence_get_type" c_webkit_credential_persistence_get_type :: 
    IO GType

instance BoxedEnum CredentialPersistence where
    boxedEnumType _ = 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 (Show, Eq)

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

    toEnum 0 = CookiePersistentStorageText
    toEnum 1 = CookiePersistentStorageSqlite
    toEnum k = AnotherCookiePersistentStorage k

instance P.Ord CookiePersistentStorage where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "webkit_cookie_persistent_storage_get_type" c_webkit_cookie_persistent_storage_get_type :: 
    IO GType

instance BoxedEnum CookiePersistentStorage where
    boxedEnumType _ = 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 (Show, Eq)

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

    toEnum 0 = CookieAcceptPolicyAlways
    toEnum 1 = CookieAcceptPolicyNever
    toEnum 2 = CookieAcceptPolicyNoThirdParty
    toEnum k = AnotherCookieAcceptPolicy k

instance P.Ord CookieAcceptPolicy where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "webkit_cookie_accept_policy_get_type" c_webkit_cookie_accept_policy_get_type :: 
    IO GType

instance BoxedEnum CookieAcceptPolicy where
    boxedEnumType _ = c_webkit_cookie_accept_policy_get_type

-- Enum ContextMenuAction
{- |
Enum values used to denote the stock actions for
'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 (Show, Eq)

instance P.Enum ContextMenuAction where
    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) = k

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

instance P.Ord ContextMenuAction where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "webkit_context_menu_action_get_type" c_webkit_context_menu_action_get_type :: 
    IO GType

instance BoxedEnum ContextMenuAction where
    boxedEnumType _ = c_webkit_context_menu_action_get_type

-- Enum CacheModel
{- |
Enum values used for determining the '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 (Show, Eq)

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

    toEnum 0 = CacheModelDocumentViewer
    toEnum 1 = CacheModelWebBrowser
    toEnum 2 = CacheModelDocumentBrowser
    toEnum k = AnotherCacheModel k

instance P.Ord CacheModel where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "webkit_cache_model_get_type" c_webkit_cache_model_get_type :: 
    IO GType

instance BoxedEnum CacheModel where
    boxedEnumType _ = 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 (Show, Eq)

instance P.Enum AuthenticationScheme where
    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) = k

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

instance P.Ord AuthenticationScheme where
    compare a b = P.compare (P.fromEnum a) (P.fromEnum b)

foreign import ccall "webkit_authentication_scheme_get_type" c_webkit_authentication_scheme_get_type :: 
    IO GType

instance BoxedEnum AuthenticationScheme where
    boxedEnumType _ = c_webkit_authentication_scheme_get_type