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

module GI.GLib.Enums
    ( 

 -- * Enumerations
-- ** BookmarkFileError #enum:BookmarkFileError#

    BookmarkFileError(..)                   ,
    catchBookmarkFileError                  ,
    handleBookmarkFileError                 ,


-- ** ChecksumType #enum:ChecksumType#

    ChecksumType(..)                        ,


-- ** ConvertError #enum:ConvertError#

    ConvertError(..)                        ,
    catchConvertError                       ,
    handleConvertError                      ,


-- ** DateDMY #enum:DateDMY#

    DateDMY(..)                             ,


-- ** DateMonth #enum:DateMonth#

    DateMonth(..)                           ,


-- ** DateWeekday #enum:DateWeekday#

    DateWeekday(..)                         ,


-- ** ErrorType #enum:ErrorType#

    ErrorType(..)                           ,


-- ** FileError #enum:FileError#

    FileError(..)                           ,
    catchFileError                          ,
    handleFileError                         ,


-- ** IOChannelError #enum:IOChannelError#

    IOChannelError(..)                      ,
    catchIOChannelError                     ,
    handleIOChannelError                    ,


-- ** IOError #enum:IOError#

    IOError(..)                             ,


-- ** IOStatus #enum:IOStatus#

    IOStatus(..)                            ,


-- ** KeyFileError #enum:KeyFileError#

    KeyFileError(..)                        ,
    catchKeyFileError                       ,
    handleKeyFileError                      ,


-- ** LogWriterOutput #enum:LogWriterOutput#

    LogWriterOutput(..)                     ,


-- ** MarkupError #enum:MarkupError#

    MarkupError(..)                         ,
    catchMarkupError                        ,
    handleMarkupError                       ,


-- ** NormalizeMode #enum:NormalizeMode#

    NormalizeMode(..)                       ,


-- ** NumberParserError #enum:NumberParserError#

    NumberParserError(..)                   ,
    catchNumberParserError                  ,
    handleNumberParserError                 ,


-- ** OnceStatus #enum:OnceStatus#

    OnceStatus(..)                          ,


-- ** OptionArg #enum:OptionArg#

    OptionArg(..)                           ,


-- ** OptionError #enum:OptionError#

    OptionError(..)                         ,
    catchOptionError                        ,
    handleOptionError                       ,


-- ** RegexError #enum:RegexError#

    RegexError(..)                          ,
    catchRegexError                         ,
    handleRegexError                        ,


-- ** SeekType #enum:SeekType#

    SeekType(..)                            ,


-- ** ShellError #enum:ShellError#

    ShellError(..)                          ,
    catchShellError                         ,
    handleShellError                        ,


-- ** SliceConfig #enum:SliceConfig#

    SliceConfig(..)                         ,


-- ** SpawnError #enum:SpawnError#

    SpawnError(..)                          ,
    catchSpawnError                         ,
    handleSpawnError                        ,


-- ** TestFileType #enum:TestFileType#

    TestFileType(..)                        ,


-- ** TestLogType #enum:TestLogType#

    TestLogType(..)                         ,


-- ** ThreadError #enum:ThreadError#

    ThreadError(..)                         ,
    catchThreadError                        ,
    handleThreadError                       ,


-- ** TimeType #enum:TimeType#

    TimeType(..)                            ,


-- ** TokenType #enum:TokenType#

    TokenType(..)                           ,


-- ** TraverseType #enum:TraverseType#

    TraverseType(..)                        ,


-- ** UnicodeBreakType #enum:UnicodeBreakType#

    UnicodeBreakType(..)                    ,


-- ** UnicodeScript #enum:UnicodeScript#

    UnicodeScript(..)                       ,


-- ** UnicodeType #enum:UnicodeType#

    UnicodeType(..)                         ,


-- ** UserDirectory #enum:UserDirectory#

    UserDirectory(..)                       ,


-- ** VariantClass #enum:VariantClass#

    VariantClass(..)                        ,


-- ** VariantParseError #enum:VariantParseError#

    VariantParseError(..)                   ,
    catchVariantParseError                  ,
    handleVariantParseError                 ,




    ) where

import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP


-- Enum VariantParseError
{- |
Error codes returned by parsing text-format GVariants.
-}
data VariantParseError = 
      VariantParseErrorFailed
    {- ^
    generic error (unused)
    -}
    | VariantParseErrorBasicTypeExpected
    {- ^
    a non-basic 'GI.GLib.Structs.VariantType.VariantType' was given where a basic type was expected
    -}
    | VariantParseErrorCannotInferType
    {- ^
    cannot infer the 'GI.GLib.Structs.VariantType.VariantType'
    -}
    | VariantParseErrorDefiniteTypeExpected
    {- ^
    an indefinite 'GI.GLib.Structs.VariantType.VariantType' was given where a definite type was expected
    -}
    | VariantParseErrorInputNotAtEnd
    {- ^
    extra data after parsing finished
    -}
    | VariantParseErrorInvalidCharacter
    {- ^
    invalid character in number or unicode escape
    -}
    | VariantParseErrorInvalidFormatString
    {- ^
    not a valid 'GVariant' format string
    -}
    | VariantParseErrorInvalidObjectPath
    {- ^
    not a valid object path
    -}
    | VariantParseErrorInvalidSignature
    {- ^
    not a valid type signature
    -}
    | VariantParseErrorInvalidTypeString
    {- ^
    not a valid 'GVariant' type string
    -}
    | VariantParseErrorNoCommonType
    {- ^
    could not find a common type for array entries
    -}
    | VariantParseErrorNumberOutOfRange
    {- ^
    the numerical value is out of range of the given type
    -}
    | VariantParseErrorNumberTooBig
    {- ^
    the numerical value is out of range for any type
    -}
    | VariantParseErrorTypeError
    {- ^
    cannot parse as variant of the specified type
    -}
    | VariantParseErrorUnexpectedToken
    {- ^
    an unexpected token was encountered
    -}
    | VariantParseErrorUnknownKeyword
    {- ^
    an unknown keyword was encountered
    -}
    | VariantParseErrorUnterminatedStringConstant
    {- ^
    unterminated string constant
    -}
    | VariantParseErrorValueExpected
    {- ^
    no value given
    -}
    | AnotherVariantParseError Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum VariantParseError where
    fromEnum VariantParseErrorFailed = 0
    fromEnum VariantParseErrorBasicTypeExpected = 1
    fromEnum VariantParseErrorCannotInferType = 2
    fromEnum VariantParseErrorDefiniteTypeExpected = 3
    fromEnum VariantParseErrorInputNotAtEnd = 4
    fromEnum VariantParseErrorInvalidCharacter = 5
    fromEnum VariantParseErrorInvalidFormatString = 6
    fromEnum VariantParseErrorInvalidObjectPath = 7
    fromEnum VariantParseErrorInvalidSignature = 8
    fromEnum VariantParseErrorInvalidTypeString = 9
    fromEnum VariantParseErrorNoCommonType = 10
    fromEnum VariantParseErrorNumberOutOfRange = 11
    fromEnum VariantParseErrorNumberTooBig = 12
    fromEnum VariantParseErrorTypeError = 13
    fromEnum VariantParseErrorUnexpectedToken = 14
    fromEnum VariantParseErrorUnknownKeyword = 15
    fromEnum VariantParseErrorUnterminatedStringConstant = 16
    fromEnum VariantParseErrorValueExpected = 17
    fromEnum (AnotherVariantParseError k) = k

    toEnum 0 = VariantParseErrorFailed
    toEnum 1 = VariantParseErrorBasicTypeExpected
    toEnum 2 = VariantParseErrorCannotInferType
    toEnum 3 = VariantParseErrorDefiniteTypeExpected
    toEnum 4 = VariantParseErrorInputNotAtEnd
    toEnum 5 = VariantParseErrorInvalidCharacter
    toEnum 6 = VariantParseErrorInvalidFormatString
    toEnum 7 = VariantParseErrorInvalidObjectPath
    toEnum 8 = VariantParseErrorInvalidSignature
    toEnum 9 = VariantParseErrorInvalidTypeString
    toEnum 10 = VariantParseErrorNoCommonType
    toEnum 11 = VariantParseErrorNumberOutOfRange
    toEnum 12 = VariantParseErrorNumberTooBig
    toEnum 13 = VariantParseErrorTypeError
    toEnum 14 = VariantParseErrorUnexpectedToken
    toEnum 15 = VariantParseErrorUnknownKeyword
    toEnum 16 = VariantParseErrorUnterminatedStringConstant
    toEnum 17 = VariantParseErrorValueExpected
    toEnum k = AnotherVariantParseError k

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

instance GErrorClass VariantParseError where
    gerrorClassDomain _ = "g-variant-parse-error-quark"

-- | Catch exceptions of type `VariantParseError`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`.
catchVariantParseError ::
    IO a ->
    (VariantParseError -> GErrorMessage -> IO a) ->
    IO a
catchVariantParseError = catchGErrorJustDomain

-- | Handle exceptions of type `VariantParseError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`.
handleVariantParseError ::
    (VariantParseError -> GErrorMessage -> IO a) ->
    IO a ->
    IO a
handleVariantParseError = handleGErrorJustDomain

-- Enum VariantClass
{- |
The range of possible top-level types of 'GVariant' instances.

@since 2.24
-}
data VariantClass = 
      VariantClassBoolean
    {- ^
    The 'GVariant' is a boolean.
    -}
    | VariantClassByte
    {- ^
    The 'GVariant' is a byte.
    -}
    | VariantClassInt16
    {- ^
    The 'GVariant' is a signed 16 bit integer.
    -}
    | VariantClassUint16
    {- ^
    The 'GVariant' is an unsigned 16 bit integer.
    -}
    | VariantClassInt32
    {- ^
    The 'GVariant' is a signed 32 bit integer.
    -}
    | VariantClassUint32
    {- ^
    The 'GVariant' is an unsigned 32 bit integer.
    -}
    | VariantClassInt64
    {- ^
    The 'GVariant' is a signed 64 bit integer.
    -}
    | VariantClassUint64
    {- ^
    The 'GVariant' is an unsigned 64 bit integer.
    -}
    | VariantClassHandle
    {- ^
    The 'GVariant' is a file handle index.
    -}
    | VariantClassDouble
    {- ^
    The 'GVariant' is a double precision floating
                             point value.
    -}
    | VariantClassString
    {- ^
    The 'GVariant' is a normal string.
    -}
    | VariantClassObjectPath
    {- ^
    The 'GVariant' is a D-Bus object path
                                  string.
    -}
    | VariantClassSignature
    {- ^
    The 'GVariant' is a D-Bus signature string.
    -}
    | VariantClassVariant
    {- ^
    The 'GVariant' is a variant.
    -}
    | VariantClassMaybe
    {- ^
    The 'GVariant' is a maybe-typed value.
    -}
    | VariantClassArray
    {- ^
    The 'GVariant' is an array.
    -}
    | VariantClassTuple
    {- ^
    The 'GVariant' is a tuple.
    -}
    | VariantClassDictEntry
    {- ^
    The 'GVariant' is a dictionary entry.
    -}
    | AnotherVariantClass Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum VariantClass where
    fromEnum VariantClassBoolean = 98
    fromEnum VariantClassByte = 121
    fromEnum VariantClassInt16 = 110
    fromEnum VariantClassUint16 = 113
    fromEnum VariantClassInt32 = 105
    fromEnum VariantClassUint32 = 117
    fromEnum VariantClassInt64 = 120
    fromEnum VariantClassUint64 = 116
    fromEnum VariantClassHandle = 104
    fromEnum VariantClassDouble = 100
    fromEnum VariantClassString = 115
    fromEnum VariantClassObjectPath = 111
    fromEnum VariantClassSignature = 103
    fromEnum VariantClassVariant = 118
    fromEnum VariantClassMaybe = 109
    fromEnum VariantClassArray = 97
    fromEnum VariantClassTuple = 40
    fromEnum VariantClassDictEntry = 123
    fromEnum (AnotherVariantClass k) = k

    toEnum 98 = VariantClassBoolean
    toEnum 121 = VariantClassByte
    toEnum 110 = VariantClassInt16
    toEnum 113 = VariantClassUint16
    toEnum 105 = VariantClassInt32
    toEnum 117 = VariantClassUint32
    toEnum 120 = VariantClassInt64
    toEnum 116 = VariantClassUint64
    toEnum 104 = VariantClassHandle
    toEnum 100 = VariantClassDouble
    toEnum 115 = VariantClassString
    toEnum 111 = VariantClassObjectPath
    toEnum 103 = VariantClassSignature
    toEnum 118 = VariantClassVariant
    toEnum 109 = VariantClassMaybe
    toEnum 97 = VariantClassArray
    toEnum 40 = VariantClassTuple
    toEnum 123 = VariantClassDictEntry
    toEnum k = AnotherVariantClass k

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

-- Enum UserDirectory
{- |
These are logical ids for special directories which are defined
depending on the platform used. You should use 'GI.GLib.Functions.getUserSpecialDir'
to retrieve the full path associated to the logical id.

The 'GI.GLib.Enums.UserDirectory' enumeration can be extended at later date. Not
every platform has a directory for every logical id in this
enumeration.

@since 2.14
-}
data UserDirectory = 
      UserDirectoryDirectoryDesktop
    {- ^
    the user\'s Desktop directory
    -}
    | UserDirectoryDirectoryDocuments
    {- ^
    the user\'s Documents directory
    -}
    | UserDirectoryDirectoryDownload
    {- ^
    the user\'s Downloads directory
    -}
    | UserDirectoryDirectoryMusic
    {- ^
    the user\'s Music directory
    -}
    | UserDirectoryDirectoryPictures
    {- ^
    the user\'s Pictures directory
    -}
    | UserDirectoryDirectoryPublicShare
    {- ^
    the user\'s shared directory
    -}
    | UserDirectoryDirectoryTemplates
    {- ^
    the user\'s Templates directory
    -}
    | UserDirectoryDirectoryVideos
    {- ^
    the user\'s Movies directory
    -}
    | UserDirectoryNDirectories
    {- ^
    the number of enum values
    -}
    | AnotherUserDirectory Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum UserDirectory where
    fromEnum UserDirectoryDirectoryDesktop = 0
    fromEnum UserDirectoryDirectoryDocuments = 1
    fromEnum UserDirectoryDirectoryDownload = 2
    fromEnum UserDirectoryDirectoryMusic = 3
    fromEnum UserDirectoryDirectoryPictures = 4
    fromEnum UserDirectoryDirectoryPublicShare = 5
    fromEnum UserDirectoryDirectoryTemplates = 6
    fromEnum UserDirectoryDirectoryVideos = 7
    fromEnum UserDirectoryNDirectories = 8
    fromEnum (AnotherUserDirectory k) = k

    toEnum 0 = UserDirectoryDirectoryDesktop
    toEnum 1 = UserDirectoryDirectoryDocuments
    toEnum 2 = UserDirectoryDirectoryDownload
    toEnum 3 = UserDirectoryDirectoryMusic
    toEnum 4 = UserDirectoryDirectoryPictures
    toEnum 5 = UserDirectoryDirectoryPublicShare
    toEnum 6 = UserDirectoryDirectoryTemplates
    toEnum 7 = UserDirectoryDirectoryVideos
    toEnum 8 = UserDirectoryNDirectories
    toEnum k = AnotherUserDirectory k

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

-- Enum UnicodeType
{- |
These are the possible character classifications from the
Unicode specification.
See <http://www.unicode.org/reports/tr44/#General_Category_Values Unicode Character Database>.
-}
data UnicodeType = 
      UnicodeTypeControl
    {- ^
    General category \"Other, Control\" (Cc)
    -}
    | UnicodeTypeFormat
    {- ^
    General category \"Other, Format\" (Cf)
    -}
    | UnicodeTypeUnassigned
    {- ^
    General category \"Other, Not Assigned\" (Cn)
    -}
    | UnicodeTypePrivateUse
    {- ^
    General category \"Other, Private Use\" (Co)
    -}
    | UnicodeTypeSurrogate
    {- ^
    General category \"Other, Surrogate\" (Cs)
    -}
    | UnicodeTypeLowercaseLetter
    {- ^
    General category \"Letter, Lowercase\" (Ll)
    -}
    | UnicodeTypeModifierLetter
    {- ^
    General category \"Letter, Modifier\" (Lm)
    -}
    | UnicodeTypeOtherLetter
    {- ^
    General category \"Letter, Other\" (Lo)
    -}
    | UnicodeTypeTitlecaseLetter
    {- ^
    General category \"Letter, Titlecase\" (Lt)
    -}
    | UnicodeTypeUppercaseLetter
    {- ^
    General category \"Letter, Uppercase\" (Lu)
    -}
    | UnicodeTypeSpacingMark
    {- ^
    General category \"Mark, Spacing\" (Mc)
    -}
    | UnicodeTypeEnclosingMark
    {- ^
    General category \"Mark, Enclosing\" (Me)
    -}
    | UnicodeTypeNonSpacingMark
    {- ^
    General category \"Mark, Nonspacing\" (Mn)
    -}
    | UnicodeTypeDecimalNumber
    {- ^
    General category \"Number, Decimal Digit\" (Nd)
    -}
    | UnicodeTypeLetterNumber
    {- ^
    General category \"Number, Letter\" (Nl)
    -}
    | UnicodeTypeOtherNumber
    {- ^
    General category \"Number, Other\" (No)
    -}
    | UnicodeTypeConnectPunctuation
    {- ^
    General category \"Punctuation, Connector\" (Pc)
    -}
    | UnicodeTypeDashPunctuation
    {- ^
    General category \"Punctuation, Dash\" (Pd)
    -}
    | UnicodeTypeClosePunctuation
    {- ^
    General category \"Punctuation, Close\" (Pe)
    -}
    | UnicodeTypeFinalPunctuation
    {- ^
    General category \"Punctuation, Final quote\" (Pf)
    -}
    | UnicodeTypeInitialPunctuation
    {- ^
    General category \"Punctuation, Initial quote\" (Pi)
    -}
    | UnicodeTypeOtherPunctuation
    {- ^
    General category \"Punctuation, Other\" (Po)
    -}
    | UnicodeTypeOpenPunctuation
    {- ^
    General category \"Punctuation, Open\" (Ps)
    -}
    | UnicodeTypeCurrencySymbol
    {- ^
    General category \"Symbol, Currency\" (Sc)
    -}
    | UnicodeTypeModifierSymbol
    {- ^
    General category \"Symbol, Modifier\" (Sk)
    -}
    | UnicodeTypeMathSymbol
    {- ^
    General category \"Symbol, Math\" (Sm)
    -}
    | UnicodeTypeOtherSymbol
    {- ^
    General category \"Symbol, Other\" (So)
    -}
    | UnicodeTypeLineSeparator
    {- ^
    General category \"Separator, Line\" (Zl)
    -}
    | UnicodeTypeParagraphSeparator
    {- ^
    General category \"Separator, Paragraph\" (Zp)
    -}
    | UnicodeTypeSpaceSeparator
    {- ^
    General category \"Separator, Space\" (Zs)
    -}
    | AnotherUnicodeType Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum UnicodeType where
    fromEnum UnicodeTypeControl = 0
    fromEnum UnicodeTypeFormat = 1
    fromEnum UnicodeTypeUnassigned = 2
    fromEnum UnicodeTypePrivateUse = 3
    fromEnum UnicodeTypeSurrogate = 4
    fromEnum UnicodeTypeLowercaseLetter = 5
    fromEnum UnicodeTypeModifierLetter = 6
    fromEnum UnicodeTypeOtherLetter = 7
    fromEnum UnicodeTypeTitlecaseLetter = 8
    fromEnum UnicodeTypeUppercaseLetter = 9
    fromEnum UnicodeTypeSpacingMark = 10
    fromEnum UnicodeTypeEnclosingMark = 11
    fromEnum UnicodeTypeNonSpacingMark = 12
    fromEnum UnicodeTypeDecimalNumber = 13
    fromEnum UnicodeTypeLetterNumber = 14
    fromEnum UnicodeTypeOtherNumber = 15
    fromEnum UnicodeTypeConnectPunctuation = 16
    fromEnum UnicodeTypeDashPunctuation = 17
    fromEnum UnicodeTypeClosePunctuation = 18
    fromEnum UnicodeTypeFinalPunctuation = 19
    fromEnum UnicodeTypeInitialPunctuation = 20
    fromEnum UnicodeTypeOtherPunctuation = 21
    fromEnum UnicodeTypeOpenPunctuation = 22
    fromEnum UnicodeTypeCurrencySymbol = 23
    fromEnum UnicodeTypeModifierSymbol = 24
    fromEnum UnicodeTypeMathSymbol = 25
    fromEnum UnicodeTypeOtherSymbol = 26
    fromEnum UnicodeTypeLineSeparator = 27
    fromEnum UnicodeTypeParagraphSeparator = 28
    fromEnum UnicodeTypeSpaceSeparator = 29
    fromEnum (AnotherUnicodeType k) = k

    toEnum 0 = UnicodeTypeControl
    toEnum 1 = UnicodeTypeFormat
    toEnum 2 = UnicodeTypeUnassigned
    toEnum 3 = UnicodeTypePrivateUse
    toEnum 4 = UnicodeTypeSurrogate
    toEnum 5 = UnicodeTypeLowercaseLetter
    toEnum 6 = UnicodeTypeModifierLetter
    toEnum 7 = UnicodeTypeOtherLetter
    toEnum 8 = UnicodeTypeTitlecaseLetter
    toEnum 9 = UnicodeTypeUppercaseLetter
    toEnum 10 = UnicodeTypeSpacingMark
    toEnum 11 = UnicodeTypeEnclosingMark
    toEnum 12 = UnicodeTypeNonSpacingMark
    toEnum 13 = UnicodeTypeDecimalNumber
    toEnum 14 = UnicodeTypeLetterNumber
    toEnum 15 = UnicodeTypeOtherNumber
    toEnum 16 = UnicodeTypeConnectPunctuation
    toEnum 17 = UnicodeTypeDashPunctuation
    toEnum 18 = UnicodeTypeClosePunctuation
    toEnum 19 = UnicodeTypeFinalPunctuation
    toEnum 20 = UnicodeTypeInitialPunctuation
    toEnum 21 = UnicodeTypeOtherPunctuation
    toEnum 22 = UnicodeTypeOpenPunctuation
    toEnum 23 = UnicodeTypeCurrencySymbol
    toEnum 24 = UnicodeTypeModifierSymbol
    toEnum 25 = UnicodeTypeMathSymbol
    toEnum 26 = UnicodeTypeOtherSymbol
    toEnum 27 = UnicodeTypeLineSeparator
    toEnum 28 = UnicodeTypeParagraphSeparator
    toEnum 29 = UnicodeTypeSpaceSeparator
    toEnum k = AnotherUnicodeType k

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

-- Enum UnicodeScript
{- |
The 'GI.GLib.Enums.UnicodeScript' enumeration identifies different writing
systems. The values correspond to the names as defined in the
Unicode standard. The enumeration has been added in GLib 2.14,
and is interchangeable with @/PangoScript/@.

Note that new types may be added in the future. Applications
should be ready to handle unknown values.
See <http://www.unicode.org/reports/tr24/ Unicode Standard Annex #24: Script names>.
-}
data UnicodeScript = 
      UnicodeScriptInvalidCode
    {- ^
    a value never returned from 'GI.GLib.Functions.unicharGetScript'
    -}
    | UnicodeScriptCommon
    {- ^
    a character used by multiple different scripts
    -}
    | UnicodeScriptInherited
    {- ^
    a mark glyph that takes its script from the
                                  base glyph to which it is attached
    -}
    | UnicodeScriptArabic
    {- ^
    Arabic
    -}
    | UnicodeScriptArmenian
    {- ^
    Armenian
    -}
    | UnicodeScriptBengali
    {- ^
    Bengali
    -}
    | UnicodeScriptBopomofo
    {- ^
    Bopomofo
    -}
    | UnicodeScriptCherokee
    {- ^
    Cherokee
    -}
    | UnicodeScriptCoptic
    {- ^
    Coptic
    -}
    | UnicodeScriptCyrillic
    {- ^
    Cyrillic
    -}
    | UnicodeScriptDeseret
    {- ^
    Deseret
    -}
    | UnicodeScriptDevanagari
    {- ^
    Devanagari
    -}
    | UnicodeScriptEthiopic
    {- ^
    Ethiopic
    -}
    | UnicodeScriptGeorgian
    {- ^
    Georgian
    -}
    | UnicodeScriptGothic
    {- ^
    Gothic
    -}
    | UnicodeScriptGreek
    {- ^
    Greek
    -}
    | UnicodeScriptGujarati
    {- ^
    Gujarati
    -}
    | UnicodeScriptGurmukhi
    {- ^
    Gurmukhi
    -}
    | UnicodeScriptHan
    {- ^
    Han
    -}
    | UnicodeScriptHangul
    {- ^
    Hangul
    -}
    | UnicodeScriptHebrew
    {- ^
    Hebrew
    -}
    | UnicodeScriptHiragana
    {- ^
    Hiragana
    -}
    | UnicodeScriptKannada
    {- ^
    Kannada
    -}
    | UnicodeScriptKatakana
    {- ^
    Katakana
    -}
    | UnicodeScriptKhmer
    {- ^
    Khmer
    -}
    | UnicodeScriptLao
    {- ^
    Lao
    -}
    | UnicodeScriptLatin
    {- ^
    Latin
    -}
    | UnicodeScriptMalayalam
    {- ^
    Malayalam
    -}
    | UnicodeScriptMongolian
    {- ^
    Mongolian
    -}
    | UnicodeScriptMyanmar
    {- ^
    Myanmar
    -}
    | UnicodeScriptOgham
    {- ^
    Ogham
    -}
    | UnicodeScriptOldItalic
    {- ^
    Old Italic
    -}
    | UnicodeScriptOriya
    {- ^
    Oriya
    -}
    | UnicodeScriptRunic
    {- ^
    Runic
    -}
    | UnicodeScriptSinhala
    {- ^
    Sinhala
    -}
    | UnicodeScriptSyriac
    {- ^
    Syriac
    -}
    | UnicodeScriptTamil
    {- ^
    Tamil
    -}
    | UnicodeScriptTelugu
    {- ^
    Telugu
    -}
    | UnicodeScriptThaana
    {- ^
    Thaana
    -}
    | UnicodeScriptThai
    {- ^
    Thai
    -}
    | UnicodeScriptTibetan
    {- ^
    Tibetan
    -}
    | UnicodeScriptCanadianAboriginal
    {- ^
    Canadian Aboriginal
    -}
    | UnicodeScriptYi
    {- ^
    Yi
    -}
    | UnicodeScriptTagalog
    {- ^
    Tagalog
    -}
    | UnicodeScriptHanunoo
    {- ^
    Hanunoo
    -}
    | UnicodeScriptBuhid
    {- ^
    Buhid
    -}
    | UnicodeScriptTagbanwa
    {- ^
    Tagbanwa
    -}
    | UnicodeScriptBraille
    {- ^
    Braille
    -}
    | UnicodeScriptCypriot
    {- ^
    Cypriot
    -}
    | UnicodeScriptLimbu
    {- ^
    Limbu
    -}
    | UnicodeScriptOsmanya
    {- ^
    Osmanya
    -}
    | UnicodeScriptShavian
    {- ^
    Shavian
    -}
    | UnicodeScriptLinearB
    {- ^
    Linear B
    -}
    | UnicodeScriptTaiLe
    {- ^
    Tai Le
    -}
    | UnicodeScriptUgaritic
    {- ^
    Ugaritic
    -}
    | UnicodeScriptNewTaiLue
    {- ^
    New Tai Lue
    -}
    | UnicodeScriptBuginese
    {- ^
    Buginese
    -}
    | UnicodeScriptGlagolitic
    {- ^
    Glagolitic
    -}
    | UnicodeScriptTifinagh
    {- ^
    Tifinagh
    -}
    | UnicodeScriptSylotiNagri
    {- ^
    Syloti Nagri
    -}
    | UnicodeScriptOldPersian
    {- ^
    Old Persian
    -}
    | UnicodeScriptKharoshthi
    {- ^
    Kharoshthi
    -}
    | UnicodeScriptUnknown
    {- ^
    an unassigned code point
    -}
    | UnicodeScriptBalinese
    {- ^
    Balinese
    -}
    | UnicodeScriptCuneiform
    {- ^
    Cuneiform
    -}
    | UnicodeScriptPhoenician
    {- ^
    Phoenician
    -}
    | UnicodeScriptPhagsPa
    {- ^
    Phags-pa
    -}
    | UnicodeScriptNko
    {- ^
    N\'Ko
    -}
    | UnicodeScriptKayahLi
    {- ^
    Kayah Li. Since 2.16.3
    -}
    | UnicodeScriptLepcha
    {- ^
    Lepcha. Since 2.16.3
    -}
    | UnicodeScriptRejang
    {- ^
    Rejang. Since 2.16.3
    -}
    | UnicodeScriptSundanese
    {- ^
    Sundanese. Since 2.16.3
    -}
    | UnicodeScriptSaurashtra
    {- ^
    Saurashtra. Since 2.16.3
    -}
    | UnicodeScriptCham
    {- ^
    Cham. Since 2.16.3
    -}
    | UnicodeScriptOlChiki
    {- ^
    Ol Chiki. Since 2.16.3
    -}
    | UnicodeScriptVai
    {- ^
    Vai. Since 2.16.3
    -}
    | UnicodeScriptCarian
    {- ^
    Carian. Since 2.16.3
    -}
    | UnicodeScriptLycian
    {- ^
    Lycian. Since 2.16.3
    -}
    | UnicodeScriptLydian
    {- ^
    Lydian. Since 2.16.3
    -}
    | UnicodeScriptAvestan
    {- ^
    Avestan. Since 2.26
    -}
    | UnicodeScriptBamum
    {- ^
    Bamum. Since 2.26
    -}
    | UnicodeScriptEgyptianHieroglyphs
    {- ^
    Egyptian Hieroglpyhs. Since 2.26
    -}
    | UnicodeScriptImperialAramaic
    {- ^
    Imperial Aramaic. Since 2.26
    -}
    | UnicodeScriptInscriptionalPahlavi
    {- ^
    Inscriptional Pahlavi. Since 2.26
    -}
    | UnicodeScriptInscriptionalParthian
    {- ^
    Inscriptional Parthian. Since 2.26
    -}
    | UnicodeScriptJavanese
    {- ^
    Javanese. Since 2.26
    -}
    | UnicodeScriptKaithi
    {- ^
    Kaithi. Since 2.26
    -}
    | UnicodeScriptLisu
    {- ^
    Lisu. Since 2.26
    -}
    | UnicodeScriptMeeteiMayek
    {- ^
    Meetei Mayek. Since 2.26
    -}
    | UnicodeScriptOldSouthArabian
    {- ^
    Old South Arabian. Since 2.26
    -}
    | UnicodeScriptOldTurkic
    {- ^
    Old Turkic. Since 2.28
    -}
    | UnicodeScriptSamaritan
    {- ^
    Samaritan. Since 2.26
    -}
    | UnicodeScriptTaiTham
    {- ^
    Tai Tham. Since 2.26
    -}
    | UnicodeScriptTaiViet
    {- ^
    Tai Viet. Since 2.26
    -}
    | UnicodeScriptBatak
    {- ^
    Batak. Since 2.28
    -}
    | UnicodeScriptBrahmi
    {- ^
    Brahmi. Since 2.28
    -}
    | UnicodeScriptMandaic
    {- ^
    Mandaic. Since 2.28
    -}
    | UnicodeScriptChakma
    {- ^
    Chakma. Since: 2.32
    -}
    | UnicodeScriptMeroiticCursive
    {- ^
    Meroitic Cursive. Since: 2.32
    -}
    | UnicodeScriptMeroiticHieroglyphs
    {- ^
    Meroitic Hieroglyphs. Since: 2.32
    -}
    | UnicodeScriptMiao
    {- ^
    Miao. Since: 2.32
    -}
    | UnicodeScriptSharada
    {- ^
    Sharada. Since: 2.32
    -}
    | UnicodeScriptSoraSompeng
    {- ^
    Sora Sompeng. Since: 2.32
    -}
    | UnicodeScriptTakri
    {- ^
    Takri. Since: 2.32
    -}
    | UnicodeScriptBassaVah
    {- ^
    Bassa. Since: 2.42
    -}
    | UnicodeScriptCaucasianAlbanian
    {- ^
    Caucasian Albanian. Since: 2.42
    -}
    | UnicodeScriptDuployan
    {- ^
    Duployan. Since: 2.42
    -}
    | UnicodeScriptElbasan
    {- ^
    Elbasan. Since: 2.42
    -}
    | UnicodeScriptGrantha
    {- ^
    Grantha. Since: 2.42
    -}
    | UnicodeScriptKhojki
    {- ^
    Kjohki. Since: 2.42
    -}
    | UnicodeScriptKhudawadi
    {- ^
    Khudawadi, Sindhi. Since: 2.42
    -}
    | UnicodeScriptLinearA
    {- ^
    Linear A. Since: 2.42
    -}
    | UnicodeScriptMahajani
    {- ^
    Mahajani. Since: 2.42
    -}
    | UnicodeScriptManichaean
    {- ^
    Manichaean. Since: 2.42
    -}
    | UnicodeScriptMendeKikakui
    {- ^
    Mende Kikakui. Since: 2.42
    -}
    | UnicodeScriptModi
    {- ^
    Modi. Since: 2.42
    -}
    | UnicodeScriptMro
    {- ^
    Mro. Since: 2.42
    -}
    | UnicodeScriptNabataean
    {- ^
    Nabataean. Since: 2.42
    -}
    | UnicodeScriptOldNorthArabian
    {- ^
    Old North Arabian. Since: 2.42
    -}
    | UnicodeScriptOldPermic
    {- ^
    Old Permic. Since: 2.42
    -}
    | UnicodeScriptPahawhHmong
    {- ^
    Pahawh Hmong. Since: 2.42
    -}
    | UnicodeScriptPalmyrene
    {- ^
    Palmyrene. Since: 2.42
    -}
    | UnicodeScriptPauCinHau
    {- ^
    Pau Cin Hau. Since: 2.42
    -}
    | UnicodeScriptPsalterPahlavi
    {- ^
    Psalter Pahlavi. Since: 2.42
    -}
    | UnicodeScriptSiddham
    {- ^
    Siddham. Since: 2.42
    -}
    | UnicodeScriptTirhuta
    {- ^
    Tirhuta. Since: 2.42
    -}
    | UnicodeScriptWarangCiti
    {- ^
    Warang Citi. Since: 2.42
    -}
    | UnicodeScriptAhom
    {- ^
    Ahom. Since: 2.48
    -}
    | UnicodeScriptAnatolianHieroglyphs
    {- ^
    Anatolian Hieroglyphs. Since: 2.48
    -}
    | UnicodeScriptHatran
    {- ^
    Hatran. Since: 2.48
    -}
    | UnicodeScriptMultani
    {- ^
    Multani. Since: 2.48
    -}
    | UnicodeScriptOldHungarian
    {- ^
    Old Hungarian. Since: 2.48
    -}
    | UnicodeScriptSignwriting
    {- ^
    Signwriting. Since: 2.48
    -}
    | UnicodeScriptAdlam
    {- ^
    Adlam. Since: 2.50
    -}
    | UnicodeScriptBhaiksuki
    {- ^
    Bhaiksuki. Since: 2.50
    -}
    | UnicodeScriptMarchen
    {- ^
    Marchen. Since: 2.50
    -}
    | UnicodeScriptNewa
    {- ^
    Newa. Since: 2.50
    -}
    | UnicodeScriptOsage
    {- ^
    Osage. Since: 2.50
    -}
    | UnicodeScriptTangut
    {- ^
    Tangut. Since: 2.50
    /@gUNICODESCRIPTMASARAMGONDI@/,        Masaram Gondi. Since: 2.54
    /@gUNICODESCRIPTNUSHU@/,                Nushu. Since: 2.54
    /@gUNICODESCRIPTSOYOMBO@/,              Soyombo. Since: 2.54
    /@gUNICODESCRIPTZANABAZARSQUARE@/      Zanabazar Square. Since: 2.54
    -}
    | UnicodeScriptMasaramGondi
    {- ^
    /No description available in the introspection data./
    -}
    | UnicodeScriptNushu
    {- ^
    /No description available in the introspection data./
    -}
    | UnicodeScriptSoyombo
    {- ^
    /No description available in the introspection data./
    -}
    | UnicodeScriptZanabazarSquare
    {- ^
    /No description available in the introspection data./
    -}
    | AnotherUnicodeScript Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum UnicodeScript where
    fromEnum UnicodeScriptInvalidCode = -1
    fromEnum UnicodeScriptCommon = 0
    fromEnum UnicodeScriptInherited = 1
    fromEnum UnicodeScriptArabic = 2
    fromEnum UnicodeScriptArmenian = 3
    fromEnum UnicodeScriptBengali = 4
    fromEnum UnicodeScriptBopomofo = 5
    fromEnum UnicodeScriptCherokee = 6
    fromEnum UnicodeScriptCoptic = 7
    fromEnum UnicodeScriptCyrillic = 8
    fromEnum UnicodeScriptDeseret = 9
    fromEnum UnicodeScriptDevanagari = 10
    fromEnum UnicodeScriptEthiopic = 11
    fromEnum UnicodeScriptGeorgian = 12
    fromEnum UnicodeScriptGothic = 13
    fromEnum UnicodeScriptGreek = 14
    fromEnum UnicodeScriptGujarati = 15
    fromEnum UnicodeScriptGurmukhi = 16
    fromEnum UnicodeScriptHan = 17
    fromEnum UnicodeScriptHangul = 18
    fromEnum UnicodeScriptHebrew = 19
    fromEnum UnicodeScriptHiragana = 20
    fromEnum UnicodeScriptKannada = 21
    fromEnum UnicodeScriptKatakana = 22
    fromEnum UnicodeScriptKhmer = 23
    fromEnum UnicodeScriptLao = 24
    fromEnum UnicodeScriptLatin = 25
    fromEnum UnicodeScriptMalayalam = 26
    fromEnum UnicodeScriptMongolian = 27
    fromEnum UnicodeScriptMyanmar = 28
    fromEnum UnicodeScriptOgham = 29
    fromEnum UnicodeScriptOldItalic = 30
    fromEnum UnicodeScriptOriya = 31
    fromEnum UnicodeScriptRunic = 32
    fromEnum UnicodeScriptSinhala = 33
    fromEnum UnicodeScriptSyriac = 34
    fromEnum UnicodeScriptTamil = 35
    fromEnum UnicodeScriptTelugu = 36
    fromEnum UnicodeScriptThaana = 37
    fromEnum UnicodeScriptThai = 38
    fromEnum UnicodeScriptTibetan = 39
    fromEnum UnicodeScriptCanadianAboriginal = 40
    fromEnum UnicodeScriptYi = 41
    fromEnum UnicodeScriptTagalog = 42
    fromEnum UnicodeScriptHanunoo = 43
    fromEnum UnicodeScriptBuhid = 44
    fromEnum UnicodeScriptTagbanwa = 45
    fromEnum UnicodeScriptBraille = 46
    fromEnum UnicodeScriptCypriot = 47
    fromEnum UnicodeScriptLimbu = 48
    fromEnum UnicodeScriptOsmanya = 49
    fromEnum UnicodeScriptShavian = 50
    fromEnum UnicodeScriptLinearB = 51
    fromEnum UnicodeScriptTaiLe = 52
    fromEnum UnicodeScriptUgaritic = 53
    fromEnum UnicodeScriptNewTaiLue = 54
    fromEnum UnicodeScriptBuginese = 55
    fromEnum UnicodeScriptGlagolitic = 56
    fromEnum UnicodeScriptTifinagh = 57
    fromEnum UnicodeScriptSylotiNagri = 58
    fromEnum UnicodeScriptOldPersian = 59
    fromEnum UnicodeScriptKharoshthi = 60
    fromEnum UnicodeScriptUnknown = 61
    fromEnum UnicodeScriptBalinese = 62
    fromEnum UnicodeScriptCuneiform = 63
    fromEnum UnicodeScriptPhoenician = 64
    fromEnum UnicodeScriptPhagsPa = 65
    fromEnum UnicodeScriptNko = 66
    fromEnum UnicodeScriptKayahLi = 67
    fromEnum UnicodeScriptLepcha = 68
    fromEnum UnicodeScriptRejang = 69
    fromEnum UnicodeScriptSundanese = 70
    fromEnum UnicodeScriptSaurashtra = 71
    fromEnum UnicodeScriptCham = 72
    fromEnum UnicodeScriptOlChiki = 73
    fromEnum UnicodeScriptVai = 74
    fromEnum UnicodeScriptCarian = 75
    fromEnum UnicodeScriptLycian = 76
    fromEnum UnicodeScriptLydian = 77
    fromEnum UnicodeScriptAvestan = 78
    fromEnum UnicodeScriptBamum = 79
    fromEnum UnicodeScriptEgyptianHieroglyphs = 80
    fromEnum UnicodeScriptImperialAramaic = 81
    fromEnum UnicodeScriptInscriptionalPahlavi = 82
    fromEnum UnicodeScriptInscriptionalParthian = 83
    fromEnum UnicodeScriptJavanese = 84
    fromEnum UnicodeScriptKaithi = 85
    fromEnum UnicodeScriptLisu = 86
    fromEnum UnicodeScriptMeeteiMayek = 87
    fromEnum UnicodeScriptOldSouthArabian = 88
    fromEnum UnicodeScriptOldTurkic = 89
    fromEnum UnicodeScriptSamaritan = 90
    fromEnum UnicodeScriptTaiTham = 91
    fromEnum UnicodeScriptTaiViet = 92
    fromEnum UnicodeScriptBatak = 93
    fromEnum UnicodeScriptBrahmi = 94
    fromEnum UnicodeScriptMandaic = 95
    fromEnum UnicodeScriptChakma = 96
    fromEnum UnicodeScriptMeroiticCursive = 97
    fromEnum UnicodeScriptMeroiticHieroglyphs = 98
    fromEnum UnicodeScriptMiao = 99
    fromEnum UnicodeScriptSharada = 100
    fromEnum UnicodeScriptSoraSompeng = 101
    fromEnum UnicodeScriptTakri = 102
    fromEnum UnicodeScriptBassaVah = 103
    fromEnum UnicodeScriptCaucasianAlbanian = 104
    fromEnum UnicodeScriptDuployan = 105
    fromEnum UnicodeScriptElbasan = 106
    fromEnum UnicodeScriptGrantha = 107
    fromEnum UnicodeScriptKhojki = 108
    fromEnum UnicodeScriptKhudawadi = 109
    fromEnum UnicodeScriptLinearA = 110
    fromEnum UnicodeScriptMahajani = 111
    fromEnum UnicodeScriptManichaean = 112
    fromEnum UnicodeScriptMendeKikakui = 113
    fromEnum UnicodeScriptModi = 114
    fromEnum UnicodeScriptMro = 115
    fromEnum UnicodeScriptNabataean = 116
    fromEnum UnicodeScriptOldNorthArabian = 117
    fromEnum UnicodeScriptOldPermic = 118
    fromEnum UnicodeScriptPahawhHmong = 119
    fromEnum UnicodeScriptPalmyrene = 120
    fromEnum UnicodeScriptPauCinHau = 121
    fromEnum UnicodeScriptPsalterPahlavi = 122
    fromEnum UnicodeScriptSiddham = 123
    fromEnum UnicodeScriptTirhuta = 124
    fromEnum UnicodeScriptWarangCiti = 125
    fromEnum UnicodeScriptAhom = 126
    fromEnum UnicodeScriptAnatolianHieroglyphs = 127
    fromEnum UnicodeScriptHatran = 128
    fromEnum UnicodeScriptMultani = 129
    fromEnum UnicodeScriptOldHungarian = 130
    fromEnum UnicodeScriptSignwriting = 131
    fromEnum UnicodeScriptAdlam = 132
    fromEnum UnicodeScriptBhaiksuki = 133
    fromEnum UnicodeScriptMarchen = 134
    fromEnum UnicodeScriptNewa = 135
    fromEnum UnicodeScriptOsage = 136
    fromEnum UnicodeScriptTangut = 137
    fromEnum UnicodeScriptMasaramGondi = 138
    fromEnum UnicodeScriptNushu = 139
    fromEnum UnicodeScriptSoyombo = 140
    fromEnum UnicodeScriptZanabazarSquare = 141
    fromEnum (AnotherUnicodeScript k) = k

    toEnum -1 = UnicodeScriptInvalidCode
    toEnum 0 = UnicodeScriptCommon
    toEnum 1 = UnicodeScriptInherited
    toEnum 2 = UnicodeScriptArabic
    toEnum 3 = UnicodeScriptArmenian
    toEnum 4 = UnicodeScriptBengali
    toEnum 5 = UnicodeScriptBopomofo
    toEnum 6 = UnicodeScriptCherokee
    toEnum 7 = UnicodeScriptCoptic
    toEnum 8 = UnicodeScriptCyrillic
    toEnum 9 = UnicodeScriptDeseret
    toEnum 10 = UnicodeScriptDevanagari
    toEnum 11 = UnicodeScriptEthiopic
    toEnum 12 = UnicodeScriptGeorgian
    toEnum 13 = UnicodeScriptGothic
    toEnum 14 = UnicodeScriptGreek
    toEnum 15 = UnicodeScriptGujarati
    toEnum 16 = UnicodeScriptGurmukhi
    toEnum 17 = UnicodeScriptHan
    toEnum 18 = UnicodeScriptHangul
    toEnum 19 = UnicodeScriptHebrew
    toEnum 20 = UnicodeScriptHiragana
    toEnum 21 = UnicodeScriptKannada
    toEnum 22 = UnicodeScriptKatakana
    toEnum 23 = UnicodeScriptKhmer
    toEnum 24 = UnicodeScriptLao
    toEnum 25 = UnicodeScriptLatin
    toEnum 26 = UnicodeScriptMalayalam
    toEnum 27 = UnicodeScriptMongolian
    toEnum 28 = UnicodeScriptMyanmar
    toEnum 29 = UnicodeScriptOgham
    toEnum 30 = UnicodeScriptOldItalic
    toEnum 31 = UnicodeScriptOriya
    toEnum 32 = UnicodeScriptRunic
    toEnum 33 = UnicodeScriptSinhala
    toEnum 34 = UnicodeScriptSyriac
    toEnum 35 = UnicodeScriptTamil
    toEnum 36 = UnicodeScriptTelugu
    toEnum 37 = UnicodeScriptThaana
    toEnum 38 = UnicodeScriptThai
    toEnum 39 = UnicodeScriptTibetan
    toEnum 40 = UnicodeScriptCanadianAboriginal
    toEnum 41 = UnicodeScriptYi
    toEnum 42 = UnicodeScriptTagalog
    toEnum 43 = UnicodeScriptHanunoo
    toEnum 44 = UnicodeScriptBuhid
    toEnum 45 = UnicodeScriptTagbanwa
    toEnum 46 = UnicodeScriptBraille
    toEnum 47 = UnicodeScriptCypriot
    toEnum 48 = UnicodeScriptLimbu
    toEnum 49 = UnicodeScriptOsmanya
    toEnum 50 = UnicodeScriptShavian
    toEnum 51 = UnicodeScriptLinearB
    toEnum 52 = UnicodeScriptTaiLe
    toEnum 53 = UnicodeScriptUgaritic
    toEnum 54 = UnicodeScriptNewTaiLue
    toEnum 55 = UnicodeScriptBuginese
    toEnum 56 = UnicodeScriptGlagolitic
    toEnum 57 = UnicodeScriptTifinagh
    toEnum 58 = UnicodeScriptSylotiNagri
    toEnum 59 = UnicodeScriptOldPersian
    toEnum 60 = UnicodeScriptKharoshthi
    toEnum 61 = UnicodeScriptUnknown
    toEnum 62 = UnicodeScriptBalinese
    toEnum 63 = UnicodeScriptCuneiform
    toEnum 64 = UnicodeScriptPhoenician
    toEnum 65 = UnicodeScriptPhagsPa
    toEnum 66 = UnicodeScriptNko
    toEnum 67 = UnicodeScriptKayahLi
    toEnum 68 = UnicodeScriptLepcha
    toEnum 69 = UnicodeScriptRejang
    toEnum 70 = UnicodeScriptSundanese
    toEnum 71 = UnicodeScriptSaurashtra
    toEnum 72 = UnicodeScriptCham
    toEnum 73 = UnicodeScriptOlChiki
    toEnum 74 = UnicodeScriptVai
    toEnum 75 = UnicodeScriptCarian
    toEnum 76 = UnicodeScriptLycian
    toEnum 77 = UnicodeScriptLydian
    toEnum 78 = UnicodeScriptAvestan
    toEnum 79 = UnicodeScriptBamum
    toEnum 80 = UnicodeScriptEgyptianHieroglyphs
    toEnum 81 = UnicodeScriptImperialAramaic
    toEnum 82 = UnicodeScriptInscriptionalPahlavi
    toEnum 83 = UnicodeScriptInscriptionalParthian
    toEnum 84 = UnicodeScriptJavanese
    toEnum 85 = UnicodeScriptKaithi
    toEnum 86 = UnicodeScriptLisu
    toEnum 87 = UnicodeScriptMeeteiMayek
    toEnum 88 = UnicodeScriptOldSouthArabian
    toEnum 89 = UnicodeScriptOldTurkic
    toEnum 90 = UnicodeScriptSamaritan
    toEnum 91 = UnicodeScriptTaiTham
    toEnum 92 = UnicodeScriptTaiViet
    toEnum 93 = UnicodeScriptBatak
    toEnum 94 = UnicodeScriptBrahmi
    toEnum 95 = UnicodeScriptMandaic
    toEnum 96 = UnicodeScriptChakma
    toEnum 97 = UnicodeScriptMeroiticCursive
    toEnum 98 = UnicodeScriptMeroiticHieroglyphs
    toEnum 99 = UnicodeScriptMiao
    toEnum 100 = UnicodeScriptSharada
    toEnum 101 = UnicodeScriptSoraSompeng
    toEnum 102 = UnicodeScriptTakri
    toEnum 103 = UnicodeScriptBassaVah
    toEnum 104 = UnicodeScriptCaucasianAlbanian
    toEnum 105 = UnicodeScriptDuployan
    toEnum 106 = UnicodeScriptElbasan
    toEnum 107 = UnicodeScriptGrantha
    toEnum 108 = UnicodeScriptKhojki
    toEnum 109 = UnicodeScriptKhudawadi
    toEnum 110 = UnicodeScriptLinearA
    toEnum 111 = UnicodeScriptMahajani
    toEnum 112 = UnicodeScriptManichaean
    toEnum 113 = UnicodeScriptMendeKikakui
    toEnum 114 = UnicodeScriptModi
    toEnum 115 = UnicodeScriptMro
    toEnum 116 = UnicodeScriptNabataean
    toEnum 117 = UnicodeScriptOldNorthArabian
    toEnum 118 = UnicodeScriptOldPermic
    toEnum 119 = UnicodeScriptPahawhHmong
    toEnum 120 = UnicodeScriptPalmyrene
    toEnum 121 = UnicodeScriptPauCinHau
    toEnum 122 = UnicodeScriptPsalterPahlavi
    toEnum 123 = UnicodeScriptSiddham
    toEnum 124 = UnicodeScriptTirhuta
    toEnum 125 = UnicodeScriptWarangCiti
    toEnum 126 = UnicodeScriptAhom
    toEnum 127 = UnicodeScriptAnatolianHieroglyphs
    toEnum 128 = UnicodeScriptHatran
    toEnum 129 = UnicodeScriptMultani
    toEnum 130 = UnicodeScriptOldHungarian
    toEnum 131 = UnicodeScriptSignwriting
    toEnum 132 = UnicodeScriptAdlam
    toEnum 133 = UnicodeScriptBhaiksuki
    toEnum 134 = UnicodeScriptMarchen
    toEnum 135 = UnicodeScriptNewa
    toEnum 136 = UnicodeScriptOsage
    toEnum 137 = UnicodeScriptTangut
    toEnum 138 = UnicodeScriptMasaramGondi
    toEnum 139 = UnicodeScriptNushu
    toEnum 140 = UnicodeScriptSoyombo
    toEnum 141 = UnicodeScriptZanabazarSquare
    toEnum k = AnotherUnicodeScript k

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

-- Enum UnicodeBreakType
{- |
These are the possible line break classifications.

Since new unicode versions may add new types here, applications should be ready
to handle unknown values. They may be regarded as 'GI.GLib.Enums.UnicodeBreakTypeUnknown'.

See <http://www.unicode.org/unicode/reports/tr14/ Unicode Line Breaking Algorithm>.
-}
data UnicodeBreakType = 
      UnicodeBreakTypeMandatory
    {- ^
    Mandatory Break (BK)
    -}
    | UnicodeBreakTypeCarriageReturn
    {- ^
    Carriage Return (CR)
    -}
    | UnicodeBreakTypeLineFeed
    {- ^
    Line Feed (LF)
    -}
    | UnicodeBreakTypeCombiningMark
    {- ^
    Attached Characters and Combining Marks (CM)
    -}
    | UnicodeBreakTypeSurrogate
    {- ^
    Surrogates (SG)
    -}
    | UnicodeBreakTypeZeroWidthSpace
    {- ^
    Zero Width Space (ZW)
    -}
    | UnicodeBreakTypeInseparable
    {- ^
    Inseparable (IN)
    -}
    | UnicodeBreakTypeNonBreakingGlue
    {- ^
    Non-breaking (\"Glue\") (GL)
    -}
    | UnicodeBreakTypeContingent
    {- ^
    Contingent Break Opportunity (CB)
    -}
    | UnicodeBreakTypeSpace
    {- ^
    Space (SP)
    -}
    | UnicodeBreakTypeAfter
    {- ^
    Break Opportunity After (BA)
    -}
    | UnicodeBreakTypeBefore
    {- ^
    Break Opportunity Before (BB)
    -}
    | UnicodeBreakTypeBeforeAndAfter
    {- ^
    Break Opportunity Before and After (B2)
    -}
    | UnicodeBreakTypeHyphen
    {- ^
    Hyphen (HY)
    -}
    | UnicodeBreakTypeNonStarter
    {- ^
    Nonstarter (NS)
    -}
    | UnicodeBreakTypeOpenPunctuation
    {- ^
    Opening Punctuation (OP)
    -}
    | UnicodeBreakTypeClosePunctuation
    {- ^
    Closing Punctuation (CL)
    -}
    | UnicodeBreakTypeQuotation
    {- ^
    Ambiguous Quotation (QU)
    -}
    | UnicodeBreakTypeExclamation
    {- ^
    Exclamation\/Interrogation (EX)
    -}
    | UnicodeBreakTypeIdeographic
    {- ^
    Ideographic (ID)
    -}
    | UnicodeBreakTypeNumeric
    {- ^
    Numeric (NU)
    -}
    | UnicodeBreakTypeInfixSeparator
    {- ^
    Infix Separator (Numeric) (IS)
    -}
    | UnicodeBreakTypeSymbol
    {- ^
    Symbols Allowing Break After (SY)
    -}
    | UnicodeBreakTypeAlphabetic
    {- ^
    Ordinary Alphabetic and Symbol Characters (AL)
    -}
    | UnicodeBreakTypePrefix
    {- ^
    Prefix (Numeric) (PR)
    -}
    | UnicodeBreakTypePostfix
    {- ^
    Postfix (Numeric) (PO)
    -}
    | UnicodeBreakTypeComplexContext
    {- ^
    Complex Content Dependent (South East Asian) (SA)
    -}
    | UnicodeBreakTypeAmbiguous
    {- ^
    Ambiguous (Alphabetic or Ideographic) (AI)
    -}
    | UnicodeBreakTypeUnknown
    {- ^
    Unknown (XX)
    -}
    | UnicodeBreakTypeNextLine
    {- ^
    Next Line (NL)
    -}
    | UnicodeBreakTypeWordJoiner
    {- ^
    Word Joiner (WJ)
    -}
    | UnicodeBreakTypeHangulLJamo
    {- ^
    Hangul L Jamo (JL)
    -}
    | UnicodeBreakTypeHangulVJamo
    {- ^
    Hangul V Jamo (JV)
    -}
    | UnicodeBreakTypeHangulTJamo
    {- ^
    Hangul T Jamo (JT)
    -}
    | UnicodeBreakTypeHangulLvSyllable
    {- ^
    Hangul LV Syllable (H2)
    -}
    | UnicodeBreakTypeHangulLvtSyllable
    {- ^
    Hangul LVT Syllable (H3)
    -}
    | UnicodeBreakTypeCloseParanthesis
    {- ^
    Closing Parenthesis (CP). Since 2.28
    -}
    | UnicodeBreakTypeConditionalJapaneseStarter
    {- ^
    Conditional Japanese Starter (CJ). Since: 2.32
    -}
    | UnicodeBreakTypeHebrewLetter
    {- ^
    Hebrew Letter (HL). Since: 2.32
    -}
    | UnicodeBreakTypeRegionalIndicator
    {- ^
    Regional Indicator (RI). Since: 2.36
    -}
    | UnicodeBreakTypeEmojiBase
    {- ^
    Emoji Base (EB). Since: 2.50
    -}
    | UnicodeBreakTypeEmojiModifier
    {- ^
    Emoji Modifier (EM). Since: 2.50
    -}
    | UnicodeBreakTypeZeroWidthJoiner
    {- ^
    Zero Width Joiner (ZWJ). Since: 2.50
    -}
    | AnotherUnicodeBreakType Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum UnicodeBreakType where
    fromEnum UnicodeBreakTypeMandatory = 0
    fromEnum UnicodeBreakTypeCarriageReturn = 1
    fromEnum UnicodeBreakTypeLineFeed = 2
    fromEnum UnicodeBreakTypeCombiningMark = 3
    fromEnum UnicodeBreakTypeSurrogate = 4
    fromEnum UnicodeBreakTypeZeroWidthSpace = 5
    fromEnum UnicodeBreakTypeInseparable = 6
    fromEnum UnicodeBreakTypeNonBreakingGlue = 7
    fromEnum UnicodeBreakTypeContingent = 8
    fromEnum UnicodeBreakTypeSpace = 9
    fromEnum UnicodeBreakTypeAfter = 10
    fromEnum UnicodeBreakTypeBefore = 11
    fromEnum UnicodeBreakTypeBeforeAndAfter = 12
    fromEnum UnicodeBreakTypeHyphen = 13
    fromEnum UnicodeBreakTypeNonStarter = 14
    fromEnum UnicodeBreakTypeOpenPunctuation = 15
    fromEnum UnicodeBreakTypeClosePunctuation = 16
    fromEnum UnicodeBreakTypeQuotation = 17
    fromEnum UnicodeBreakTypeExclamation = 18
    fromEnum UnicodeBreakTypeIdeographic = 19
    fromEnum UnicodeBreakTypeNumeric = 20
    fromEnum UnicodeBreakTypeInfixSeparator = 21
    fromEnum UnicodeBreakTypeSymbol = 22
    fromEnum UnicodeBreakTypeAlphabetic = 23
    fromEnum UnicodeBreakTypePrefix = 24
    fromEnum UnicodeBreakTypePostfix = 25
    fromEnum UnicodeBreakTypeComplexContext = 26
    fromEnum UnicodeBreakTypeAmbiguous = 27
    fromEnum UnicodeBreakTypeUnknown = 28
    fromEnum UnicodeBreakTypeNextLine = 29
    fromEnum UnicodeBreakTypeWordJoiner = 30
    fromEnum UnicodeBreakTypeHangulLJamo = 31
    fromEnum UnicodeBreakTypeHangulVJamo = 32
    fromEnum UnicodeBreakTypeHangulTJamo = 33
    fromEnum UnicodeBreakTypeHangulLvSyllable = 34
    fromEnum UnicodeBreakTypeHangulLvtSyllable = 35
    fromEnum UnicodeBreakTypeCloseParanthesis = 36
    fromEnum UnicodeBreakTypeConditionalJapaneseStarter = 37
    fromEnum UnicodeBreakTypeHebrewLetter = 38
    fromEnum UnicodeBreakTypeRegionalIndicator = 39
    fromEnum UnicodeBreakTypeEmojiBase = 40
    fromEnum UnicodeBreakTypeEmojiModifier = 41
    fromEnum UnicodeBreakTypeZeroWidthJoiner = 42
    fromEnum (AnotherUnicodeBreakType k) = k

    toEnum 0 = UnicodeBreakTypeMandatory
    toEnum 1 = UnicodeBreakTypeCarriageReturn
    toEnum 2 = UnicodeBreakTypeLineFeed
    toEnum 3 = UnicodeBreakTypeCombiningMark
    toEnum 4 = UnicodeBreakTypeSurrogate
    toEnum 5 = UnicodeBreakTypeZeroWidthSpace
    toEnum 6 = UnicodeBreakTypeInseparable
    toEnum 7 = UnicodeBreakTypeNonBreakingGlue
    toEnum 8 = UnicodeBreakTypeContingent
    toEnum 9 = UnicodeBreakTypeSpace
    toEnum 10 = UnicodeBreakTypeAfter
    toEnum 11 = UnicodeBreakTypeBefore
    toEnum 12 = UnicodeBreakTypeBeforeAndAfter
    toEnum 13 = UnicodeBreakTypeHyphen
    toEnum 14 = UnicodeBreakTypeNonStarter
    toEnum 15 = UnicodeBreakTypeOpenPunctuation
    toEnum 16 = UnicodeBreakTypeClosePunctuation
    toEnum 17 = UnicodeBreakTypeQuotation
    toEnum 18 = UnicodeBreakTypeExclamation
    toEnum 19 = UnicodeBreakTypeIdeographic
    toEnum 20 = UnicodeBreakTypeNumeric
    toEnum 21 = UnicodeBreakTypeInfixSeparator
    toEnum 22 = UnicodeBreakTypeSymbol
    toEnum 23 = UnicodeBreakTypeAlphabetic
    toEnum 24 = UnicodeBreakTypePrefix
    toEnum 25 = UnicodeBreakTypePostfix
    toEnum 26 = UnicodeBreakTypeComplexContext
    toEnum 27 = UnicodeBreakTypeAmbiguous
    toEnum 28 = UnicodeBreakTypeUnknown
    toEnum 29 = UnicodeBreakTypeNextLine
    toEnum 30 = UnicodeBreakTypeWordJoiner
    toEnum 31 = UnicodeBreakTypeHangulLJamo
    toEnum 32 = UnicodeBreakTypeHangulVJamo
    toEnum 33 = UnicodeBreakTypeHangulTJamo
    toEnum 34 = UnicodeBreakTypeHangulLvSyllable
    toEnum 35 = UnicodeBreakTypeHangulLvtSyllable
    toEnum 36 = UnicodeBreakTypeCloseParanthesis
    toEnum 37 = UnicodeBreakTypeConditionalJapaneseStarter
    toEnum 38 = UnicodeBreakTypeHebrewLetter
    toEnum 39 = UnicodeBreakTypeRegionalIndicator
    toEnum 40 = UnicodeBreakTypeEmojiBase
    toEnum 41 = UnicodeBreakTypeEmojiModifier
    toEnum 42 = UnicodeBreakTypeZeroWidthJoiner
    toEnum k = AnotherUnicodeBreakType k

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

-- Enum TraverseType
{- |
Specifies the type of traveral performed by @/g_tree_traverse()/@,
@/g_node_traverse()/@ and @/g_node_find()/@. The different orders are
illustrated here:

* In order: A, B, C, D, E, F, G, H, I
<<http://developer.gnome.org/glib/stable/Sorted_binary_tree_inorder.svg>>
* Pre order: F, B, A, D, C, E, G, I, H
<<http://developer.gnome.org/glib/stable/Sorted_binary_tree_preorder.svg>>
* Post order: A, C, E, D, B, H, I, G, F
<<http://developer.gnome.org/glib/stable/Sorted_binary_tree_postorder.svg>>
* Level order: F, B, G, A, D, I, C, E, H
<<http://developer.gnome.org/glib/stable/Sorted_binary_tree_breadth-first_traversal.svg>>
-}
data TraverseType = 
      TraverseTypeInOrder
    {- ^
    vists a node\'s left child first, then the node itself,
                 then its right child. This is the one to use if you
                 want the output sorted according to the compare
                 function.
    -}
    | TraverseTypePreOrder
    {- ^
    visits a node, then its children.
    -}
    | TraverseTypePostOrder
    {- ^
    visits the node\'s children, then the node itself.
    -}
    | TraverseTypeLevelOrder
    {- ^
    is not implemented for
                 [balanced binary trees][glib-Balanced-Binary-Trees].
                 For [n-ary trees][glib-N-ary-Trees], it
                 vists the root node first, then its children, then
                 its grandchildren, and so on. Note that this is less
                 efficient than the other orders.
    -}
    | AnotherTraverseType Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum TraverseType where
    fromEnum TraverseTypeInOrder = 0
    fromEnum TraverseTypePreOrder = 1
    fromEnum TraverseTypePostOrder = 2
    fromEnum TraverseTypeLevelOrder = 3
    fromEnum (AnotherTraverseType k) = k

    toEnum 0 = TraverseTypeInOrder
    toEnum 1 = TraverseTypePreOrder
    toEnum 2 = TraverseTypePostOrder
    toEnum 3 = TraverseTypeLevelOrder
    toEnum k = AnotherTraverseType k

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

-- Enum TokenType
{- |
The possible types of token returned from each
'GI.GLib.Structs.Scanner.scannerGetNextToken' call.
-}
data TokenType = 
      TokenTypeEof
    {- ^
    the end of the file
    -}
    | TokenTypeLeftParen
    {- ^
    a \'(\' character
    -}
    | TokenTypeRightParen
    {- ^
    a \')\' character
    -}
    | TokenTypeLeftCurly
    {- ^
    a \'{\' character
    -}
    | TokenTypeRightCurly
    {- ^
    a \'}\' character
    -}
    | TokenTypeLeftBrace
    {- ^
    a \'[\' character
    -}
    | TokenTypeRightBrace
    {- ^
    a \']\' character
    -}
    | TokenTypeEqualSign
    {- ^
    a \'=\' character
    -}
    | TokenTypeComma
    {- ^
    a \',\' character
    -}
    | TokenTypeNone
    {- ^
    not a token
    -}
    | TokenTypeError
    {- ^
    an error occurred
    -}
    | TokenTypeChar
    {- ^
    a character
    -}
    | TokenTypeBinary
    {- ^
    a binary integer
    -}
    | TokenTypeOctal
    {- ^
    an octal integer
    -}
    | TokenTypeInt
    {- ^
    an integer
    -}
    | TokenTypeHex
    {- ^
    a hex integer
    -}
    | TokenTypeFloat
    {- ^
    a floating point number
    -}
    | TokenTypeString
    {- ^
    a string
    -}
    | TokenTypeSymbol
    {- ^
    a symbol
    -}
    | TokenTypeIdentifier
    {- ^
    an identifier
    -}
    | TokenTypeIdentifierNull
    {- ^
    a null identifier
    -}
    | TokenTypeCommentSingle
    {- ^
    one line comment
    -}
    | TokenTypeCommentMulti
    {- ^
    multi line comment
    -}
    | AnotherTokenType Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum TokenType where
    fromEnum TokenTypeEof = 0
    fromEnum TokenTypeLeftParen = 40
    fromEnum TokenTypeRightParen = 41
    fromEnum TokenTypeLeftCurly = 123
    fromEnum TokenTypeRightCurly = 125
    fromEnum TokenTypeLeftBrace = 91
    fromEnum TokenTypeRightBrace = 93
    fromEnum TokenTypeEqualSign = 61
    fromEnum TokenTypeComma = 44
    fromEnum TokenTypeNone = 256
    fromEnum TokenTypeError = 257
    fromEnum TokenTypeChar = 258
    fromEnum TokenTypeBinary = 259
    fromEnum TokenTypeOctal = 260
    fromEnum TokenTypeInt = 261
    fromEnum TokenTypeHex = 262
    fromEnum TokenTypeFloat = 263
    fromEnum TokenTypeString = 264
    fromEnum TokenTypeSymbol = 265
    fromEnum TokenTypeIdentifier = 266
    fromEnum TokenTypeIdentifierNull = 267
    fromEnum TokenTypeCommentSingle = 268
    fromEnum TokenTypeCommentMulti = 269
    fromEnum (AnotherTokenType k) = k

    toEnum 0 = TokenTypeEof
    toEnum 40 = TokenTypeLeftParen
    toEnum 41 = TokenTypeRightParen
    toEnum 123 = TokenTypeLeftCurly
    toEnum 125 = TokenTypeRightCurly
    toEnum 91 = TokenTypeLeftBrace
    toEnum 93 = TokenTypeRightBrace
    toEnum 61 = TokenTypeEqualSign
    toEnum 44 = TokenTypeComma
    toEnum 256 = TokenTypeNone
    toEnum 257 = TokenTypeError
    toEnum 258 = TokenTypeChar
    toEnum 259 = TokenTypeBinary
    toEnum 260 = TokenTypeOctal
    toEnum 261 = TokenTypeInt
    toEnum 262 = TokenTypeHex
    toEnum 263 = TokenTypeFloat
    toEnum 264 = TokenTypeString
    toEnum 265 = TokenTypeSymbol
    toEnum 266 = TokenTypeIdentifier
    toEnum 267 = TokenTypeIdentifierNull
    toEnum 268 = TokenTypeCommentSingle
    toEnum 269 = TokenTypeCommentMulti
    toEnum k = AnotherTokenType k

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

-- Enum TimeType
{- |
Disambiguates a given time in two ways.

First, specifies if the given time is in universal or local time.

Second, if the time is in local time, specifies if it is local
standard time or local daylight time.  This is important for the case
where the same local time occurs twice (during daylight savings time
transitions, for example).
-}
data TimeType = 
      TimeTypeStandard
    {- ^
    the time is in local standard time
    -}
    | TimeTypeDaylight
    {- ^
    the time is in local daylight time
    -}
    | TimeTypeUniversal
    {- ^
    the time is in UTC
    -}
    | AnotherTimeType Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum TimeType where
    fromEnum TimeTypeStandard = 0
    fromEnum TimeTypeDaylight = 1
    fromEnum TimeTypeUniversal = 2
    fromEnum (AnotherTimeType k) = k

    toEnum 0 = TimeTypeStandard
    toEnum 1 = TimeTypeDaylight
    toEnum 2 = TimeTypeUniversal
    toEnum k = AnotherTimeType k

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

-- Enum ThreadError
{- |
Possible errors of thread related functions.
-}
data ThreadError = 
      ThreadErrorThreadErrorAgain
    {- ^
    a thread couldn\'t be created due to resource
                           shortage. Try again later.
    -}
    | AnotherThreadError Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum ThreadError where
    fromEnum ThreadErrorThreadErrorAgain = 0
    fromEnum (AnotherThreadError k) = k

    toEnum 0 = ThreadErrorThreadErrorAgain
    toEnum k = AnotherThreadError k

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

instance GErrorClass ThreadError where
    gerrorClassDomain _ = "g_thread_error"

-- | Catch exceptions of type `ThreadError`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`.
catchThreadError ::
    IO a ->
    (ThreadError -> GErrorMessage -> IO a) ->
    IO a
catchThreadError = catchGErrorJustDomain

-- | Handle exceptions of type `ThreadError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`.
handleThreadError ::
    (ThreadError -> GErrorMessage -> IO a) ->
    IO a ->
    IO a
handleThreadError = handleGErrorJustDomain

-- Enum TestLogType
{- |
/No description available in the introspection data./
-}
data TestLogType = 
      TestLogTypeNone
    {- ^
    /No description available in the introspection data./
    -}
    | TestLogTypeError
    {- ^
    /No description available in the introspection data./
    -}
    | TestLogTypeStartBinary
    {- ^
    /No description available in the introspection data./
    -}
    | TestLogTypeListCase
    {- ^
    /No description available in the introspection data./
    -}
    | TestLogTypeSkipCase
    {- ^
    /No description available in the introspection data./
    -}
    | TestLogTypeStartCase
    {- ^
    /No description available in the introspection data./
    -}
    | TestLogTypeStopCase
    {- ^
    /No description available in the introspection data./
    -}
    | TestLogTypeMinResult
    {- ^
    /No description available in the introspection data./
    -}
    | TestLogTypeMaxResult
    {- ^
    /No description available in the introspection data./
    -}
    | TestLogTypeMessage
    {- ^
    /No description available in the introspection data./
    -}
    | TestLogTypeStartSuite
    {- ^
    /No description available in the introspection data./
    -}
    | TestLogTypeStopSuite
    {- ^
    /No description available in the introspection data./
    -}
    | AnotherTestLogType Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum TestLogType where
    fromEnum TestLogTypeNone = 0
    fromEnum TestLogTypeError = 1
    fromEnum TestLogTypeStartBinary = 2
    fromEnum TestLogTypeListCase = 3
    fromEnum TestLogTypeSkipCase = 4
    fromEnum TestLogTypeStartCase = 5
    fromEnum TestLogTypeStopCase = 6
    fromEnum TestLogTypeMinResult = 7
    fromEnum TestLogTypeMaxResult = 8
    fromEnum TestLogTypeMessage = 9
    fromEnum TestLogTypeStartSuite = 10
    fromEnum TestLogTypeStopSuite = 11
    fromEnum (AnotherTestLogType k) = k

    toEnum 0 = TestLogTypeNone
    toEnum 1 = TestLogTypeError
    toEnum 2 = TestLogTypeStartBinary
    toEnum 3 = TestLogTypeListCase
    toEnum 4 = TestLogTypeSkipCase
    toEnum 5 = TestLogTypeStartCase
    toEnum 6 = TestLogTypeStopCase
    toEnum 7 = TestLogTypeMinResult
    toEnum 8 = TestLogTypeMaxResult
    toEnum 9 = TestLogTypeMessage
    toEnum 10 = TestLogTypeStartSuite
    toEnum 11 = TestLogTypeStopSuite
    toEnum k = AnotherTestLogType k

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

-- Enum TestFileType
{- |
The type of file to return the filename for, when used with
@/g_test_build_filename()/@.

These two options correspond rather directly to the \'dist\' and
\'built\' terminology that automake uses and are explicitly used to
distinguish between the \'srcdir\' and \'builddir\' being separate.  All
files in your project should either be dist (in the
@EXTRA_DIST@ or @dist_schema_DATA@
sense, in which case they will always be in the srcdir) or built (in
the @BUILT_SOURCES@ sense, in which case they will
always be in the builddir).

Note: as a general rule of automake, files that are generated only as
part of the build-from-git process (but then are distributed with the
tarball) always go in srcdir (even if doing a srcdir != builddir
build from git) and are considered as distributed files.

@since 2.38
-}
data TestFileType = 
      TestFileTypeDist
    {- ^
    a file that was included in the distribution tarball
    -}
    | TestFileTypeBuilt
    {- ^
    a file that was built on the compiling machine
    -}
    | AnotherTestFileType Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum TestFileType where
    fromEnum TestFileTypeDist = 0
    fromEnum TestFileTypeBuilt = 1
    fromEnum (AnotherTestFileType k) = k

    toEnum 0 = TestFileTypeDist
    toEnum 1 = TestFileTypeBuilt
    toEnum k = AnotherTestFileType k

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

-- Enum SpawnError
{- |
Error codes returned by spawning processes.
-}
data SpawnError = 
      SpawnErrorFork
    {- ^
    Fork failed due to lack of memory.
    -}
    | SpawnErrorRead
    {- ^
    Read or select on pipes failed.
    -}
    | SpawnErrorChdir
    {- ^
    Changing to working directory failed.
    -}
    | SpawnErrorAcces
    {- ^
    @/execv()/@ returned @EACCES@
    -}
    | SpawnErrorPerm
    {- ^
    @/execv()/@ returned @EPERM@
    -}
    | SpawnErrorTooBig
    {- ^
    @/execv()/@ returned @E2BIG@
    -}
    | SpawnError2big
    {- ^
    deprecated alias for 'GI.GLib.Enums.SpawnErrorTooBig'
    -}
    | SpawnErrorNoexec
    {- ^
    @/execv()/@ returned @ENOEXEC@
    -}
    | SpawnErrorNametoolong
    {- ^
    @/execv()/@ returned @ENAMETOOLONG@
    -}
    | SpawnErrorNoent
    {- ^
    @/execv()/@ returned @ENOENT@
    -}
    | SpawnErrorNomem
    {- ^
    @/execv()/@ returned @ENOMEM@
    -}
    | SpawnErrorNotdir
    {- ^
    @/execv()/@ returned @ENOTDIR@
    -}
    | SpawnErrorLoop
    {- ^
    @/execv()/@ returned @ELOOP@
    -}
    | SpawnErrorTxtbusy
    {- ^
    @/execv()/@ returned @ETXTBUSY@
    -}
    | SpawnErrorIo
    {- ^
    @/execv()/@ returned @EIO@
    -}
    | SpawnErrorNfile
    {- ^
    @/execv()/@ returned @ENFILE@
    -}
    | SpawnErrorMfile
    {- ^
    @/execv()/@ returned @EMFILE@
    -}
    | SpawnErrorInval
    {- ^
    @/execv()/@ returned @EINVAL@
    -}
    | SpawnErrorIsdir
    {- ^
    @/execv()/@ returned @EISDIR@
    -}
    | SpawnErrorLibbad
    {- ^
    @/execv()/@ returned @ELIBBAD@
    -}
    | SpawnErrorFailed
    {- ^
    Some other fatal failure,
      @error->message@ should explain.
    -}
    | AnotherSpawnError Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum SpawnError where
    fromEnum SpawnErrorFork = 0
    fromEnum SpawnErrorRead = 1
    fromEnum SpawnErrorChdir = 2
    fromEnum SpawnErrorAcces = 3
    fromEnum SpawnErrorPerm = 4
    fromEnum SpawnErrorTooBig = 5
    fromEnum SpawnError2big = 5
    fromEnum SpawnErrorNoexec = 6
    fromEnum SpawnErrorNametoolong = 7
    fromEnum SpawnErrorNoent = 8
    fromEnum SpawnErrorNomem = 9
    fromEnum SpawnErrorNotdir = 10
    fromEnum SpawnErrorLoop = 11
    fromEnum SpawnErrorTxtbusy = 12
    fromEnum SpawnErrorIo = 13
    fromEnum SpawnErrorNfile = 14
    fromEnum SpawnErrorMfile = 15
    fromEnum SpawnErrorInval = 16
    fromEnum SpawnErrorIsdir = 17
    fromEnum SpawnErrorLibbad = 18
    fromEnum SpawnErrorFailed = 19
    fromEnum (AnotherSpawnError k) = k

    toEnum 0 = SpawnErrorFork
    toEnum 1 = SpawnErrorRead
    toEnum 2 = SpawnErrorChdir
    toEnum 3 = SpawnErrorAcces
    toEnum 4 = SpawnErrorPerm
    toEnum 5 = SpawnErrorTooBig
    toEnum 5 = SpawnError2big
    toEnum 6 = SpawnErrorNoexec
    toEnum 7 = SpawnErrorNametoolong
    toEnum 8 = SpawnErrorNoent
    toEnum 9 = SpawnErrorNomem
    toEnum 10 = SpawnErrorNotdir
    toEnum 11 = SpawnErrorLoop
    toEnum 12 = SpawnErrorTxtbusy
    toEnum 13 = SpawnErrorIo
    toEnum 14 = SpawnErrorNfile
    toEnum 15 = SpawnErrorMfile
    toEnum 16 = SpawnErrorInval
    toEnum 17 = SpawnErrorIsdir
    toEnum 18 = SpawnErrorLibbad
    toEnum 19 = SpawnErrorFailed
    toEnum k = AnotherSpawnError k

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

instance GErrorClass SpawnError where
    gerrorClassDomain _ = "g-exec-error-quark"

-- | Catch exceptions of type `SpawnError`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`.
catchSpawnError ::
    IO a ->
    (SpawnError -> GErrorMessage -> IO a) ->
    IO a
catchSpawnError = catchGErrorJustDomain

-- | Handle exceptions of type `SpawnError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`.
handleSpawnError ::
    (SpawnError -> GErrorMessage -> IO a) ->
    IO a ->
    IO a
handleSpawnError = handleGErrorJustDomain

-- Enum SliceConfig
{- |
/No description available in the introspection data./
-}
data SliceConfig = 
      SliceConfigAlwaysMalloc
    {- ^
    /No description available in the introspection data./
    -}
    | SliceConfigBypassMagazines
    {- ^
    /No description available in the introspection data./
    -}
    | SliceConfigWorkingSetMsecs
    {- ^
    /No description available in the introspection data./
    -}
    | SliceConfigColorIncrement
    {- ^
    /No description available in the introspection data./
    -}
    | SliceConfigChunkSizes
    {- ^
    /No description available in the introspection data./
    -}
    | SliceConfigContentionCounter
    {- ^
    /No description available in the introspection data./
    -}
    | AnotherSliceConfig Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum SliceConfig where
    fromEnum SliceConfigAlwaysMalloc = 1
    fromEnum SliceConfigBypassMagazines = 2
    fromEnum SliceConfigWorkingSetMsecs = 3
    fromEnum SliceConfigColorIncrement = 4
    fromEnum SliceConfigChunkSizes = 5
    fromEnum SliceConfigContentionCounter = 6
    fromEnum (AnotherSliceConfig k) = k

    toEnum 1 = SliceConfigAlwaysMalloc
    toEnum 2 = SliceConfigBypassMagazines
    toEnum 3 = SliceConfigWorkingSetMsecs
    toEnum 4 = SliceConfigColorIncrement
    toEnum 5 = SliceConfigChunkSizes
    toEnum 6 = SliceConfigContentionCounter
    toEnum k = AnotherSliceConfig k

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

-- Enum ShellError
{- |
Error codes returned by shell functions.
-}
data ShellError = 
      ShellErrorBadQuoting
    {- ^
    Mismatched or otherwise mangled quoting.
    -}
    | ShellErrorEmptyString
    {- ^
    String to be parsed was empty.
    -}
    | ShellErrorFailed
    {- ^
    Some other error.
    -}
    | AnotherShellError Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum ShellError where
    fromEnum ShellErrorBadQuoting = 0
    fromEnum ShellErrorEmptyString = 1
    fromEnum ShellErrorFailed = 2
    fromEnum (AnotherShellError k) = k

    toEnum 0 = ShellErrorBadQuoting
    toEnum 1 = ShellErrorEmptyString
    toEnum 2 = ShellErrorFailed
    toEnum k = AnotherShellError k

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

instance GErrorClass ShellError where
    gerrorClassDomain _ = "g-shell-error-quark"

-- | Catch exceptions of type `ShellError`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`.
catchShellError ::
    IO a ->
    (ShellError -> GErrorMessage -> IO a) ->
    IO a
catchShellError = catchGErrorJustDomain

-- | Handle exceptions of type `ShellError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`.
handleShellError ::
    (ShellError -> GErrorMessage -> IO a) ->
    IO a ->
    IO a
handleShellError = handleGErrorJustDomain

-- Enum SeekType
{- |
An enumeration specifying the base position for a
'GI.GLib.Structs.IOChannel.iOChannelSeekPosition' operation.
-}
data SeekType = 
      SeekTypeCur
    {- ^
    the current position in the file.
    -}
    | SeekTypeSet
    {- ^
    the start of the file.
    -}
    | SeekTypeEnd
    {- ^
    the end of the file.
    -}
    | AnotherSeekType Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum SeekType where
    fromEnum SeekTypeCur = 0
    fromEnum SeekTypeSet = 1
    fromEnum SeekTypeEnd = 2
    fromEnum (AnotherSeekType k) = k

    toEnum 0 = SeekTypeCur
    toEnum 1 = SeekTypeSet
    toEnum 2 = SeekTypeEnd
    toEnum k = AnotherSeekType k

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

-- Enum RegexError
{- |
Error codes returned by regular expressions functions.

@since 2.14
-}
data RegexError = 
      RegexErrorCompile
    {- ^
    Compilation of the regular expression failed.
    -}
    | RegexErrorOptimize
    {- ^
    Optimization of the regular expression failed.
    -}
    | RegexErrorReplace
    {- ^
    Replacement failed due to an ill-formed replacement
        string.
    -}
    | RegexErrorMatch
    {- ^
    The match process failed.
    -}
    | RegexErrorInternal
    {- ^
    Internal error of the regular expression engine.
        Since 2.16
    -}
    | RegexErrorStrayBackslash
    {- ^
    \"\\\" at end of pattern. Since 2.16
    -}
    | RegexErrorMissingControlChar
    {- ^
    \"\\c\" at end of pattern. Since 2.16
    -}
    | RegexErrorUnrecognizedEscape
    {- ^
    Unrecognized character follows \"\\\".
        Since 2.16
    -}
    | RegexErrorQuantifiersOutOfOrder
    {- ^
    Numbers out of order in \"{}\"
        quantifier. Since 2.16
    -}
    | RegexErrorQuantifierTooBig
    {- ^
    Number too big in \"{}\" quantifier.
        Since 2.16
    -}
    | RegexErrorUnterminatedCharacterClass
    {- ^
    Missing terminating \"]\" for
        character class. Since 2.16
    -}
    | RegexErrorInvalidEscapeInCharacterClass
    {- ^
    Invalid escape sequence
        in character class. Since 2.16
    -}
    | RegexErrorRangeOutOfOrder
    {- ^
    Range out of order in character class.
        Since 2.16
    -}
    | RegexErrorNothingToRepeat
    {- ^
    Nothing to repeat. Since 2.16
    -}
    | RegexErrorUnrecognizedCharacter
    {- ^
    Unrecognized character after \"(?\",
        \"(?\<\" or \"(?P\". Since 2.16
    -}
    | RegexErrorPosixNamedClassOutsideClass
    {- ^
    POSIX named classes are
        supported only within a class. Since 2.16
    -}
    | RegexErrorUnmatchedParenthesis
    {- ^
    Missing terminating \")\" or \")\"
        without opening \"(\". Since 2.16
    -}
    | RegexErrorInexistentSubpatternReference
    {- ^
    Reference to non-existent
        subpattern. Since 2.16
    -}
    | RegexErrorUnterminatedComment
    {- ^
    Missing terminating \")\" after comment.
        Since 2.16
    -}
    | RegexErrorExpressionTooLarge
    {- ^
    Regular expression too large.
        Since 2.16
    -}
    | RegexErrorMemoryError
    {- ^
    Failed to get memory. Since 2.16
    -}
    | RegexErrorVariableLengthLookbehind
    {- ^
    Lookbehind assertion is not
        fixed length. Since 2.16
    -}
    | RegexErrorMalformedCondition
    {- ^
    Malformed number or name after \"(?(\".
        Since 2.16
    -}
    | RegexErrorTooManyConditionalBranches
    {- ^
    Conditional group contains
        more than two branches. Since 2.16
    -}
    | RegexErrorAssertionExpected
    {- ^
    Assertion expected after \"(?(\".
        Since 2.16
    -}
    | RegexErrorUnknownPosixClassName
    {- ^
    Unknown POSIX class name.
        Since 2.16
    -}
    | RegexErrorPosixCollatingElementsNotSupported
    {- ^
    POSIX collating
        elements are not supported. Since 2.16
    -}
    | RegexErrorHexCodeTooLarge
    {- ^
    Character value in \"\\x{...}\" sequence
        is too large. Since 2.16
    -}
    | RegexErrorInvalidCondition
    {- ^
    Invalid condition \"(?(0)\". Since 2.16
    -}
    | RegexErrorSingleByteMatchInLookbehind
    {- ^
    \\C not allowed in
        lookbehind assertion. Since 2.16
    -}
    | RegexErrorInfiniteLoop
    {- ^
    Recursive call could loop indefinitely.
        Since 2.16
    -}
    | RegexErrorMissingSubpatternNameTerminator
    {- ^
    Missing terminator
        in subpattern name. Since 2.16
    -}
    | RegexErrorDuplicateSubpatternName
    {- ^
    Two named subpatterns have
        the same name. Since 2.16
    -}
    | RegexErrorMalformedProperty
    {- ^
    Malformed \"\\P\" or \"\\p\" sequence.
        Since 2.16
    -}
    | RegexErrorUnknownProperty
    {- ^
    Unknown property name after \"\\P\" or
        \"\\p\". Since 2.16
    -}
    | RegexErrorSubpatternNameTooLong
    {- ^
    Subpattern name is too long
        (maximum 32 characters). Since 2.16
    -}
    | RegexErrorTooManySubpatterns
    {- ^
    Too many named subpatterns (maximum
        10,000). Since 2.16
    -}
    | RegexErrorInvalidOctalValue
    {- ^
    Octal value is greater than \"\\377\".
        Since 2.16
    -}
    | RegexErrorTooManyBranchesInDefine
    {- ^
    \"DEFINE\" group contains more
        than one branch. Since 2.16
    -}
    | RegexErrorDefineRepetion
    {- ^
    Repeating a \"DEFINE\" group is not allowed.
        This error is never raised. Since: 2.16 Deprecated: 2.34
    -}
    | RegexErrorInconsistentNewlineOptions
    {- ^
    Inconsistent newline options.
        Since 2.16
    -}
    | RegexErrorMissingBackReference
    {- ^
    \"\\g\" is not followed by a braced,
         angle-bracketed, or quoted name or number, or by a plain number. Since: 2.16
    -}
    | RegexErrorInvalidRelativeReference
    {- ^
    relative reference must not be zero. Since: 2.34
    -}
    | RegexErrorBacktrackingControlVerbArgumentForbidden
    {- ^
    the backtracing
        control verb used does not allow an argument. Since: 2.34
    -}
    | RegexErrorUnknownBacktrackingControlVerb
    {- ^
    unknown backtracing
        control verb. Since: 2.34
    -}
    | RegexErrorNumberTooBig
    {- ^
    number is too big in escape sequence. Since: 2.34
    -}
    | RegexErrorMissingSubpatternName
    {- ^
    Missing subpattern name. Since: 2.34
    -}
    | RegexErrorMissingDigit
    {- ^
    Missing digit. Since 2.34
    -}
    | RegexErrorInvalidDataCharacter
    {- ^
    In JavaScript compatibility mode,
        \"[\" is an invalid data character. Since: 2.34
    -}
    | RegexErrorExtraSubpatternName
    {- ^
    different names for subpatterns of the
        same number are not allowed. Since: 2.34
    -}
    | RegexErrorBacktrackingControlVerbArgumentRequired
    {- ^
    the backtracing control
        verb requires an argument. Since: 2.34
    -}
    | RegexErrorInvalidControlChar
    {- ^
    \"\\c\" must be followed by an ASCII
        character. Since: 2.34
    -}
    | RegexErrorMissingName
    {- ^
    \"\\k\" is not followed by a braced, angle-bracketed, or
        quoted name. Since: 2.34
    -}
    | RegexErrorNotSupportedInClass
    {- ^
    \"\\N\" is not supported in a class. Since: 2.34
    -}
    | RegexErrorTooManyForwardReferences
    {- ^
    too many forward references. Since: 2.34
    -}
    | RegexErrorNameTooLong
    {- ^
    the name is too long in \"(*MARK)\", \"(*PRUNE)\",
        \"(*SKIP)\", or \"(*THEN)\". Since: 2.34
    -}
    | RegexErrorCharacterValueTooLarge
    {- ^
    the character value in the \\u sequence is
        too large. Since: 2.34
    -}
    | AnotherRegexError Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum RegexError where
    fromEnum RegexErrorCompile = 0
    fromEnum RegexErrorOptimize = 1
    fromEnum RegexErrorReplace = 2
    fromEnum RegexErrorMatch = 3
    fromEnum RegexErrorInternal = 4
    fromEnum RegexErrorStrayBackslash = 101
    fromEnum RegexErrorMissingControlChar = 102
    fromEnum RegexErrorUnrecognizedEscape = 103
    fromEnum RegexErrorQuantifiersOutOfOrder = 104
    fromEnum RegexErrorQuantifierTooBig = 105
    fromEnum RegexErrorUnterminatedCharacterClass = 106
    fromEnum RegexErrorInvalidEscapeInCharacterClass = 107
    fromEnum RegexErrorRangeOutOfOrder = 108
    fromEnum RegexErrorNothingToRepeat = 109
    fromEnum RegexErrorUnrecognizedCharacter = 112
    fromEnum RegexErrorPosixNamedClassOutsideClass = 113
    fromEnum RegexErrorUnmatchedParenthesis = 114
    fromEnum RegexErrorInexistentSubpatternReference = 115
    fromEnum RegexErrorUnterminatedComment = 118
    fromEnum RegexErrorExpressionTooLarge = 120
    fromEnum RegexErrorMemoryError = 121
    fromEnum RegexErrorVariableLengthLookbehind = 125
    fromEnum RegexErrorMalformedCondition = 126
    fromEnum RegexErrorTooManyConditionalBranches = 127
    fromEnum RegexErrorAssertionExpected = 128
    fromEnum RegexErrorUnknownPosixClassName = 130
    fromEnum RegexErrorPosixCollatingElementsNotSupported = 131
    fromEnum RegexErrorHexCodeTooLarge = 134
    fromEnum RegexErrorInvalidCondition = 135
    fromEnum RegexErrorSingleByteMatchInLookbehind = 136
    fromEnum RegexErrorInfiniteLoop = 140
    fromEnum RegexErrorMissingSubpatternNameTerminator = 142
    fromEnum RegexErrorDuplicateSubpatternName = 143
    fromEnum RegexErrorMalformedProperty = 146
    fromEnum RegexErrorUnknownProperty = 147
    fromEnum RegexErrorSubpatternNameTooLong = 148
    fromEnum RegexErrorTooManySubpatterns = 149
    fromEnum RegexErrorInvalidOctalValue = 151
    fromEnum RegexErrorTooManyBranchesInDefine = 154
    fromEnum RegexErrorDefineRepetion = 155
    fromEnum RegexErrorInconsistentNewlineOptions = 156
    fromEnum RegexErrorMissingBackReference = 157
    fromEnum RegexErrorInvalidRelativeReference = 158
    fromEnum RegexErrorBacktrackingControlVerbArgumentForbidden = 159
    fromEnum RegexErrorUnknownBacktrackingControlVerb = 160
    fromEnum RegexErrorNumberTooBig = 161
    fromEnum RegexErrorMissingSubpatternName = 162
    fromEnum RegexErrorMissingDigit = 163
    fromEnum RegexErrorInvalidDataCharacter = 164
    fromEnum RegexErrorExtraSubpatternName = 165
    fromEnum RegexErrorBacktrackingControlVerbArgumentRequired = 166
    fromEnum RegexErrorInvalidControlChar = 168
    fromEnum RegexErrorMissingName = 169
    fromEnum RegexErrorNotSupportedInClass = 171
    fromEnum RegexErrorTooManyForwardReferences = 172
    fromEnum RegexErrorNameTooLong = 175
    fromEnum RegexErrorCharacterValueTooLarge = 176
    fromEnum (AnotherRegexError k) = k

    toEnum 0 = RegexErrorCompile
    toEnum 1 = RegexErrorOptimize
    toEnum 2 = RegexErrorReplace
    toEnum 3 = RegexErrorMatch
    toEnum 4 = RegexErrorInternal
    toEnum 101 = RegexErrorStrayBackslash
    toEnum 102 = RegexErrorMissingControlChar
    toEnum 103 = RegexErrorUnrecognizedEscape
    toEnum 104 = RegexErrorQuantifiersOutOfOrder
    toEnum 105 = RegexErrorQuantifierTooBig
    toEnum 106 = RegexErrorUnterminatedCharacterClass
    toEnum 107 = RegexErrorInvalidEscapeInCharacterClass
    toEnum 108 = RegexErrorRangeOutOfOrder
    toEnum 109 = RegexErrorNothingToRepeat
    toEnum 112 = RegexErrorUnrecognizedCharacter
    toEnum 113 = RegexErrorPosixNamedClassOutsideClass
    toEnum 114 = RegexErrorUnmatchedParenthesis
    toEnum 115 = RegexErrorInexistentSubpatternReference
    toEnum 118 = RegexErrorUnterminatedComment
    toEnum 120 = RegexErrorExpressionTooLarge
    toEnum 121 = RegexErrorMemoryError
    toEnum 125 = RegexErrorVariableLengthLookbehind
    toEnum 126 = RegexErrorMalformedCondition
    toEnum 127 = RegexErrorTooManyConditionalBranches
    toEnum 128 = RegexErrorAssertionExpected
    toEnum 130 = RegexErrorUnknownPosixClassName
    toEnum 131 = RegexErrorPosixCollatingElementsNotSupported
    toEnum 134 = RegexErrorHexCodeTooLarge
    toEnum 135 = RegexErrorInvalidCondition
    toEnum 136 = RegexErrorSingleByteMatchInLookbehind
    toEnum 140 = RegexErrorInfiniteLoop
    toEnum 142 = RegexErrorMissingSubpatternNameTerminator
    toEnum 143 = RegexErrorDuplicateSubpatternName
    toEnum 146 = RegexErrorMalformedProperty
    toEnum 147 = RegexErrorUnknownProperty
    toEnum 148 = RegexErrorSubpatternNameTooLong
    toEnum 149 = RegexErrorTooManySubpatterns
    toEnum 151 = RegexErrorInvalidOctalValue
    toEnum 154 = RegexErrorTooManyBranchesInDefine
    toEnum 155 = RegexErrorDefineRepetion
    toEnum 156 = RegexErrorInconsistentNewlineOptions
    toEnum 157 = RegexErrorMissingBackReference
    toEnum 158 = RegexErrorInvalidRelativeReference
    toEnum 159 = RegexErrorBacktrackingControlVerbArgumentForbidden
    toEnum 160 = RegexErrorUnknownBacktrackingControlVerb
    toEnum 161 = RegexErrorNumberTooBig
    toEnum 162 = RegexErrorMissingSubpatternName
    toEnum 163 = RegexErrorMissingDigit
    toEnum 164 = RegexErrorInvalidDataCharacter
    toEnum 165 = RegexErrorExtraSubpatternName
    toEnum 166 = RegexErrorBacktrackingControlVerbArgumentRequired
    toEnum 168 = RegexErrorInvalidControlChar
    toEnum 169 = RegexErrorMissingName
    toEnum 171 = RegexErrorNotSupportedInClass
    toEnum 172 = RegexErrorTooManyForwardReferences
    toEnum 175 = RegexErrorNameTooLong
    toEnum 176 = RegexErrorCharacterValueTooLarge
    toEnum k = AnotherRegexError k

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

instance GErrorClass RegexError where
    gerrorClassDomain _ = "g-regex-error-quark"

-- | Catch exceptions of type `RegexError`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`.
catchRegexError ::
    IO a ->
    (RegexError -> GErrorMessage -> IO a) ->
    IO a
catchRegexError = catchGErrorJustDomain

-- | Handle exceptions of type `RegexError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`.
handleRegexError ::
    (RegexError -> GErrorMessage -> IO a) ->
    IO a ->
    IO a
handleRegexError = handleGErrorJustDomain

-- Enum OptionError
{- |
Error codes returned by option parsing.
-}
data OptionError = 
      OptionErrorUnknownOption
    {- ^
    An option was not known to the parser.
     This error will only be reported, if the parser hasn\'t been instructed
     to ignore unknown options, see 'GI.GLib.Structs.OptionContext.optionContextSetIgnoreUnknownOptions'.
    -}
    | OptionErrorBadValue
    {- ^
    A value couldn\'t be parsed.
    -}
    | OptionErrorFailed
    {- ^
    A 'GI.GLib.Callbacks.OptionArgFunc' callback failed.
    -}
    | AnotherOptionError Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum OptionError where
    fromEnum OptionErrorUnknownOption = 0
    fromEnum OptionErrorBadValue = 1
    fromEnum OptionErrorFailed = 2
    fromEnum (AnotherOptionError k) = k

    toEnum 0 = OptionErrorUnknownOption
    toEnum 1 = OptionErrorBadValue
    toEnum 2 = OptionErrorFailed
    toEnum k = AnotherOptionError k

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

instance GErrorClass OptionError where
    gerrorClassDomain _ = "g-option-context-error-quark"

-- | Catch exceptions of type `OptionError`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`.
catchOptionError ::
    IO a ->
    (OptionError -> GErrorMessage -> IO a) ->
    IO a
catchOptionError = catchGErrorJustDomain

-- | Handle exceptions of type `OptionError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`.
handleOptionError ::
    (OptionError -> GErrorMessage -> IO a) ->
    IO a ->
    IO a
handleOptionError = handleGErrorJustDomain

-- Enum OptionArg
{- |
The 'GI.GLib.Enums.OptionArg' enum values determine which type of extra argument the
options expect to find. If an option expects an extra argument, it can
be specified in several ways; with a short option: @-x arg@, with a long
option: @--name arg@ or combined in a single argument: @--name=arg@.
-}
data OptionArg = 
      OptionArgNone
    {- ^
    No extra argument. This is useful for simple flags.
    -}
    | OptionArgString
    {- ^
    The option takes a string argument.
    -}
    | OptionArgInt
    {- ^
    The option takes an integer argument.
    -}
    | OptionArgCallback
    {- ^
    The option provides a callback (of type
        'GI.GLib.Callbacks.OptionArgFunc') to parse the extra argument.
    -}
    | OptionArgFilename
    {- ^
    The option takes a filename as argument.
    -}
    | OptionArgStringArray
    {- ^
    The option takes a string argument, multiple
        uses of the option are collected into an array of strings.
    -}
    | OptionArgFilenameArray
    {- ^
    The option takes a filename as argument,
        multiple uses of the option are collected into an array of strings.
    -}
    | OptionArgDouble
    {- ^
    The option takes a double argument. The argument
        can be formatted either for the user\'s locale or for the \"C\" locale.
        Since 2.12
    -}
    | OptionArgInt64
    {- ^
    The option takes a 64-bit integer. Like
        'GI.GLib.Enums.OptionArgInt' but for larger numbers. The number can be in
        decimal base, or in hexadecimal (when prefixed with @0x@, for
        example, @0xffffffff@). Since 2.12
    -}
    | AnotherOptionArg Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum OptionArg where
    fromEnum OptionArgNone = 0
    fromEnum OptionArgString = 1
    fromEnum OptionArgInt = 2
    fromEnum OptionArgCallback = 3
    fromEnum OptionArgFilename = 4
    fromEnum OptionArgStringArray = 5
    fromEnum OptionArgFilenameArray = 6
    fromEnum OptionArgDouble = 7
    fromEnum OptionArgInt64 = 8
    fromEnum (AnotherOptionArg k) = k

    toEnum 0 = OptionArgNone
    toEnum 1 = OptionArgString
    toEnum 2 = OptionArgInt
    toEnum 3 = OptionArgCallback
    toEnum 4 = OptionArgFilename
    toEnum 5 = OptionArgStringArray
    toEnum 6 = OptionArgFilenameArray
    toEnum 7 = OptionArgDouble
    toEnum 8 = OptionArgInt64
    toEnum k = AnotherOptionArg k

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

-- Enum OnceStatus
{- |
The possible statuses of a one-time initialization function
controlled by a 'GI.GLib.Structs.Once.Once' struct.

@since 2.4
-}
data OnceStatus = 
      OnceStatusNotcalled
    {- ^
    the function has not been called yet.
    -}
    | OnceStatusProgress
    {- ^
    the function call is currently in progress.
    -}
    | OnceStatusReady
    {- ^
    the function has been called.
    -}
    | AnotherOnceStatus Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum OnceStatus where
    fromEnum OnceStatusNotcalled = 0
    fromEnum OnceStatusProgress = 1
    fromEnum OnceStatusReady = 2
    fromEnum (AnotherOnceStatus k) = k

    toEnum 0 = OnceStatusNotcalled
    toEnum 1 = OnceStatusProgress
    toEnum 2 = OnceStatusReady
    toEnum k = AnotherOnceStatus k

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

-- Enum NumberParserError
{- |
Error codes returned by functions converting a string to a number.

@since 2.54
-}
data NumberParserError = 
      NumberParserErrorInvalid
    {- ^
    String was not a valid number.
    -}
    | NumberParserErrorOutOfBounds
    {- ^
    String was a number, but out of bounds.
    -}
    | AnotherNumberParserError Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum NumberParserError where
    fromEnum NumberParserErrorInvalid = 0
    fromEnum NumberParserErrorOutOfBounds = 1
    fromEnum (AnotherNumberParserError k) = k

    toEnum 0 = NumberParserErrorInvalid
    toEnum 1 = NumberParserErrorOutOfBounds
    toEnum k = AnotherNumberParserError k

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

instance GErrorClass NumberParserError where
    gerrorClassDomain _ = "g-number-parser-error-quark"

-- | Catch exceptions of type `NumberParserError`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`.
catchNumberParserError ::
    IO a ->
    (NumberParserError -> GErrorMessage -> IO a) ->
    IO a
catchNumberParserError = catchGErrorJustDomain

-- | Handle exceptions of type `NumberParserError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`.
handleNumberParserError ::
    (NumberParserError -> GErrorMessage -> IO a) ->
    IO a ->
    IO a
handleNumberParserError = handleGErrorJustDomain

-- Enum NormalizeMode
{- |
Defines how a Unicode string is transformed in a canonical
form, standardizing such issues as whether a character with
an accent is represented as a base character and combining
accent or as a single precomposed character. Unicode strings
should generally be normalized before comparing them.
-}
data NormalizeMode = 
      NormalizeModeDefault
    {- ^
    standardize differences that do not affect the
        text content, such as the above-mentioned accent representation
    -}
    | NormalizeModeNfd
    {- ^
    another name for 'GI.GLib.Enums.NormalizeModeDefault'
    -}
    | NormalizeModeDefaultCompose
    {- ^
    like 'GI.GLib.Enums.NormalizeModeDefault', but with
        composed forms rather than a maximally decomposed form
    -}
    | NormalizeModeNfc
    {- ^
    another name for 'GI.GLib.Enums.NormalizeModeDefaultCompose'
    -}
    | NormalizeModeAll
    {- ^
    beyond 'GI.GLib.Enums.NormalizeModeDefault' also standardize the
        \"compatibility\" characters in Unicode, such as SUPERSCRIPT THREE
        to the standard forms (in this case DIGIT THREE). Formatting
        information may be lost but for most text operations such
        characters should be considered the same
    -}
    | NormalizeModeNfkd
    {- ^
    another name for 'GI.GLib.Enums.NormalizeModeAll'
    -}
    | NormalizeModeAllCompose
    {- ^
    like 'GI.GLib.Enums.NormalizeModeAll', but with composed
        forms rather than a maximally decomposed form
    -}
    | NormalizeModeNfkc
    {- ^
    another name for 'GI.GLib.Enums.NormalizeModeAllCompose'
    -}
    | AnotherNormalizeMode Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum NormalizeMode where
    fromEnum NormalizeModeDefault = 0
    fromEnum NormalizeModeNfd = 0
    fromEnum NormalizeModeDefaultCompose = 1
    fromEnum NormalizeModeNfc = 1
    fromEnum NormalizeModeAll = 2
    fromEnum NormalizeModeNfkd = 2
    fromEnum NormalizeModeAllCompose = 3
    fromEnum NormalizeModeNfkc = 3
    fromEnum (AnotherNormalizeMode k) = k

    toEnum 0 = NormalizeModeDefault
    toEnum 0 = NormalizeModeNfd
    toEnum 1 = NormalizeModeDefaultCompose
    toEnum 1 = NormalizeModeNfc
    toEnum 2 = NormalizeModeAll
    toEnum 2 = NormalizeModeNfkd
    toEnum 3 = NormalizeModeAllCompose
    toEnum 3 = NormalizeModeNfkc
    toEnum k = AnotherNormalizeMode k

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

-- Enum MarkupError
{- |
Error codes returned by markup parsing.
-}
data MarkupError = 
      MarkupErrorBadUtf8
    {- ^
    text being parsed was not valid UTF-8
    -}
    | MarkupErrorEmpty
    {- ^
    document contained nothing, or only whitespace
    -}
    | MarkupErrorParse
    {- ^
    document was ill-formed
    -}
    | MarkupErrorUnknownElement
    {- ^
    error should be set by 'GI.GLib.Structs.MarkupParser.MarkupParser'
        functions; element wasn\'t known
    -}
    | MarkupErrorUnknownAttribute
    {- ^
    error should be set by 'GI.GLib.Structs.MarkupParser.MarkupParser'
        functions; attribute wasn\'t known
    -}
    | MarkupErrorInvalidContent
    {- ^
    error should be set by 'GI.GLib.Structs.MarkupParser.MarkupParser'
        functions; content was invalid
    -}
    | MarkupErrorMissingAttribute
    {- ^
    error should be set by 'GI.GLib.Structs.MarkupParser.MarkupParser'
        functions; a required attribute was missing
    -}
    | AnotherMarkupError Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum MarkupError where
    fromEnum MarkupErrorBadUtf8 = 0
    fromEnum MarkupErrorEmpty = 1
    fromEnum MarkupErrorParse = 2
    fromEnum MarkupErrorUnknownElement = 3
    fromEnum MarkupErrorUnknownAttribute = 4
    fromEnum MarkupErrorInvalidContent = 5
    fromEnum MarkupErrorMissingAttribute = 6
    fromEnum (AnotherMarkupError k) = k

    toEnum 0 = MarkupErrorBadUtf8
    toEnum 1 = MarkupErrorEmpty
    toEnum 2 = MarkupErrorParse
    toEnum 3 = MarkupErrorUnknownElement
    toEnum 4 = MarkupErrorUnknownAttribute
    toEnum 5 = MarkupErrorInvalidContent
    toEnum 6 = MarkupErrorMissingAttribute
    toEnum k = AnotherMarkupError k

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

instance GErrorClass MarkupError where
    gerrorClassDomain _ = "g-markup-error-quark"

-- | Catch exceptions of type `MarkupError`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`.
catchMarkupError ::
    IO a ->
    (MarkupError -> GErrorMessage -> IO a) ->
    IO a
catchMarkupError = catchGErrorJustDomain

-- | Handle exceptions of type `MarkupError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`.
handleMarkupError ::
    (MarkupError -> GErrorMessage -> IO a) ->
    IO a ->
    IO a
handleMarkupError = handleGErrorJustDomain

-- Enum LogWriterOutput
{- |
Return values from @/GLogWriterFuncs/@ to indicate whether the given log entry
was successfully handled by the writer, or whether there was an error in
handling it (and hence a fallback writer should be used).

If a 'GI.GLib.Callbacks.LogWriterFunc' ignores a log entry, it should return
'GI.GLib.Enums.LogWriterOutputHandled'.

@since 2.50
-}
data LogWriterOutput = 
      LogWriterOutputHandled
    {- ^
    Log writer has handled the log entry.
    -}
    | LogWriterOutputUnhandled
    {- ^
    Log writer could not handle the log entry.
    -}
    | AnotherLogWriterOutput Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum LogWriterOutput where
    fromEnum LogWriterOutputHandled = 1
    fromEnum LogWriterOutputUnhandled = 0
    fromEnum (AnotherLogWriterOutput k) = k

    toEnum 1 = LogWriterOutputHandled
    toEnum 0 = LogWriterOutputUnhandled
    toEnum k = AnotherLogWriterOutput k

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

-- Enum KeyFileError
{- |
Error codes returned by key file parsing.
-}
data KeyFileError = 
      KeyFileErrorUnknownEncoding
    {- ^
    the text being parsed was in
        an unknown encoding
    -}
    | KeyFileErrorParse
    {- ^
    document was ill-formed
    -}
    | KeyFileErrorNotFound
    {- ^
    the file was not found
    -}
    | KeyFileErrorKeyNotFound
    {- ^
    a requested key was not found
    -}
    | KeyFileErrorGroupNotFound
    {- ^
    a requested group was not found
    -}
    | KeyFileErrorInvalidValue
    {- ^
    a value could not be parsed
    -}
    | AnotherKeyFileError Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum KeyFileError where
    fromEnum KeyFileErrorUnknownEncoding = 0
    fromEnum KeyFileErrorParse = 1
    fromEnum KeyFileErrorNotFound = 2
    fromEnum KeyFileErrorKeyNotFound = 3
    fromEnum KeyFileErrorGroupNotFound = 4
    fromEnum KeyFileErrorInvalidValue = 5
    fromEnum (AnotherKeyFileError k) = k

    toEnum 0 = KeyFileErrorUnknownEncoding
    toEnum 1 = KeyFileErrorParse
    toEnum 2 = KeyFileErrorNotFound
    toEnum 3 = KeyFileErrorKeyNotFound
    toEnum 4 = KeyFileErrorGroupNotFound
    toEnum 5 = KeyFileErrorInvalidValue
    toEnum k = AnotherKeyFileError k

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

instance GErrorClass KeyFileError where
    gerrorClassDomain _ = "g-key-file-error-quark"

-- | Catch exceptions of type `KeyFileError`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`.
catchKeyFileError ::
    IO a ->
    (KeyFileError -> GErrorMessage -> IO a) ->
    IO a
catchKeyFileError = catchGErrorJustDomain

-- | Handle exceptions of type `KeyFileError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`.
handleKeyFileError ::
    (KeyFileError -> GErrorMessage -> IO a) ->
    IO a ->
    IO a
handleKeyFileError = handleGErrorJustDomain

-- Enum IOStatus
{- |
Stati returned by most of the 'GI.GLib.Structs.IOFuncs.IOFuncs' functions.
-}
data IOStatus = 
      IOStatusError
    {- ^
    An error occurred.
    -}
    | IOStatusNormal
    {- ^
    Success.
    -}
    | IOStatusEof
    {- ^
    End of file.
    -}
    | IOStatusAgain
    {- ^
    Resource temporarily unavailable.
    -}
    | AnotherIOStatus Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum IOStatus where
    fromEnum IOStatusError = 0
    fromEnum IOStatusNormal = 1
    fromEnum IOStatusEof = 2
    fromEnum IOStatusAgain = 3
    fromEnum (AnotherIOStatus k) = k

    toEnum 0 = IOStatusError
    toEnum 1 = IOStatusNormal
    toEnum 2 = IOStatusEof
    toEnum 3 = IOStatusAgain
    toEnum k = AnotherIOStatus k

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

-- Enum IOError
{- |
'GI.GLib.Enums.IOError' is only used by the deprecated functions
'GI.GLib.Structs.IOChannel.iOChannelRead', 'GI.GLib.Structs.IOChannel.iOChannelWrite', and 'GI.GLib.Structs.IOChannel.iOChannelSeek'.
-}
data IOError = 
      IOErrorNone
    {- ^
    no error
    -}
    | IOErrorAgain
    {- ^
    an EAGAIN error occurred
    -}
    | IOErrorInval
    {- ^
    an EINVAL error occurred
    -}
    | IOErrorUnknown
    {- ^
    another error occurred
    -}
    | AnotherIOError Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum IOError where
    fromEnum IOErrorNone = 0
    fromEnum IOErrorAgain = 1
    fromEnum IOErrorInval = 2
    fromEnum IOErrorUnknown = 3
    fromEnum (AnotherIOError k) = k

    toEnum 0 = IOErrorNone
    toEnum 1 = IOErrorAgain
    toEnum 2 = IOErrorInval
    toEnum 3 = IOErrorUnknown
    toEnum k = AnotherIOError k

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

-- Enum IOChannelError
{- |
Error codes returned by 'GI.GLib.Structs.IOChannel.IOChannel' operations.
-}
data IOChannelError = 
      IOChannelErrorFbig
    {- ^
    File too large.
    -}
    | IOChannelErrorInval
    {- ^
    Invalid argument.
    -}
    | IOChannelErrorIo
    {- ^
    IO error.
    -}
    | IOChannelErrorIsdir
    {- ^
    File is a directory.
    -}
    | IOChannelErrorNospc
    {- ^
    No space left on device.
    -}
    | IOChannelErrorNxio
    {- ^
    No such device or address.
    -}
    | IOChannelErrorOverflow
    {- ^
    Value too large for defined datatype.
    -}
    | IOChannelErrorPipe
    {- ^
    Broken pipe.
    -}
    | IOChannelErrorFailed
    {- ^
    Some other error.
    -}
    | AnotherIOChannelError Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum IOChannelError where
    fromEnum IOChannelErrorFbig = 0
    fromEnum IOChannelErrorInval = 1
    fromEnum IOChannelErrorIo = 2
    fromEnum IOChannelErrorIsdir = 3
    fromEnum IOChannelErrorNospc = 4
    fromEnum IOChannelErrorNxio = 5
    fromEnum IOChannelErrorOverflow = 6
    fromEnum IOChannelErrorPipe = 7
    fromEnum IOChannelErrorFailed = 8
    fromEnum (AnotherIOChannelError k) = k

    toEnum 0 = IOChannelErrorFbig
    toEnum 1 = IOChannelErrorInval
    toEnum 2 = IOChannelErrorIo
    toEnum 3 = IOChannelErrorIsdir
    toEnum 4 = IOChannelErrorNospc
    toEnum 5 = IOChannelErrorNxio
    toEnum 6 = IOChannelErrorOverflow
    toEnum 7 = IOChannelErrorPipe
    toEnum 8 = IOChannelErrorFailed
    toEnum k = AnotherIOChannelError k

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

instance GErrorClass IOChannelError where
    gerrorClassDomain _ = "g-io-channel-error-quark"

-- | Catch exceptions of type `IOChannelError`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`.
catchIOChannelError ::
    IO a ->
    (IOChannelError -> GErrorMessage -> IO a) ->
    IO a
catchIOChannelError = catchGErrorJustDomain

-- | Handle exceptions of type `IOChannelError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`.
handleIOChannelError ::
    (IOChannelError -> GErrorMessage -> IO a) ->
    IO a ->
    IO a
handleIOChannelError = handleGErrorJustDomain

-- Enum FileError
{- |
Values corresponding to /@errno@/ codes returned from file operations
on UNIX. Unlike /@errno@/ codes, GFileError values are available on
all systems, even Windows. The exact meaning of each code depends
on what sort of file operation you were performing; the UNIX
documentation gives more details. The following error code descriptions
come from the GNU C Library manual, and are under the copyright
of that manual.

It\'s not very portable to make detailed assumptions about exactly
which errors will be returned from a given operation. Some errors
don\'t occur on some systems, etc., sometimes there are subtle
differences in when a system will report a given error, etc.
-}
data FileError = 
      FileErrorExist
    {- ^
    Operation not permitted; only the owner of
        the file (or other resource) or processes with special privileges
        can perform the operation.
    -}
    | FileErrorIsdir
    {- ^
    File is a directory; you cannot open a directory
        for writing, or create or remove hard links to it.
    -}
    | FileErrorAcces
    {- ^
    Permission denied; the file permissions do not
        allow the attempted operation.
    -}
    | FileErrorNametoolong
    {- ^
    Filename too long.
    -}
    | FileErrorNoent
    {- ^
    No such file or directory. This is a \"file
        doesn\'t exist\" error for ordinary files that are referenced in
        contexts where they are expected to already exist.
    -}
    | FileErrorNotdir
    {- ^
    A file that isn\'t a directory was specified when
        a directory is required.
    -}
    | FileErrorNxio
    {- ^
    No such device or address. The system tried to
        use the device represented by a file you specified, and it
        couldn\'t find the device. This can mean that the device file was
        installed incorrectly, or that the physical device is missing or
        not correctly attached to the computer.
    -}
    | FileErrorNodev
    {- ^
    The underlying file system of the specified file
        does not support memory mapping.
    -}
    | FileErrorRofs
    {- ^
    The directory containing the new link can\'t be
        modified because it\'s on a read-only file system.
    -}
    | FileErrorTxtbsy
    {- ^
    Text file busy.
    -}
    | FileErrorFault
    {- ^
    You passed in a pointer to bad memory.
        (GLib won\'t reliably return this, don\'t pass in pointers to bad
        memory.)
    -}
    | FileErrorLoop
    {- ^
    Too many levels of symbolic links were encountered
        in looking up a file name. This often indicates a cycle of symbolic
        links.
    -}
    | FileErrorNospc
    {- ^
    No space left on device; write operation on a
        file failed because the disk is full.
    -}
    | FileErrorNomem
    {- ^
    No memory available. The system cannot allocate
        more virtual memory because its capacity is full.
    -}
    | FileErrorMfile
    {- ^
    The current process has too many files open and
        can\'t open any more. Duplicate descriptors do count toward this
        limit.
    -}
    | FileErrorNfile
    {- ^
    There are too many distinct file openings in the
        entire system.
    -}
    | FileErrorBadf
    {- ^
    Bad file descriptor; for example, I\/O on a
        descriptor that has been closed or reading from a descriptor open
        only for writing (or vice versa).
    -}
    | FileErrorInval
    {- ^
    Invalid argument. This is used to indicate
        various kinds of problems with passing the wrong argument to a
        library function.
    -}
    | FileErrorPipe
    {- ^
    Broken pipe; there is no process reading from the
        other end of a pipe. Every library function that returns this
        error code also generates a \'SIGPIPE\' signal; this signal
        terminates the program if not handled or blocked. Thus, your
        program will never actually see this code unless it has handled
        or blocked \'SIGPIPE\'.
    -}
    | FileErrorAgain
    {- ^
    Resource temporarily unavailable; the call might
        work if you try again later.
    -}
    | FileErrorIntr
    {- ^
    Interrupted function call; an asynchronous signal
        occurred and prevented completion of the call. When this
        happens, you should try the call again.
    -}
    | FileErrorIo
    {- ^
    Input\/output error; usually used for physical read
       or write errors. i.e. the disk or other physical device hardware
       is returning errors.
    -}
    | FileErrorPerm
    {- ^
    Operation not permitted; only the owner of the
       file (or other resource) or processes with special privileges can
       perform the operation.
    -}
    | FileErrorNosys
    {- ^
    Function not implemented; this indicates that
       the system is missing some functionality.
    -}
    | FileErrorFailed
    {- ^
    Does not correspond to a UNIX error code; this
       is the standard \"failed for unspecified reason\" error code present
       in all 'GError' error code enumerations. Returned if no specific
       code applies.
    -}
    | AnotherFileError Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum FileError where
    fromEnum FileErrorExist = 0
    fromEnum FileErrorIsdir = 1
    fromEnum FileErrorAcces = 2
    fromEnum FileErrorNametoolong = 3
    fromEnum FileErrorNoent = 4
    fromEnum FileErrorNotdir = 5
    fromEnum FileErrorNxio = 6
    fromEnum FileErrorNodev = 7
    fromEnum FileErrorRofs = 8
    fromEnum FileErrorTxtbsy = 9
    fromEnum FileErrorFault = 10
    fromEnum FileErrorLoop = 11
    fromEnum FileErrorNospc = 12
    fromEnum FileErrorNomem = 13
    fromEnum FileErrorMfile = 14
    fromEnum FileErrorNfile = 15
    fromEnum FileErrorBadf = 16
    fromEnum FileErrorInval = 17
    fromEnum FileErrorPipe = 18
    fromEnum FileErrorAgain = 19
    fromEnum FileErrorIntr = 20
    fromEnum FileErrorIo = 21
    fromEnum FileErrorPerm = 22
    fromEnum FileErrorNosys = 23
    fromEnum FileErrorFailed = 24
    fromEnum (AnotherFileError k) = k

    toEnum 0 = FileErrorExist
    toEnum 1 = FileErrorIsdir
    toEnum 2 = FileErrorAcces
    toEnum 3 = FileErrorNametoolong
    toEnum 4 = FileErrorNoent
    toEnum 5 = FileErrorNotdir
    toEnum 6 = FileErrorNxio
    toEnum 7 = FileErrorNodev
    toEnum 8 = FileErrorRofs
    toEnum 9 = FileErrorTxtbsy
    toEnum 10 = FileErrorFault
    toEnum 11 = FileErrorLoop
    toEnum 12 = FileErrorNospc
    toEnum 13 = FileErrorNomem
    toEnum 14 = FileErrorMfile
    toEnum 15 = FileErrorNfile
    toEnum 16 = FileErrorBadf
    toEnum 17 = FileErrorInval
    toEnum 18 = FileErrorPipe
    toEnum 19 = FileErrorAgain
    toEnum 20 = FileErrorIntr
    toEnum 21 = FileErrorIo
    toEnum 22 = FileErrorPerm
    toEnum 23 = FileErrorNosys
    toEnum 24 = FileErrorFailed
    toEnum k = AnotherFileError k

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

instance GErrorClass FileError where
    gerrorClassDomain _ = "g-file-error-quark"

-- | Catch exceptions of type `FileError`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`.
catchFileError ::
    IO a ->
    (FileError -> GErrorMessage -> IO a) ->
    IO a
catchFileError = catchGErrorJustDomain

-- | Handle exceptions of type `FileError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`.
handleFileError ::
    (FileError -> GErrorMessage -> IO a) ->
    IO a ->
    IO a
handleFileError = handleGErrorJustDomain

-- Enum ErrorType
{- |
The possible errors, used in the /@vError@/ field
of 'GI.GLib.Unions.TokenValue.TokenValue', when the token is a 'GI.GLib.Enums.TokenTypeError'.
-}
data ErrorType = 
      ErrorTypeUnknown
    {- ^
    unknown error
    -}
    | ErrorTypeUnexpEof
    {- ^
    unexpected end of file
    -}
    | ErrorTypeUnexpEofInString
    {- ^
    unterminated string constant
    -}
    | ErrorTypeUnexpEofInComment
    {- ^
    unterminated comment
    -}
    | ErrorTypeNonDigitInConst
    {- ^
    non-digit character in a number
    -}
    | ErrorTypeDigitRadix
    {- ^
    digit beyond radix in a number
    -}
    | ErrorTypeFloatRadix
    {- ^
    non-decimal floating point number
    -}
    | ErrorTypeFloatMalformed
    {- ^
    malformed floating point number
    -}
    | AnotherErrorType Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum ErrorType where
    fromEnum ErrorTypeUnknown = 0
    fromEnum ErrorTypeUnexpEof = 1
    fromEnum ErrorTypeUnexpEofInString = 2
    fromEnum ErrorTypeUnexpEofInComment = 3
    fromEnum ErrorTypeNonDigitInConst = 4
    fromEnum ErrorTypeDigitRadix = 5
    fromEnum ErrorTypeFloatRadix = 6
    fromEnum ErrorTypeFloatMalformed = 7
    fromEnum (AnotherErrorType k) = k

    toEnum 0 = ErrorTypeUnknown
    toEnum 1 = ErrorTypeUnexpEof
    toEnum 2 = ErrorTypeUnexpEofInString
    toEnum 3 = ErrorTypeUnexpEofInComment
    toEnum 4 = ErrorTypeNonDigitInConst
    toEnum 5 = ErrorTypeDigitRadix
    toEnum 6 = ErrorTypeFloatRadix
    toEnum 7 = ErrorTypeFloatMalformed
    toEnum k = AnotherErrorType k

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

-- Enum DateWeekday
{- |
Enumeration representing a day of the week; @/G_DATE_MONDAY/@,
@/G_DATE_TUESDAY/@, etc. @/G_DATE_BAD_WEEKDAY/@ is an invalid weekday.
-}
data DateWeekday = 
      DateWeekdayBadWeekday
    {- ^
    invalid value
    -}
    | DateWeekdayMonday
    {- ^
    Monday
    -}
    | DateWeekdayTuesday
    {- ^
    Tuesday
    -}
    | DateWeekdayWednesday
    {- ^
    Wednesday
    -}
    | DateWeekdayThursday
    {- ^
    Thursday
    -}
    | DateWeekdayFriday
    {- ^
    Friday
    -}
    | DateWeekdaySaturday
    {- ^
    Saturday
    -}
    | DateWeekdaySunday
    {- ^
    Sunday
    -}
    | AnotherDateWeekday Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum DateWeekday where
    fromEnum DateWeekdayBadWeekday = 0
    fromEnum DateWeekdayMonday = 1
    fromEnum DateWeekdayTuesday = 2
    fromEnum DateWeekdayWednesday = 3
    fromEnum DateWeekdayThursday = 4
    fromEnum DateWeekdayFriday = 5
    fromEnum DateWeekdaySaturday = 6
    fromEnum DateWeekdaySunday = 7
    fromEnum (AnotherDateWeekday k) = k

    toEnum 0 = DateWeekdayBadWeekday
    toEnum 1 = DateWeekdayMonday
    toEnum 2 = DateWeekdayTuesday
    toEnum 3 = DateWeekdayWednesday
    toEnum 4 = DateWeekdayThursday
    toEnum 5 = DateWeekdayFriday
    toEnum 6 = DateWeekdaySaturday
    toEnum 7 = DateWeekdaySunday
    toEnum k = AnotherDateWeekday k

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

-- Enum DateMonth
{- |
Enumeration representing a month; values are @/G_DATE_JANUARY/@,
@/G_DATE_FEBRUARY/@, etc. @/G_DATE_BAD_MONTH/@ is the invalid value.
-}
data DateMonth = 
      DateMonthBadMonth
    {- ^
    invalid value
    -}
    | DateMonthJanuary
    {- ^
    January
    -}
    | DateMonthFebruary
    {- ^
    February
    -}
    | DateMonthMarch
    {- ^
    March
    -}
    | DateMonthApril
    {- ^
    April
    -}
    | DateMonthMay
    {- ^
    May
    -}
    | DateMonthJune
    {- ^
    June
    -}
    | DateMonthJuly
    {- ^
    July
    -}
    | DateMonthAugust
    {- ^
    August
    -}
    | DateMonthSeptember
    {- ^
    September
    -}
    | DateMonthOctober
    {- ^
    October
    -}
    | DateMonthNovember
    {- ^
    November
    -}
    | DateMonthDecember
    {- ^
    December
    -}
    | AnotherDateMonth Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum DateMonth where
    fromEnum DateMonthBadMonth = 0
    fromEnum DateMonthJanuary = 1
    fromEnum DateMonthFebruary = 2
    fromEnum DateMonthMarch = 3
    fromEnum DateMonthApril = 4
    fromEnum DateMonthMay = 5
    fromEnum DateMonthJune = 6
    fromEnum DateMonthJuly = 7
    fromEnum DateMonthAugust = 8
    fromEnum DateMonthSeptember = 9
    fromEnum DateMonthOctober = 10
    fromEnum DateMonthNovember = 11
    fromEnum DateMonthDecember = 12
    fromEnum (AnotherDateMonth k) = k

    toEnum 0 = DateMonthBadMonth
    toEnum 1 = DateMonthJanuary
    toEnum 2 = DateMonthFebruary
    toEnum 3 = DateMonthMarch
    toEnum 4 = DateMonthApril
    toEnum 5 = DateMonthMay
    toEnum 6 = DateMonthJune
    toEnum 7 = DateMonthJuly
    toEnum 8 = DateMonthAugust
    toEnum 9 = DateMonthSeptember
    toEnum 10 = DateMonthOctober
    toEnum 11 = DateMonthNovember
    toEnum 12 = DateMonthDecember
    toEnum k = AnotherDateMonth k

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

-- Enum DateDMY
{- |
This enumeration isn\'t used in the API, but may be useful if you need
to mark a number as a day, month, or year.
-}
data DateDMY = 
      DateDMYDay
    {- ^
    a day
    -}
    | DateDMYMonth
    {- ^
    a month
    -}
    | DateDMYYear
    {- ^
    a year
    -}
    | AnotherDateDMY Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum DateDMY where
    fromEnum DateDMYDay = 0
    fromEnum DateDMYMonth = 1
    fromEnum DateDMYYear = 2
    fromEnum (AnotherDateDMY k) = k

    toEnum 0 = DateDMYDay
    toEnum 1 = DateDMYMonth
    toEnum 2 = DateDMYYear
    toEnum k = AnotherDateDMY k

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

-- Enum ConvertError
{- |
Error codes returned by character set conversion routines.
-}
data ConvertError = 
      ConvertErrorNoConversion
    {- ^
    Conversion between the requested character
        sets is not supported.
    -}
    | ConvertErrorIllegalSequence
    {- ^
    Invalid byte sequence in conversion input.
    -}
    | ConvertErrorFailed
    {- ^
    Conversion failed for some reason.
    -}
    | ConvertErrorPartialInput
    {- ^
    Partial character sequence at end of input.
    -}
    | ConvertErrorBadUri
    {- ^
    URI is invalid.
    -}
    | ConvertErrorNotAbsolutePath
    {- ^
    Pathname is not an absolute path.
    -}
    | ConvertErrorNoMemory
    {- ^
    No memory available. Since: 2.40
    -}
    | AnotherConvertError Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum ConvertError where
    fromEnum ConvertErrorNoConversion = 0
    fromEnum ConvertErrorIllegalSequence = 1
    fromEnum ConvertErrorFailed = 2
    fromEnum ConvertErrorPartialInput = 3
    fromEnum ConvertErrorBadUri = 4
    fromEnum ConvertErrorNotAbsolutePath = 5
    fromEnum ConvertErrorNoMemory = 6
    fromEnum (AnotherConvertError k) = k

    toEnum 0 = ConvertErrorNoConversion
    toEnum 1 = ConvertErrorIllegalSequence
    toEnum 2 = ConvertErrorFailed
    toEnum 3 = ConvertErrorPartialInput
    toEnum 4 = ConvertErrorBadUri
    toEnum 5 = ConvertErrorNotAbsolutePath
    toEnum 6 = ConvertErrorNoMemory
    toEnum k = AnotherConvertError k

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

instance GErrorClass ConvertError where
    gerrorClassDomain _ = "g_convert_error"

-- | Catch exceptions of type `ConvertError`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`.
catchConvertError ::
    IO a ->
    (ConvertError -> GErrorMessage -> IO a) ->
    IO a
catchConvertError = catchGErrorJustDomain

-- | Handle exceptions of type `ConvertError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`.
handleConvertError ::
    (ConvertError -> GErrorMessage -> IO a) ->
    IO a ->
    IO a
handleConvertError = handleGErrorJustDomain

-- Enum ChecksumType
{- |
The hashing algorithm to be used by 'GI.GLib.Structs.Checksum.Checksum' when performing the
digest of some data.

Note that the 'GI.GLib.Enums.ChecksumType' enumeration may be extended at a later
date to include new hashing algorithm types.

@since 2.16
-}
data ChecksumType = 
      ChecksumTypeMd5
    {- ^
    Use the MD5 hashing algorithm
    -}
    | ChecksumTypeSha1
    {- ^
    Use the SHA-1 hashing algorithm
    -}
    | ChecksumTypeSha256
    {- ^
    Use the SHA-256 hashing algorithm
    -}
    | ChecksumTypeSha512
    {- ^
    Use the SHA-512 hashing algorithm (Since: 2.36)
    -}
    | ChecksumTypeSha384
    {- ^
    Use the SHA-384 hashing algorithm (Since: 2.51)
    -}
    | AnotherChecksumType Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum ChecksumType where
    fromEnum ChecksumTypeMd5 = 0
    fromEnum ChecksumTypeSha1 = 1
    fromEnum ChecksumTypeSha256 = 2
    fromEnum ChecksumTypeSha512 = 3
    fromEnum ChecksumTypeSha384 = 4
    fromEnum (AnotherChecksumType k) = k

    toEnum 0 = ChecksumTypeMd5
    toEnum 1 = ChecksumTypeSha1
    toEnum 2 = ChecksumTypeSha256
    toEnum 3 = ChecksumTypeSha512
    toEnum 4 = ChecksumTypeSha384
    toEnum k = AnotherChecksumType k

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

-- Enum BookmarkFileError
{- |
Error codes returned by bookmark file parsing.
-}
data BookmarkFileError = 
      BookmarkFileErrorInvalidUri
    {- ^
    URI was ill-formed
    -}
    | BookmarkFileErrorInvalidValue
    {- ^
    a requested field was not found
    -}
    | BookmarkFileErrorAppNotRegistered
    {- ^
    a requested application did
        not register a bookmark
    -}
    | BookmarkFileErrorUriNotFound
    {- ^
    a requested URI was not found
    -}
    | BookmarkFileErrorRead
    {- ^
    document was ill formed
    -}
    | BookmarkFileErrorUnknownEncoding
    {- ^
    the text being parsed was
        in an unknown encoding
    -}
    | BookmarkFileErrorWrite
    {- ^
    an error occurred while writing
    -}
    | BookmarkFileErrorFileNotFound
    {- ^
    requested file was not found
    -}
    | AnotherBookmarkFileError Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum BookmarkFileError where
    fromEnum BookmarkFileErrorInvalidUri = 0
    fromEnum BookmarkFileErrorInvalidValue = 1
    fromEnum BookmarkFileErrorAppNotRegistered = 2
    fromEnum BookmarkFileErrorUriNotFound = 3
    fromEnum BookmarkFileErrorRead = 4
    fromEnum BookmarkFileErrorUnknownEncoding = 5
    fromEnum BookmarkFileErrorWrite = 6
    fromEnum BookmarkFileErrorFileNotFound = 7
    fromEnum (AnotherBookmarkFileError k) = k

    toEnum 0 = BookmarkFileErrorInvalidUri
    toEnum 1 = BookmarkFileErrorInvalidValue
    toEnum 2 = BookmarkFileErrorAppNotRegistered
    toEnum 3 = BookmarkFileErrorUriNotFound
    toEnum 4 = BookmarkFileErrorRead
    toEnum 5 = BookmarkFileErrorUnknownEncoding
    toEnum 6 = BookmarkFileErrorWrite
    toEnum 7 = BookmarkFileErrorFileNotFound
    toEnum k = AnotherBookmarkFileError k

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

instance GErrorClass BookmarkFileError where
    gerrorClassDomain _ = "g-bookmark-file-error-quark"

-- | Catch exceptions of type `BookmarkFileError`. This is a specialized version of `Data.GI.Base.GError.catchGErrorJustDomain`.
catchBookmarkFileError ::
    IO a ->
    (BookmarkFileError -> GErrorMessage -> IO a) ->
    IO a
catchBookmarkFileError = catchGErrorJustDomain

-- | Handle exceptions of type `BookmarkFileError`. This is a specialized version of `Data.GI.Base.GError.handleGErrorJustDomain`.
handleBookmarkFileError ::
    (BookmarkFileError -> GErrorMessage -> IO a) ->
    IO a ->
    IO a
handleBookmarkFileError = handleGErrorJustDomain