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

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

module GI.Poppler.Enums
    ( 

 -- * Enumerations
-- ** ActionLayerAction #enum:ActionLayerAction#

    ActionLayerAction(..)                   ,


-- ** ActionMovieOperation #enum:ActionMovieOperation#

    ActionMovieOperation(..)                ,


-- ** ActionType #enum:ActionType#

    ActionType(..)                          ,


-- ** AdditionalActionType #enum:AdditionalActionType#

    AdditionalActionType(..)                ,


-- ** AnnotExternalDataType #enum:AnnotExternalDataType#

    AnnotExternalDataType(..)               ,


-- ** AnnotFreeTextQuadding #enum:AnnotFreeTextQuadding#

    AnnotFreeTextQuadding(..)               ,


-- ** AnnotMarkupReplyType #enum:AnnotMarkupReplyType#

    AnnotMarkupReplyType(..)                ,


-- ** AnnotTextState #enum:AnnotTextState#

    AnnotTextState(..)                      ,


-- ** AnnotType #enum:AnnotType#

    AnnotType(..)                           ,


-- ** Backend #enum:Backend#

    Backend(..)                             ,


-- ** DestType #enum:DestType#

    DestType(..)                            ,


-- ** Error #enum:Error#

    Error(..)                               ,
    catchError                              ,
    handleError                             ,


-- ** FontType #enum:FontType#

    FontType(..)                            ,


-- ** FormButtonType #enum:FormButtonType#

    FormButtonType(..)                      ,


-- ** FormChoiceType #enum:FormChoiceType#

    FormChoiceType(..)                      ,


-- ** FormFieldType #enum:FormFieldType#

    FormFieldType(..)                       ,


-- ** FormTextType #enum:FormTextType#

    FormTextType(..)                        ,


-- ** MoviePlayMode #enum:MoviePlayMode#

    MoviePlayMode(..)                       ,


-- ** PDFConformance #enum:PDFConformance#

    PDFConformance(..)                      ,


-- ** PDFPart #enum:PDFPart#

    PDFPart(..)                             ,


-- ** PDFSubtype #enum:PDFSubtype#

    PDFSubtype(..)                          ,


-- ** PageLayout #enum:PageLayout#

    PageLayout(..)                          ,


-- ** PageMode #enum:PageMode#

    PageMode(..)                            ,


-- ** PageTransitionAlignment #enum:PageTransitionAlignment#

    PageTransitionAlignment(..)             ,


-- ** PageTransitionDirection #enum:PageTransitionDirection#

    PageTransitionDirection(..)             ,


-- ** PageTransitionType #enum:PageTransitionType#

    PageTransitionType(..)                  ,


-- ** PrintScaling #enum:PrintScaling#

    PrintScaling(..)                        ,


-- ** SelectionStyle #enum:SelectionStyle#

    SelectionStyle(..)                      ,


-- ** StructureBlockAlign #enum:StructureBlockAlign#

    StructureBlockAlign(..)                 ,


-- ** StructureBorderStyle #enum:StructureBorderStyle#

    StructureBorderStyle(..)                ,


-- ** StructureElementKind #enum:StructureElementKind#

    StructureElementKind(..)                ,


-- ** StructureFormRole #enum:StructureFormRole#

    StructureFormRole(..)                   ,


-- ** StructureFormState #enum:StructureFormState#

    StructureFormState(..)                  ,


-- ** StructureGlyphOrientation #enum:StructureGlyphOrientation#

    StructureGlyphOrientation(..)           ,


-- ** StructureInlineAlign #enum:StructureInlineAlign#

    StructureInlineAlign(..)                ,


-- ** StructureListNumbering #enum:StructureListNumbering#

    StructureListNumbering(..)              ,


-- ** StructurePlacement #enum:StructurePlacement#

    StructurePlacement(..)                  ,


-- ** StructureRubyAlign #enum:StructureRubyAlign#

    StructureRubyAlign(..)                  ,


-- ** StructureRubyPosition #enum:StructureRubyPosition#

    StructureRubyPosition(..)               ,


-- ** StructureTableScope #enum:StructureTableScope#

    StructureTableScope(..)                 ,


-- ** StructureTextAlign #enum:StructureTextAlign#

    StructureTextAlign(..)                  ,


-- ** StructureTextDecoration #enum:StructureTextDecoration#

    StructureTextDecoration(..)             ,


-- ** StructureWritingMode #enum:StructureWritingMode#

    StructureWritingMode(..)                ,




    ) where

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

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL


-- Enum StructureWritingMode
-- | /No description available in the introspection data./
data StructureWritingMode = 
      StructureWritingModeLrTb
    -- ^ /No description available in the introspection data./
    | StructureWritingModeRlTb
    -- ^ /No description available in the introspection data./
    | StructureWritingModeTbRl
    -- ^ /No description available in the introspection data./
    | AnotherStructureWritingMode Int
    -- ^ Catch-all for unknown values
    deriving (Int -> StructureWritingMode -> ShowS
[StructureWritingMode] -> ShowS
StructureWritingMode -> String
(Int -> StructureWritingMode -> ShowS)
-> (StructureWritingMode -> String)
-> ([StructureWritingMode] -> ShowS)
-> Show StructureWritingMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StructureWritingMode] -> ShowS
$cshowList :: [StructureWritingMode] -> ShowS
show :: StructureWritingMode -> String
$cshow :: StructureWritingMode -> String
showsPrec :: Int -> StructureWritingMode -> ShowS
$cshowsPrec :: Int -> StructureWritingMode -> ShowS
Show, StructureWritingMode -> StructureWritingMode -> Bool
(StructureWritingMode -> StructureWritingMode -> Bool)
-> (StructureWritingMode -> StructureWritingMode -> Bool)
-> Eq StructureWritingMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StructureWritingMode -> StructureWritingMode -> Bool
$c/= :: StructureWritingMode -> StructureWritingMode -> Bool
== :: StructureWritingMode -> StructureWritingMode -> Bool
$c== :: StructureWritingMode -> StructureWritingMode -> Bool
Eq)

instance P.Enum StructureWritingMode where
    fromEnum :: StructureWritingMode -> Int
fromEnum StructureWritingModeLrTb = 0
    fromEnum StructureWritingModeRlTb = 1
    fromEnum StructureWritingModeTbRl = 2
    fromEnum (AnotherStructureWritingMode k :: Int
k) = Int
k

    toEnum :: Int -> StructureWritingMode
toEnum 0 = StructureWritingMode
StructureWritingModeLrTb
    toEnum 1 = StructureWritingMode
StructureWritingModeRlTb
    toEnum 2 = StructureWritingMode
StructureWritingModeTbRl
    toEnum k :: Int
k = Int -> StructureWritingMode
AnotherStructureWritingMode Int
k

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

foreign import ccall "poppler_structure_writing_mode_get_type" c_poppler_structure_writing_mode_get_type :: 
    IO GType

instance BoxedEnum StructureWritingMode where
    boxedEnumType :: StructureWritingMode -> IO GType
boxedEnumType _ = IO GType
c_poppler_structure_writing_mode_get_type

-- Enum StructureTextDecoration
-- | /No description available in the introspection data./
data StructureTextDecoration = 
      StructureTextDecorationNone
    -- ^ /No description available in the introspection data./
    | StructureTextDecorationUnderline
    -- ^ /No description available in the introspection data./
    | StructureTextDecorationOverline
    -- ^ /No description available in the introspection data./
    | StructureTextDecorationLinethrough
    -- ^ /No description available in the introspection data./
    | AnotherStructureTextDecoration Int
    -- ^ Catch-all for unknown values
    deriving (Int -> StructureTextDecoration -> ShowS
[StructureTextDecoration] -> ShowS
StructureTextDecoration -> String
(Int -> StructureTextDecoration -> ShowS)
-> (StructureTextDecoration -> String)
-> ([StructureTextDecoration] -> ShowS)
-> Show StructureTextDecoration
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StructureTextDecoration] -> ShowS
$cshowList :: [StructureTextDecoration] -> ShowS
show :: StructureTextDecoration -> String
$cshow :: StructureTextDecoration -> String
showsPrec :: Int -> StructureTextDecoration -> ShowS
$cshowsPrec :: Int -> StructureTextDecoration -> ShowS
Show, StructureTextDecoration -> StructureTextDecoration -> Bool
(StructureTextDecoration -> StructureTextDecoration -> Bool)
-> (StructureTextDecoration -> StructureTextDecoration -> Bool)
-> Eq StructureTextDecoration
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StructureTextDecoration -> StructureTextDecoration -> Bool
$c/= :: StructureTextDecoration -> StructureTextDecoration -> Bool
== :: StructureTextDecoration -> StructureTextDecoration -> Bool
$c== :: StructureTextDecoration -> StructureTextDecoration -> Bool
Eq)

instance P.Enum StructureTextDecoration where
    fromEnum :: StructureTextDecoration -> Int
fromEnum StructureTextDecorationNone = 0
    fromEnum StructureTextDecorationUnderline = 1
    fromEnum StructureTextDecorationOverline = 2
    fromEnum StructureTextDecorationLinethrough = 3
    fromEnum (AnotherStructureTextDecoration k :: Int
k) = Int
k

    toEnum :: Int -> StructureTextDecoration
toEnum 0 = StructureTextDecoration
StructureTextDecorationNone
    toEnum 1 = StructureTextDecoration
StructureTextDecorationUnderline
    toEnum 2 = StructureTextDecoration
StructureTextDecorationOverline
    toEnum 3 = StructureTextDecoration
StructureTextDecorationLinethrough
    toEnum k :: Int
k = Int -> StructureTextDecoration
AnotherStructureTextDecoration Int
k

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

foreign import ccall "poppler_structure_text_decoration_get_type" c_poppler_structure_text_decoration_get_type :: 
    IO GType

instance BoxedEnum StructureTextDecoration where
    boxedEnumType :: StructureTextDecoration -> IO GType
boxedEnumType _ = IO GType
c_poppler_structure_text_decoration_get_type

-- Enum StructureTextAlign
-- | /No description available in the introspection data./
data StructureTextAlign = 
      StructureTextAlignStart
    -- ^ /No description available in the introspection data./
    | StructureTextAlignCenter
    -- ^ /No description available in the introspection data./
    | StructureTextAlignEnd
    -- ^ /No description available in the introspection data./
    | StructureTextAlignJustify
    -- ^ /No description available in the introspection data./
    | AnotherStructureTextAlign Int
    -- ^ Catch-all for unknown values
    deriving (Int -> StructureTextAlign -> ShowS
[StructureTextAlign] -> ShowS
StructureTextAlign -> String
(Int -> StructureTextAlign -> ShowS)
-> (StructureTextAlign -> String)
-> ([StructureTextAlign] -> ShowS)
-> Show StructureTextAlign
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StructureTextAlign] -> ShowS
$cshowList :: [StructureTextAlign] -> ShowS
show :: StructureTextAlign -> String
$cshow :: StructureTextAlign -> String
showsPrec :: Int -> StructureTextAlign -> ShowS
$cshowsPrec :: Int -> StructureTextAlign -> ShowS
Show, StructureTextAlign -> StructureTextAlign -> Bool
(StructureTextAlign -> StructureTextAlign -> Bool)
-> (StructureTextAlign -> StructureTextAlign -> Bool)
-> Eq StructureTextAlign
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StructureTextAlign -> StructureTextAlign -> Bool
$c/= :: StructureTextAlign -> StructureTextAlign -> Bool
== :: StructureTextAlign -> StructureTextAlign -> Bool
$c== :: StructureTextAlign -> StructureTextAlign -> Bool
Eq)

instance P.Enum StructureTextAlign where
    fromEnum :: StructureTextAlign -> Int
fromEnum StructureTextAlignStart = 0
    fromEnum StructureTextAlignCenter = 1
    fromEnum StructureTextAlignEnd = 2
    fromEnum StructureTextAlignJustify = 3
    fromEnum (AnotherStructureTextAlign k :: Int
k) = Int
k

    toEnum :: Int -> StructureTextAlign
toEnum 0 = StructureTextAlign
StructureTextAlignStart
    toEnum 1 = StructureTextAlign
StructureTextAlignCenter
    toEnum 2 = StructureTextAlign
StructureTextAlignEnd
    toEnum 3 = StructureTextAlign
StructureTextAlignJustify
    toEnum k :: Int
k = Int -> StructureTextAlign
AnotherStructureTextAlign Int
k

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

foreign import ccall "poppler_structure_text_align_get_type" c_poppler_structure_text_align_get_type :: 
    IO GType

instance BoxedEnum StructureTextAlign where
    boxedEnumType :: StructureTextAlign -> IO GType
boxedEnumType _ = IO GType
c_poppler_structure_text_align_get_type

-- Enum StructureTableScope
-- | /No description available in the introspection data./
data StructureTableScope = 
      StructureTableScopeRow
    -- ^ /No description available in the introspection data./
    | StructureTableScopeColumn
    -- ^ /No description available in the introspection data./
    | StructureTableScopeBoth
    -- ^ /No description available in the introspection data./
    | AnotherStructureTableScope Int
    -- ^ Catch-all for unknown values
    deriving (Int -> StructureTableScope -> ShowS
[StructureTableScope] -> ShowS
StructureTableScope -> String
(Int -> StructureTableScope -> ShowS)
-> (StructureTableScope -> String)
-> ([StructureTableScope] -> ShowS)
-> Show StructureTableScope
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StructureTableScope] -> ShowS
$cshowList :: [StructureTableScope] -> ShowS
show :: StructureTableScope -> String
$cshow :: StructureTableScope -> String
showsPrec :: Int -> StructureTableScope -> ShowS
$cshowsPrec :: Int -> StructureTableScope -> ShowS
Show, StructureTableScope -> StructureTableScope -> Bool
(StructureTableScope -> StructureTableScope -> Bool)
-> (StructureTableScope -> StructureTableScope -> Bool)
-> Eq StructureTableScope
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StructureTableScope -> StructureTableScope -> Bool
$c/= :: StructureTableScope -> StructureTableScope -> Bool
== :: StructureTableScope -> StructureTableScope -> Bool
$c== :: StructureTableScope -> StructureTableScope -> Bool
Eq)

instance P.Enum StructureTableScope where
    fromEnum :: StructureTableScope -> Int
fromEnum StructureTableScopeRow = 0
    fromEnum StructureTableScopeColumn = 1
    fromEnum StructureTableScopeBoth = 2
    fromEnum (AnotherStructureTableScope k :: Int
k) = Int
k

    toEnum :: Int -> StructureTableScope
toEnum 0 = StructureTableScope
StructureTableScopeRow
    toEnum 1 = StructureTableScope
StructureTableScopeColumn
    toEnum 2 = StructureTableScope
StructureTableScopeBoth
    toEnum k :: Int
k = Int -> StructureTableScope
AnotherStructureTableScope Int
k

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

foreign import ccall "poppler_structure_table_scope_get_type" c_poppler_structure_table_scope_get_type :: 
    IO GType

instance BoxedEnum StructureTableScope where
    boxedEnumType :: StructureTableScope -> IO GType
boxedEnumType _ = IO GType
c_poppler_structure_table_scope_get_type

-- Enum StructureRubyPosition
-- | /No description available in the introspection data./
data StructureRubyPosition = 
      StructureRubyPositionBefore
    -- ^ /No description available in the introspection data./
    | StructureRubyPositionAfter
    -- ^ /No description available in the introspection data./
    | StructureRubyPositionWarichu
    -- ^ /No description available in the introspection data./
    | StructureRubyPositionInline
    -- ^ /No description available in the introspection data./
    | AnotherStructureRubyPosition Int
    -- ^ Catch-all for unknown values
    deriving (Int -> StructureRubyPosition -> ShowS
[StructureRubyPosition] -> ShowS
StructureRubyPosition -> String
(Int -> StructureRubyPosition -> ShowS)
-> (StructureRubyPosition -> String)
-> ([StructureRubyPosition] -> ShowS)
-> Show StructureRubyPosition
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StructureRubyPosition] -> ShowS
$cshowList :: [StructureRubyPosition] -> ShowS
show :: StructureRubyPosition -> String
$cshow :: StructureRubyPosition -> String
showsPrec :: Int -> StructureRubyPosition -> ShowS
$cshowsPrec :: Int -> StructureRubyPosition -> ShowS
Show, StructureRubyPosition -> StructureRubyPosition -> Bool
(StructureRubyPosition -> StructureRubyPosition -> Bool)
-> (StructureRubyPosition -> StructureRubyPosition -> Bool)
-> Eq StructureRubyPosition
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StructureRubyPosition -> StructureRubyPosition -> Bool
$c/= :: StructureRubyPosition -> StructureRubyPosition -> Bool
== :: StructureRubyPosition -> StructureRubyPosition -> Bool
$c== :: StructureRubyPosition -> StructureRubyPosition -> Bool
Eq)

instance P.Enum StructureRubyPosition where
    fromEnum :: StructureRubyPosition -> Int
fromEnum StructureRubyPositionBefore = 0
    fromEnum StructureRubyPositionAfter = 1
    fromEnum StructureRubyPositionWarichu = 2
    fromEnum StructureRubyPositionInline = 3
    fromEnum (AnotherStructureRubyPosition k :: Int
k) = Int
k

    toEnum :: Int -> StructureRubyPosition
toEnum 0 = StructureRubyPosition
StructureRubyPositionBefore
    toEnum 1 = StructureRubyPosition
StructureRubyPositionAfter
    toEnum 2 = StructureRubyPosition
StructureRubyPositionWarichu
    toEnum 3 = StructureRubyPosition
StructureRubyPositionInline
    toEnum k :: Int
k = Int -> StructureRubyPosition
AnotherStructureRubyPosition Int
k

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

foreign import ccall "poppler_structure_ruby_position_get_type" c_poppler_structure_ruby_position_get_type :: 
    IO GType

instance BoxedEnum StructureRubyPosition where
    boxedEnumType :: StructureRubyPosition -> IO GType
boxedEnumType _ = IO GType
c_poppler_structure_ruby_position_get_type

-- Enum StructureRubyAlign
-- | /No description available in the introspection data./
data StructureRubyAlign = 
      StructureRubyAlignStart
    -- ^ /No description available in the introspection data./
    | StructureRubyAlignCenter
    -- ^ /No description available in the introspection data./
    | StructureRubyAlignEnd
    -- ^ /No description available in the introspection data./
    | StructureRubyAlignJustify
    -- ^ /No description available in the introspection data./
    | StructureRubyAlignDistribute
    -- ^ /No description available in the introspection data./
    | AnotherStructureRubyAlign Int
    -- ^ Catch-all for unknown values
    deriving (Int -> StructureRubyAlign -> ShowS
[StructureRubyAlign] -> ShowS
StructureRubyAlign -> String
(Int -> StructureRubyAlign -> ShowS)
-> (StructureRubyAlign -> String)
-> ([StructureRubyAlign] -> ShowS)
-> Show StructureRubyAlign
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StructureRubyAlign] -> ShowS
$cshowList :: [StructureRubyAlign] -> ShowS
show :: StructureRubyAlign -> String
$cshow :: StructureRubyAlign -> String
showsPrec :: Int -> StructureRubyAlign -> ShowS
$cshowsPrec :: Int -> StructureRubyAlign -> ShowS
Show, StructureRubyAlign -> StructureRubyAlign -> Bool
(StructureRubyAlign -> StructureRubyAlign -> Bool)
-> (StructureRubyAlign -> StructureRubyAlign -> Bool)
-> Eq StructureRubyAlign
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StructureRubyAlign -> StructureRubyAlign -> Bool
$c/= :: StructureRubyAlign -> StructureRubyAlign -> Bool
== :: StructureRubyAlign -> StructureRubyAlign -> Bool
$c== :: StructureRubyAlign -> StructureRubyAlign -> Bool
Eq)

instance P.Enum StructureRubyAlign where
    fromEnum :: StructureRubyAlign -> Int
fromEnum StructureRubyAlignStart = 0
    fromEnum StructureRubyAlignCenter = 1
    fromEnum StructureRubyAlignEnd = 2
    fromEnum StructureRubyAlignJustify = 3
    fromEnum StructureRubyAlignDistribute = 4
    fromEnum (AnotherStructureRubyAlign k :: Int
k) = Int
k

    toEnum :: Int -> StructureRubyAlign
toEnum 0 = StructureRubyAlign
StructureRubyAlignStart
    toEnum 1 = StructureRubyAlign
StructureRubyAlignCenter
    toEnum 2 = StructureRubyAlign
StructureRubyAlignEnd
    toEnum 3 = StructureRubyAlign
StructureRubyAlignJustify
    toEnum 4 = StructureRubyAlign
StructureRubyAlignDistribute
    toEnum k :: Int
k = Int -> StructureRubyAlign
AnotherStructureRubyAlign Int
k

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

foreign import ccall "poppler_structure_ruby_align_get_type" c_poppler_structure_ruby_align_get_type :: 
    IO GType

instance BoxedEnum StructureRubyAlign where
    boxedEnumType :: StructureRubyAlign -> IO GType
boxedEnumType _ = IO GType
c_poppler_structure_ruby_align_get_type

-- Enum StructurePlacement
-- | /No description available in the introspection data./
data StructurePlacement = 
      StructurePlacementBlock
    -- ^ /No description available in the introspection data./
    | StructurePlacementInline
    -- ^ /No description available in the introspection data./
    | StructurePlacementBefore
    -- ^ /No description available in the introspection data./
    | StructurePlacementStart
    -- ^ /No description available in the introspection data./
    | StructurePlacementEnd
    -- ^ /No description available in the introspection data./
    | AnotherStructurePlacement Int
    -- ^ Catch-all for unknown values
    deriving (Int -> StructurePlacement -> ShowS
[StructurePlacement] -> ShowS
StructurePlacement -> String
(Int -> StructurePlacement -> ShowS)
-> (StructurePlacement -> String)
-> ([StructurePlacement] -> ShowS)
-> Show StructurePlacement
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StructurePlacement] -> ShowS
$cshowList :: [StructurePlacement] -> ShowS
show :: StructurePlacement -> String
$cshow :: StructurePlacement -> String
showsPrec :: Int -> StructurePlacement -> ShowS
$cshowsPrec :: Int -> StructurePlacement -> ShowS
Show, StructurePlacement -> StructurePlacement -> Bool
(StructurePlacement -> StructurePlacement -> Bool)
-> (StructurePlacement -> StructurePlacement -> Bool)
-> Eq StructurePlacement
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StructurePlacement -> StructurePlacement -> Bool
$c/= :: StructurePlacement -> StructurePlacement -> Bool
== :: StructurePlacement -> StructurePlacement -> Bool
$c== :: StructurePlacement -> StructurePlacement -> Bool
Eq)

instance P.Enum StructurePlacement where
    fromEnum :: StructurePlacement -> Int
fromEnum StructurePlacementBlock = 0
    fromEnum StructurePlacementInline = 1
    fromEnum StructurePlacementBefore = 2
    fromEnum StructurePlacementStart = 3
    fromEnum StructurePlacementEnd = 4
    fromEnum (AnotherStructurePlacement k :: Int
k) = Int
k

    toEnum :: Int -> StructurePlacement
toEnum 0 = StructurePlacement
StructurePlacementBlock
    toEnum 1 = StructurePlacement
StructurePlacementInline
    toEnum 2 = StructurePlacement
StructurePlacementBefore
    toEnum 3 = StructurePlacement
StructurePlacementStart
    toEnum 4 = StructurePlacement
StructurePlacementEnd
    toEnum k :: Int
k = Int -> StructurePlacement
AnotherStructurePlacement Int
k

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

foreign import ccall "poppler_structure_placement_get_type" c_poppler_structure_placement_get_type :: 
    IO GType

instance BoxedEnum StructurePlacement where
    boxedEnumType :: StructurePlacement -> IO GType
boxedEnumType _ = IO GType
c_poppler_structure_placement_get_type

-- Enum StructureListNumbering
-- | /No description available in the introspection data./
data StructureListNumbering = 
      StructureListNumberingNone
    -- ^ /No description available in the introspection data./
    | StructureListNumberingDisc
    -- ^ /No description available in the introspection data./
    | StructureListNumberingCircle
    -- ^ /No description available in the introspection data./
    | StructureListNumberingSquare
    -- ^ /No description available in the introspection data./
    | StructureListNumberingDecimal
    -- ^ /No description available in the introspection data./
    | StructureListNumberingUpperRoman
    -- ^ /No description available in the introspection data./
    | StructureListNumberingLowerRoman
    -- ^ /No description available in the introspection data./
    | StructureListNumberingUpperAlpha
    -- ^ /No description available in the introspection data./
    | StructureListNumberingLowerAlpha
    -- ^ /No description available in the introspection data./
    | AnotherStructureListNumbering Int
    -- ^ Catch-all for unknown values
    deriving (Int -> StructureListNumbering -> ShowS
[StructureListNumbering] -> ShowS
StructureListNumbering -> String
(Int -> StructureListNumbering -> ShowS)
-> (StructureListNumbering -> String)
-> ([StructureListNumbering] -> ShowS)
-> Show StructureListNumbering
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StructureListNumbering] -> ShowS
$cshowList :: [StructureListNumbering] -> ShowS
show :: StructureListNumbering -> String
$cshow :: StructureListNumbering -> String
showsPrec :: Int -> StructureListNumbering -> ShowS
$cshowsPrec :: Int -> StructureListNumbering -> ShowS
Show, StructureListNumbering -> StructureListNumbering -> Bool
(StructureListNumbering -> StructureListNumbering -> Bool)
-> (StructureListNumbering -> StructureListNumbering -> Bool)
-> Eq StructureListNumbering
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StructureListNumbering -> StructureListNumbering -> Bool
$c/= :: StructureListNumbering -> StructureListNumbering -> Bool
== :: StructureListNumbering -> StructureListNumbering -> Bool
$c== :: StructureListNumbering -> StructureListNumbering -> Bool
Eq)

instance P.Enum StructureListNumbering where
    fromEnum :: StructureListNumbering -> Int
fromEnum StructureListNumberingNone = 0
    fromEnum StructureListNumberingDisc = 1
    fromEnum StructureListNumberingCircle = 2
    fromEnum StructureListNumberingSquare = 3
    fromEnum StructureListNumberingDecimal = 4
    fromEnum StructureListNumberingUpperRoman = 5
    fromEnum StructureListNumberingLowerRoman = 6
    fromEnum StructureListNumberingUpperAlpha = 7
    fromEnum StructureListNumberingLowerAlpha = 8
    fromEnum (AnotherStructureListNumbering k :: Int
k) = Int
k

    toEnum :: Int -> StructureListNumbering
toEnum 0 = StructureListNumbering
StructureListNumberingNone
    toEnum 1 = StructureListNumbering
StructureListNumberingDisc
    toEnum 2 = StructureListNumbering
StructureListNumberingCircle
    toEnum 3 = StructureListNumbering
StructureListNumberingSquare
    toEnum 4 = StructureListNumbering
StructureListNumberingDecimal
    toEnum 5 = StructureListNumbering
StructureListNumberingUpperRoman
    toEnum 6 = StructureListNumbering
StructureListNumberingLowerRoman
    toEnum 7 = StructureListNumbering
StructureListNumberingUpperAlpha
    toEnum 8 = StructureListNumbering
StructureListNumberingLowerAlpha
    toEnum k :: Int
k = Int -> StructureListNumbering
AnotherStructureListNumbering Int
k

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

foreign import ccall "poppler_structure_list_numbering_get_type" c_poppler_structure_list_numbering_get_type :: 
    IO GType

instance BoxedEnum StructureListNumbering where
    boxedEnumType :: StructureListNumbering -> IO GType
boxedEnumType _ = IO GType
c_poppler_structure_list_numbering_get_type

-- Enum StructureInlineAlign
-- | /No description available in the introspection data./
data StructureInlineAlign = 
      StructureInlineAlignStart
    -- ^ /No description available in the introspection data./
    | StructureInlineAlignCenter
    -- ^ /No description available in the introspection data./
    | StructureInlineAlignEnd
    -- ^ /No description available in the introspection data./
    | AnotherStructureInlineAlign Int
    -- ^ Catch-all for unknown values
    deriving (Int -> StructureInlineAlign -> ShowS
[StructureInlineAlign] -> ShowS
StructureInlineAlign -> String
(Int -> StructureInlineAlign -> ShowS)
-> (StructureInlineAlign -> String)
-> ([StructureInlineAlign] -> ShowS)
-> Show StructureInlineAlign
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StructureInlineAlign] -> ShowS
$cshowList :: [StructureInlineAlign] -> ShowS
show :: StructureInlineAlign -> String
$cshow :: StructureInlineAlign -> String
showsPrec :: Int -> StructureInlineAlign -> ShowS
$cshowsPrec :: Int -> StructureInlineAlign -> ShowS
Show, StructureInlineAlign -> StructureInlineAlign -> Bool
(StructureInlineAlign -> StructureInlineAlign -> Bool)
-> (StructureInlineAlign -> StructureInlineAlign -> Bool)
-> Eq StructureInlineAlign
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StructureInlineAlign -> StructureInlineAlign -> Bool
$c/= :: StructureInlineAlign -> StructureInlineAlign -> Bool
== :: StructureInlineAlign -> StructureInlineAlign -> Bool
$c== :: StructureInlineAlign -> StructureInlineAlign -> Bool
Eq)

instance P.Enum StructureInlineAlign where
    fromEnum :: StructureInlineAlign -> Int
fromEnum StructureInlineAlignStart = 0
    fromEnum StructureInlineAlignCenter = 1
    fromEnum StructureInlineAlignEnd = 2
    fromEnum (AnotherStructureInlineAlign k :: Int
k) = Int
k

    toEnum :: Int -> StructureInlineAlign
toEnum 0 = StructureInlineAlign
StructureInlineAlignStart
    toEnum 1 = StructureInlineAlign
StructureInlineAlignCenter
    toEnum 2 = StructureInlineAlign
StructureInlineAlignEnd
    toEnum k :: Int
k = Int -> StructureInlineAlign
AnotherStructureInlineAlign Int
k

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

foreign import ccall "poppler_structure_inline_align_get_type" c_poppler_structure_inline_align_get_type :: 
    IO GType

instance BoxedEnum StructureInlineAlign where
    boxedEnumType :: StructureInlineAlign -> IO GType
boxedEnumType _ = IO GType
c_poppler_structure_inline_align_get_type

-- Enum StructureGlyphOrientation
-- | /No description available in the introspection data./
data StructureGlyphOrientation = 
      StructureGlyphOrientationAuto
    -- ^ /No description available in the introspection data./
    | StructureGlyphOrientation0
    -- ^ /No description available in the introspection data./
    | StructureGlyphOrientation90
    -- ^ /No description available in the introspection data./
    | StructureGlyphOrientation180
    -- ^ /No description available in the introspection data./
    | StructureGlyphOrientation270
    -- ^ /No description available in the introspection data./
    | AnotherStructureGlyphOrientation Int
    -- ^ Catch-all for unknown values
    deriving (Int -> StructureGlyphOrientation -> ShowS
[StructureGlyphOrientation] -> ShowS
StructureGlyphOrientation -> String
(Int -> StructureGlyphOrientation -> ShowS)
-> (StructureGlyphOrientation -> String)
-> ([StructureGlyphOrientation] -> ShowS)
-> Show StructureGlyphOrientation
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StructureGlyphOrientation] -> ShowS
$cshowList :: [StructureGlyphOrientation] -> ShowS
show :: StructureGlyphOrientation -> String
$cshow :: StructureGlyphOrientation -> String
showsPrec :: Int -> StructureGlyphOrientation -> ShowS
$cshowsPrec :: Int -> StructureGlyphOrientation -> ShowS
Show, StructureGlyphOrientation -> StructureGlyphOrientation -> Bool
(StructureGlyphOrientation -> StructureGlyphOrientation -> Bool)
-> (StructureGlyphOrientation -> StructureGlyphOrientation -> Bool)
-> Eq StructureGlyphOrientation
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StructureGlyphOrientation -> StructureGlyphOrientation -> Bool
$c/= :: StructureGlyphOrientation -> StructureGlyphOrientation -> Bool
== :: StructureGlyphOrientation -> StructureGlyphOrientation -> Bool
$c== :: StructureGlyphOrientation -> StructureGlyphOrientation -> Bool
Eq)

instance P.Enum StructureGlyphOrientation where
    fromEnum :: StructureGlyphOrientation -> Int
fromEnum StructureGlyphOrientationAuto = 0
    fromEnum StructureGlyphOrientation0 = 0
    fromEnum StructureGlyphOrientation90 = 1
    fromEnum StructureGlyphOrientation180 = 2
    fromEnum StructureGlyphOrientation270 = 3
    fromEnum (AnotherStructureGlyphOrientation k :: Int
k) = Int
k

    toEnum :: Int -> StructureGlyphOrientation
toEnum 0 = StructureGlyphOrientation
StructureGlyphOrientationAuto
    toEnum 1 = StructureGlyphOrientation
StructureGlyphOrientation90
    toEnum 2 = StructureGlyphOrientation
StructureGlyphOrientation180
    toEnum 3 = StructureGlyphOrientation
StructureGlyphOrientation270
    toEnum k :: Int
k = Int -> StructureGlyphOrientation
AnotherStructureGlyphOrientation Int
k

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

foreign import ccall "poppler_structure_glyph_orientation_get_type" c_poppler_structure_glyph_orientation_get_type :: 
    IO GType

instance BoxedEnum StructureGlyphOrientation where
    boxedEnumType :: StructureGlyphOrientation -> IO GType
boxedEnumType _ = IO GType
c_poppler_structure_glyph_orientation_get_type

-- Enum StructureFormState
-- | /No description available in the introspection data./
data StructureFormState = 
      StructureFormStateOn
    -- ^ /No description available in the introspection data./
    | StructureFormStateOff
    -- ^ /No description available in the introspection data./
    | StructureFormStateNeutral
    -- ^ /No description available in the introspection data./
    | AnotherStructureFormState Int
    -- ^ Catch-all for unknown values
    deriving (Int -> StructureFormState -> ShowS
[StructureFormState] -> ShowS
StructureFormState -> String
(Int -> StructureFormState -> ShowS)
-> (StructureFormState -> String)
-> ([StructureFormState] -> ShowS)
-> Show StructureFormState
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StructureFormState] -> ShowS
$cshowList :: [StructureFormState] -> ShowS
show :: StructureFormState -> String
$cshow :: StructureFormState -> String
showsPrec :: Int -> StructureFormState -> ShowS
$cshowsPrec :: Int -> StructureFormState -> ShowS
Show, StructureFormState -> StructureFormState -> Bool
(StructureFormState -> StructureFormState -> Bool)
-> (StructureFormState -> StructureFormState -> Bool)
-> Eq StructureFormState
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StructureFormState -> StructureFormState -> Bool
$c/= :: StructureFormState -> StructureFormState -> Bool
== :: StructureFormState -> StructureFormState -> Bool
$c== :: StructureFormState -> StructureFormState -> Bool
Eq)

instance P.Enum StructureFormState where
    fromEnum :: StructureFormState -> Int
fromEnum StructureFormStateOn = 0
    fromEnum StructureFormStateOff = 1
    fromEnum StructureFormStateNeutral = 2
    fromEnum (AnotherStructureFormState k :: Int
k) = Int
k

    toEnum :: Int -> StructureFormState
toEnum 0 = StructureFormState
StructureFormStateOn
    toEnum 1 = StructureFormState
StructureFormStateOff
    toEnum 2 = StructureFormState
StructureFormStateNeutral
    toEnum k :: Int
k = Int -> StructureFormState
AnotherStructureFormState Int
k

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

foreign import ccall "poppler_structure_form_state_get_type" c_poppler_structure_form_state_get_type :: 
    IO GType

instance BoxedEnum StructureFormState where
    boxedEnumType :: StructureFormState -> IO GType
boxedEnumType _ = IO GType
c_poppler_structure_form_state_get_type

-- Enum StructureFormRole
-- | /No description available in the introspection data./
data StructureFormRole = 
      StructureFormRoleUndefined
    -- ^ /No description available in the introspection data./
    | StructureFormRoleRadioButton
    -- ^ /No description available in the introspection data./
    | StructureFormRolePushButton
    -- ^ /No description available in the introspection data./
    | StructureFormRoleTextValue
    -- ^ /No description available in the introspection data./
    | StructureFormRoleCheckbox
    -- ^ /No description available in the introspection data./
    | AnotherStructureFormRole Int
    -- ^ Catch-all for unknown values
    deriving (Int -> StructureFormRole -> ShowS
[StructureFormRole] -> ShowS
StructureFormRole -> String
(Int -> StructureFormRole -> ShowS)
-> (StructureFormRole -> String)
-> ([StructureFormRole] -> ShowS)
-> Show StructureFormRole
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StructureFormRole] -> ShowS
$cshowList :: [StructureFormRole] -> ShowS
show :: StructureFormRole -> String
$cshow :: StructureFormRole -> String
showsPrec :: Int -> StructureFormRole -> ShowS
$cshowsPrec :: Int -> StructureFormRole -> ShowS
Show, StructureFormRole -> StructureFormRole -> Bool
(StructureFormRole -> StructureFormRole -> Bool)
-> (StructureFormRole -> StructureFormRole -> Bool)
-> Eq StructureFormRole
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StructureFormRole -> StructureFormRole -> Bool
$c/= :: StructureFormRole -> StructureFormRole -> Bool
== :: StructureFormRole -> StructureFormRole -> Bool
$c== :: StructureFormRole -> StructureFormRole -> Bool
Eq)

instance P.Enum StructureFormRole where
    fromEnum :: StructureFormRole -> Int
fromEnum StructureFormRoleUndefined = 0
    fromEnum StructureFormRoleRadioButton = 1
    fromEnum StructureFormRolePushButton = 2
    fromEnum StructureFormRoleTextValue = 3
    fromEnum StructureFormRoleCheckbox = 4
    fromEnum (AnotherStructureFormRole k :: Int
k) = Int
k

    toEnum :: Int -> StructureFormRole
toEnum 0 = StructureFormRole
StructureFormRoleUndefined
    toEnum 1 = StructureFormRole
StructureFormRoleRadioButton
    toEnum 2 = StructureFormRole
StructureFormRolePushButton
    toEnum 3 = StructureFormRole
StructureFormRoleTextValue
    toEnum 4 = StructureFormRole
StructureFormRoleCheckbox
    toEnum k :: Int
k = Int -> StructureFormRole
AnotherStructureFormRole Int
k

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

foreign import ccall "poppler_structure_form_role_get_type" c_poppler_structure_form_role_get_type :: 
    IO GType

instance BoxedEnum StructureFormRole where
    boxedEnumType :: StructureFormRole -> IO GType
boxedEnumType _ = IO GType
c_poppler_structure_form_role_get_type

-- Enum StructureElementKind
-- | /No description available in the introspection data./
data StructureElementKind = 
      StructureElementKindContent
    -- ^ /No description available in the introspection data./
    | StructureElementKindObjectReference
    -- ^ /No description available in the introspection data./
    | StructureElementKindDocument
    -- ^ /No description available in the introspection data./
    | StructureElementKindPart
    -- ^ /No description available in the introspection data./
    | StructureElementKindArticle
    -- ^ /No description available in the introspection data./
    | StructureElementKindSection
    -- ^ /No description available in the introspection data./
    | StructureElementKindDiv
    -- ^ /No description available in the introspection data./
    | StructureElementKindSpan
    -- ^ /No description available in the introspection data./
    | StructureElementKindQuote
    -- ^ /No description available in the introspection data./
    | StructureElementKindNote
    -- ^ /No description available in the introspection data./
    | StructureElementKindReference
    -- ^ /No description available in the introspection data./
    | StructureElementKindBibentry
    -- ^ /No description available in the introspection data./
    | StructureElementKindCode
    -- ^ /No description available in the introspection data./
    | StructureElementKindLink
    -- ^ /No description available in the introspection data./
    | StructureElementKindAnnot
    -- ^ /No description available in the introspection data./
    | StructureElementKindBlockquote
    -- ^ /No description available in the introspection data./
    | StructureElementKindCaption
    -- ^ /No description available in the introspection data./
    | StructureElementKindNonstruct
    -- ^ /No description available in the introspection data./
    | StructureElementKindToc
    -- ^ /No description available in the introspection data./
    | StructureElementKindTocItem
    -- ^ /No description available in the introspection data./
    | StructureElementKindIndex
    -- ^ /No description available in the introspection data./
    | StructureElementKindPrivate
    -- ^ /No description available in the introspection data./
    | StructureElementKindParagraph
    -- ^ /No description available in the introspection data./
    | StructureElementKindHeading
    -- ^ /No description available in the introspection data./
    | StructureElementKindHeading1
    -- ^ /No description available in the introspection data./
    | StructureElementKindHeading2
    -- ^ /No description available in the introspection data./
    | StructureElementKindHeading3
    -- ^ /No description available in the introspection data./
    | StructureElementKindHeading4
    -- ^ /No description available in the introspection data./
    | StructureElementKindHeading5
    -- ^ /No description available in the introspection data./
    | StructureElementKindHeading6
    -- ^ /No description available in the introspection data./
    | StructureElementKindList
    -- ^ /No description available in the introspection data./
    | StructureElementKindListItem
    -- ^ /No description available in the introspection data./
    | StructureElementKindListLabel
    -- ^ /No description available in the introspection data./
    | StructureElementKindListBody
    -- ^ /No description available in the introspection data./
    | StructureElementKindTable
    -- ^ /No description available in the introspection data./
    | StructureElementKindTableRow
    -- ^ /No description available in the introspection data./
    | StructureElementKindTableHeading
    -- ^ /No description available in the introspection data./
    | StructureElementKindTableData
    -- ^ /No description available in the introspection data./
    | StructureElementKindTableHeader
    -- ^ /No description available in the introspection data./
    | StructureElementKindTableFooter
    -- ^ /No description available in the introspection data./
    | StructureElementKindTableBody
    -- ^ /No description available in the introspection data./
    | StructureElementKindRuby
    -- ^ /No description available in the introspection data./
    | StructureElementKindRubyBaseText
    -- ^ /No description available in the introspection data./
    | StructureElementKindRubyAnnotText
    -- ^ /No description available in the introspection data./
    | StructureElementKindRubyPunctuation
    -- ^ /No description available in the introspection data./
    | StructureElementKindWarichu
    -- ^ /No description available in the introspection data./
    | StructureElementKindWarichuText
    -- ^ /No description available in the introspection data./
    | StructureElementKindWarichuPunctuation
    -- ^ /No description available in the introspection data./
    | StructureElementKindFigure
    -- ^ /No description available in the introspection data./
    | StructureElementKindFormula
    -- ^ /No description available in the introspection data./
    | StructureElementKindForm
    -- ^ /No description available in the introspection data./
    | AnotherStructureElementKind Int
    -- ^ Catch-all for unknown values
    deriving (Int -> StructureElementKind -> ShowS
[StructureElementKind] -> ShowS
StructureElementKind -> String
(Int -> StructureElementKind -> ShowS)
-> (StructureElementKind -> String)
-> ([StructureElementKind] -> ShowS)
-> Show StructureElementKind
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StructureElementKind] -> ShowS
$cshowList :: [StructureElementKind] -> ShowS
show :: StructureElementKind -> String
$cshow :: StructureElementKind -> String
showsPrec :: Int -> StructureElementKind -> ShowS
$cshowsPrec :: Int -> StructureElementKind -> ShowS
Show, StructureElementKind -> StructureElementKind -> Bool
(StructureElementKind -> StructureElementKind -> Bool)
-> (StructureElementKind -> StructureElementKind -> Bool)
-> Eq StructureElementKind
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StructureElementKind -> StructureElementKind -> Bool
$c/= :: StructureElementKind -> StructureElementKind -> Bool
== :: StructureElementKind -> StructureElementKind -> Bool
$c== :: StructureElementKind -> StructureElementKind -> Bool
Eq)

instance P.Enum StructureElementKind where
    fromEnum :: StructureElementKind -> Int
fromEnum StructureElementKindContent = 0
    fromEnum StructureElementKindObjectReference = 1
    fromEnum StructureElementKindDocument = 2
    fromEnum StructureElementKindPart = 3
    fromEnum StructureElementKindArticle = 4
    fromEnum StructureElementKindSection = 5
    fromEnum StructureElementKindDiv = 6
    fromEnum StructureElementKindSpan = 7
    fromEnum StructureElementKindQuote = 8
    fromEnum StructureElementKindNote = 9
    fromEnum StructureElementKindReference = 10
    fromEnum StructureElementKindBibentry = 11
    fromEnum StructureElementKindCode = 12
    fromEnum StructureElementKindLink = 13
    fromEnum StructureElementKindAnnot = 14
    fromEnum StructureElementKindBlockquote = 15
    fromEnum StructureElementKindCaption = 16
    fromEnum StructureElementKindNonstruct = 17
    fromEnum StructureElementKindToc = 18
    fromEnum StructureElementKindTocItem = 19
    fromEnum StructureElementKindIndex = 20
    fromEnum StructureElementKindPrivate = 21
    fromEnum StructureElementKindParagraph = 22
    fromEnum StructureElementKindHeading = 23
    fromEnum StructureElementKindHeading1 = 24
    fromEnum StructureElementKindHeading2 = 25
    fromEnum StructureElementKindHeading3 = 26
    fromEnum StructureElementKindHeading4 = 27
    fromEnum StructureElementKindHeading5 = 28
    fromEnum StructureElementKindHeading6 = 29
    fromEnum StructureElementKindList = 30
    fromEnum StructureElementKindListItem = 31
    fromEnum StructureElementKindListLabel = 32
    fromEnum StructureElementKindListBody = 33
    fromEnum StructureElementKindTable = 34
    fromEnum StructureElementKindTableRow = 35
    fromEnum StructureElementKindTableHeading = 36
    fromEnum StructureElementKindTableData = 37
    fromEnum StructureElementKindTableHeader = 38
    fromEnum StructureElementKindTableFooter = 39
    fromEnum StructureElementKindTableBody = 40
    fromEnum StructureElementKindRuby = 41
    fromEnum StructureElementKindRubyBaseText = 42
    fromEnum StructureElementKindRubyAnnotText = 43
    fromEnum StructureElementKindRubyPunctuation = 44
    fromEnum StructureElementKindWarichu = 45
    fromEnum StructureElementKindWarichuText = 46
    fromEnum StructureElementKindWarichuPunctuation = 47
    fromEnum StructureElementKindFigure = 48
    fromEnum StructureElementKindFormula = 49
    fromEnum StructureElementKindForm = 50
    fromEnum (AnotherStructureElementKind k :: Int
k) = Int
k

    toEnum :: Int -> StructureElementKind
toEnum 0 = StructureElementKind
StructureElementKindContent
    toEnum 1 = StructureElementKind
StructureElementKindObjectReference
    toEnum 2 = StructureElementKind
StructureElementKindDocument
    toEnum 3 = StructureElementKind
StructureElementKindPart
    toEnum 4 = StructureElementKind
StructureElementKindArticle
    toEnum 5 = StructureElementKind
StructureElementKindSection
    toEnum 6 = StructureElementKind
StructureElementKindDiv
    toEnum 7 = StructureElementKind
StructureElementKindSpan
    toEnum 8 = StructureElementKind
StructureElementKindQuote
    toEnum 9 = StructureElementKind
StructureElementKindNote
    toEnum 10 = StructureElementKind
StructureElementKindReference
    toEnum 11 = StructureElementKind
StructureElementKindBibentry
    toEnum 12 = StructureElementKind
StructureElementKindCode
    toEnum 13 = StructureElementKind
StructureElementKindLink
    toEnum 14 = StructureElementKind
StructureElementKindAnnot
    toEnum 15 = StructureElementKind
StructureElementKindBlockquote
    toEnum 16 = StructureElementKind
StructureElementKindCaption
    toEnum 17 = StructureElementKind
StructureElementKindNonstruct
    toEnum 18 = StructureElementKind
StructureElementKindToc
    toEnum 19 = StructureElementKind
StructureElementKindTocItem
    toEnum 20 = StructureElementKind
StructureElementKindIndex
    toEnum 21 = StructureElementKind
StructureElementKindPrivate
    toEnum 22 = StructureElementKind
StructureElementKindParagraph
    toEnum 23 = StructureElementKind
StructureElementKindHeading
    toEnum 24 = StructureElementKind
StructureElementKindHeading1
    toEnum 25 = StructureElementKind
StructureElementKindHeading2
    toEnum 26 = StructureElementKind
StructureElementKindHeading3
    toEnum 27 = StructureElementKind
StructureElementKindHeading4
    toEnum 28 = StructureElementKind
StructureElementKindHeading5
    toEnum 29 = StructureElementKind
StructureElementKindHeading6
    toEnum 30 = StructureElementKind
StructureElementKindList
    toEnum 31 = StructureElementKind
StructureElementKindListItem
    toEnum 32 = StructureElementKind
StructureElementKindListLabel
    toEnum 33 = StructureElementKind
StructureElementKindListBody
    toEnum 34 = StructureElementKind
StructureElementKindTable
    toEnum 35 = StructureElementKind
StructureElementKindTableRow
    toEnum 36 = StructureElementKind
StructureElementKindTableHeading
    toEnum 37 = StructureElementKind
StructureElementKindTableData
    toEnum 38 = StructureElementKind
StructureElementKindTableHeader
    toEnum 39 = StructureElementKind
StructureElementKindTableFooter
    toEnum 40 = StructureElementKind
StructureElementKindTableBody
    toEnum 41 = StructureElementKind
StructureElementKindRuby
    toEnum 42 = StructureElementKind
StructureElementKindRubyBaseText
    toEnum 43 = StructureElementKind
StructureElementKindRubyAnnotText
    toEnum 44 = StructureElementKind
StructureElementKindRubyPunctuation
    toEnum 45 = StructureElementKind
StructureElementKindWarichu
    toEnum 46 = StructureElementKind
StructureElementKindWarichuText
    toEnum 47 = StructureElementKind
StructureElementKindWarichuPunctuation
    toEnum 48 = StructureElementKind
StructureElementKindFigure
    toEnum 49 = StructureElementKind
StructureElementKindFormula
    toEnum 50 = StructureElementKind
StructureElementKindForm
    toEnum k :: Int
k = Int -> StructureElementKind
AnotherStructureElementKind Int
k

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

foreign import ccall "poppler_structure_element_kind_get_type" c_poppler_structure_element_kind_get_type :: 
    IO GType

instance BoxedEnum StructureElementKind where
    boxedEnumType :: StructureElementKind -> IO GType
boxedEnumType _ = IO GType
c_poppler_structure_element_kind_get_type

-- Enum StructureBorderStyle
-- | /No description available in the introspection data./
data StructureBorderStyle = 
      StructureBorderStyleNone
    -- ^ /No description available in the introspection data./
    | StructureBorderStyleHidden
    -- ^ /No description available in the introspection data./
    | StructureBorderStyleDotted
    -- ^ /No description available in the introspection data./
    | StructureBorderStyleDashed
    -- ^ /No description available in the introspection data./
    | StructureBorderStyleSolid
    -- ^ /No description available in the introspection data./
    | StructureBorderStyleDouble
    -- ^ /No description available in the introspection data./
    | StructureBorderStyleGroove
    -- ^ /No description available in the introspection data./
    | StructureBorderStyleInset
    -- ^ /No description available in the introspection data./
    | StructureBorderStyleOutset
    -- ^ /No description available in the introspection data./
    | AnotherStructureBorderStyle Int
    -- ^ Catch-all for unknown values
    deriving (Int -> StructureBorderStyle -> ShowS
[StructureBorderStyle] -> ShowS
StructureBorderStyle -> String
(Int -> StructureBorderStyle -> ShowS)
-> (StructureBorderStyle -> String)
-> ([StructureBorderStyle] -> ShowS)
-> Show StructureBorderStyle
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StructureBorderStyle] -> ShowS
$cshowList :: [StructureBorderStyle] -> ShowS
show :: StructureBorderStyle -> String
$cshow :: StructureBorderStyle -> String
showsPrec :: Int -> StructureBorderStyle -> ShowS
$cshowsPrec :: Int -> StructureBorderStyle -> ShowS
Show, StructureBorderStyle -> StructureBorderStyle -> Bool
(StructureBorderStyle -> StructureBorderStyle -> Bool)
-> (StructureBorderStyle -> StructureBorderStyle -> Bool)
-> Eq StructureBorderStyle
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StructureBorderStyle -> StructureBorderStyle -> Bool
$c/= :: StructureBorderStyle -> StructureBorderStyle -> Bool
== :: StructureBorderStyle -> StructureBorderStyle -> Bool
$c== :: StructureBorderStyle -> StructureBorderStyle -> Bool
Eq)

instance P.Enum StructureBorderStyle where
    fromEnum :: StructureBorderStyle -> Int
fromEnum StructureBorderStyleNone = 0
    fromEnum StructureBorderStyleHidden = 1
    fromEnum StructureBorderStyleDotted = 2
    fromEnum StructureBorderStyleDashed = 3
    fromEnum StructureBorderStyleSolid = 4
    fromEnum StructureBorderStyleDouble = 5
    fromEnum StructureBorderStyleGroove = 6
    fromEnum StructureBorderStyleInset = 7
    fromEnum StructureBorderStyleOutset = 8
    fromEnum (AnotherStructureBorderStyle k :: Int
k) = Int
k

    toEnum :: Int -> StructureBorderStyle
toEnum 0 = StructureBorderStyle
StructureBorderStyleNone
    toEnum 1 = StructureBorderStyle
StructureBorderStyleHidden
    toEnum 2 = StructureBorderStyle
StructureBorderStyleDotted
    toEnum 3 = StructureBorderStyle
StructureBorderStyleDashed
    toEnum 4 = StructureBorderStyle
StructureBorderStyleSolid
    toEnum 5 = StructureBorderStyle
StructureBorderStyleDouble
    toEnum 6 = StructureBorderStyle
StructureBorderStyleGroove
    toEnum 7 = StructureBorderStyle
StructureBorderStyleInset
    toEnum 8 = StructureBorderStyle
StructureBorderStyleOutset
    toEnum k :: Int
k = Int -> StructureBorderStyle
AnotherStructureBorderStyle Int
k

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

foreign import ccall "poppler_structure_border_style_get_type" c_poppler_structure_border_style_get_type :: 
    IO GType

instance BoxedEnum StructureBorderStyle where
    boxedEnumType :: StructureBorderStyle -> IO GType
boxedEnumType _ = IO GType
c_poppler_structure_border_style_get_type

-- Enum StructureBlockAlign
-- | /No description available in the introspection data./
data StructureBlockAlign = 
      StructureBlockAlignBefore
    -- ^ /No description available in the introspection data./
    | StructureBlockAlignMiddle
    -- ^ /No description available in the introspection data./
    | StructureBlockAlignAfter
    -- ^ /No description available in the introspection data./
    | StructureBlockAlignJustify
    -- ^ /No description available in the introspection data./
    | AnotherStructureBlockAlign Int
    -- ^ Catch-all for unknown values
    deriving (Int -> StructureBlockAlign -> ShowS
[StructureBlockAlign] -> ShowS
StructureBlockAlign -> String
(Int -> StructureBlockAlign -> ShowS)
-> (StructureBlockAlign -> String)
-> ([StructureBlockAlign] -> ShowS)
-> Show StructureBlockAlign
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [StructureBlockAlign] -> ShowS
$cshowList :: [StructureBlockAlign] -> ShowS
show :: StructureBlockAlign -> String
$cshow :: StructureBlockAlign -> String
showsPrec :: Int -> StructureBlockAlign -> ShowS
$cshowsPrec :: Int -> StructureBlockAlign -> ShowS
Show, StructureBlockAlign -> StructureBlockAlign -> Bool
(StructureBlockAlign -> StructureBlockAlign -> Bool)
-> (StructureBlockAlign -> StructureBlockAlign -> Bool)
-> Eq StructureBlockAlign
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: StructureBlockAlign -> StructureBlockAlign -> Bool
$c/= :: StructureBlockAlign -> StructureBlockAlign -> Bool
== :: StructureBlockAlign -> StructureBlockAlign -> Bool
$c== :: StructureBlockAlign -> StructureBlockAlign -> Bool
Eq)

instance P.Enum StructureBlockAlign where
    fromEnum :: StructureBlockAlign -> Int
fromEnum StructureBlockAlignBefore = 0
    fromEnum StructureBlockAlignMiddle = 1
    fromEnum StructureBlockAlignAfter = 2
    fromEnum StructureBlockAlignJustify = 3
    fromEnum (AnotherStructureBlockAlign k :: Int
k) = Int
k

    toEnum :: Int -> StructureBlockAlign
toEnum 0 = StructureBlockAlign
StructureBlockAlignBefore
    toEnum 1 = StructureBlockAlign
StructureBlockAlignMiddle
    toEnum 2 = StructureBlockAlign
StructureBlockAlignAfter
    toEnum 3 = StructureBlockAlign
StructureBlockAlignJustify
    toEnum k :: Int
k = Int -> StructureBlockAlign
AnotherStructureBlockAlign Int
k

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

foreign import ccall "poppler_structure_block_align_get_type" c_poppler_structure_block_align_get_type :: 
    IO GType

instance BoxedEnum StructureBlockAlign where
    boxedEnumType :: StructureBlockAlign -> IO GType
boxedEnumType _ = IO GType
c_poppler_structure_block_align_get_type

-- Enum SelectionStyle
-- | Selection styles
data SelectionStyle = 
      SelectionStyleGlyph
    -- ^ glyph is the minimum unit for selection
    | SelectionStyleWord
    -- ^ word is the minimum unit for selection
    | SelectionStyleLine
    -- ^ line is the minimum unit for selection
    | AnotherSelectionStyle Int
    -- ^ Catch-all for unknown values
    deriving (Int -> SelectionStyle -> ShowS
[SelectionStyle] -> ShowS
SelectionStyle -> String
(Int -> SelectionStyle -> ShowS)
-> (SelectionStyle -> String)
-> ([SelectionStyle] -> ShowS)
-> Show SelectionStyle
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SelectionStyle] -> ShowS
$cshowList :: [SelectionStyle] -> ShowS
show :: SelectionStyle -> String
$cshow :: SelectionStyle -> String
showsPrec :: Int -> SelectionStyle -> ShowS
$cshowsPrec :: Int -> SelectionStyle -> ShowS
Show, SelectionStyle -> SelectionStyle -> Bool
(SelectionStyle -> SelectionStyle -> Bool)
-> (SelectionStyle -> SelectionStyle -> Bool) -> Eq SelectionStyle
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SelectionStyle -> SelectionStyle -> Bool
$c/= :: SelectionStyle -> SelectionStyle -> Bool
== :: SelectionStyle -> SelectionStyle -> Bool
$c== :: SelectionStyle -> SelectionStyle -> Bool
Eq)

instance P.Enum SelectionStyle where
    fromEnum :: SelectionStyle -> Int
fromEnum SelectionStyleGlyph = 0
    fromEnum SelectionStyleWord = 1
    fromEnum SelectionStyleLine = 2
    fromEnum (AnotherSelectionStyle k :: Int
k) = Int
k

    toEnum :: Int -> SelectionStyle
toEnum 0 = SelectionStyle
SelectionStyleGlyph
    toEnum 1 = SelectionStyle
SelectionStyleWord
    toEnum 2 = SelectionStyle
SelectionStyleLine
    toEnum k :: Int
k = Int -> SelectionStyle
AnotherSelectionStyle Int
k

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

foreign import ccall "poppler_selection_style_get_type" c_poppler_selection_style_get_type :: 
    IO GType

instance BoxedEnum SelectionStyle where
    boxedEnumType :: SelectionStyle -> IO GType
boxedEnumType _ = IO GType
c_poppler_selection_style_get_type

-- Enum PrintScaling
-- | PrintScaling viewer preference
-- 
-- /Since: 0.73/
data PrintScaling = 
      PrintScalingAppDefault
    -- ^ application\'s default page scaling
    | PrintScalingNone
    -- ^ no page scaling
    | AnotherPrintScaling Int
    -- ^ Catch-all for unknown values
    deriving (Int -> PrintScaling -> ShowS
[PrintScaling] -> ShowS
PrintScaling -> String
(Int -> PrintScaling -> ShowS)
-> (PrintScaling -> String)
-> ([PrintScaling] -> ShowS)
-> Show PrintScaling
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PrintScaling] -> ShowS
$cshowList :: [PrintScaling] -> ShowS
show :: PrintScaling -> String
$cshow :: PrintScaling -> String
showsPrec :: Int -> PrintScaling -> ShowS
$cshowsPrec :: Int -> PrintScaling -> ShowS
Show, PrintScaling -> PrintScaling -> Bool
(PrintScaling -> PrintScaling -> Bool)
-> (PrintScaling -> PrintScaling -> Bool) -> Eq PrintScaling
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PrintScaling -> PrintScaling -> Bool
$c/= :: PrintScaling -> PrintScaling -> Bool
== :: PrintScaling -> PrintScaling -> Bool
$c== :: PrintScaling -> PrintScaling -> Bool
Eq)

instance P.Enum PrintScaling where
    fromEnum :: PrintScaling -> Int
fromEnum PrintScalingAppDefault = 0
    fromEnum PrintScalingNone = 1
    fromEnum (AnotherPrintScaling k :: Int
k) = Int
k

    toEnum :: Int -> PrintScaling
toEnum 0 = PrintScaling
PrintScalingAppDefault
    toEnum 1 = PrintScaling
PrintScalingNone
    toEnum k :: Int
k = Int -> PrintScaling
AnotherPrintScaling Int
k

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

foreign import ccall "poppler_print_scaling_get_type" c_poppler_print_scaling_get_type :: 
    IO GType

instance BoxedEnum PrintScaling where
    boxedEnumType :: PrintScaling -> IO GType
boxedEnumType _ = IO GType
c_poppler_print_scaling_get_type

-- Enum PageTransitionType
-- | Page transition types
data PageTransitionType = 
      PageTransitionTypeReplace
    -- ^ the new page replace the old one
    | PageTransitionTypeSplit
    -- ^ two lines sweep across the screen, revealing the new page
    | PageTransitionTypeBlinds
    -- ^ multiple lines, evenly spaced across the screen, synchronously
    -- sweep in the same direction to reveal the new page
    | PageTransitionTypeBox
    -- ^ a rectangular box sweeps inward from the edges of the page or
    -- outward from the center revealing the new page
    | PageTransitionTypeWipe
    -- ^ a single line sweeps across the screen from one edge to the other
    -- revealing the new page
    | PageTransitionTypeDissolve
    -- ^ the old page dissolves gradually to reveal the new one
    | PageTransitionTypeGlitter
    -- ^ similar to @/POPPLER_PAGE_TRANSITION_DISSOLVE/@, except that the effect
    -- sweeps across the page in a wide band moving from one side of the screen to the other
    | PageTransitionTypeFly
    -- ^ changes are flown out or in to or from a location that is offscreen
    | PageTransitionTypePush
    -- ^ the old page slides off the screen while the new page slides in
    | PageTransitionTypeCover
    -- ^ the new page slides on to the screen covering the old page
    | PageTransitionTypeUncover
    -- ^ the old page slides off the screen uncovering the new page
    | PageTransitionTypeFade
    -- ^ the new page gradually becomes visible through the old one
    | AnotherPageTransitionType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> PageTransitionType -> ShowS
[PageTransitionType] -> ShowS
PageTransitionType -> String
(Int -> PageTransitionType -> ShowS)
-> (PageTransitionType -> String)
-> ([PageTransitionType] -> ShowS)
-> Show PageTransitionType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PageTransitionType] -> ShowS
$cshowList :: [PageTransitionType] -> ShowS
show :: PageTransitionType -> String
$cshow :: PageTransitionType -> String
showsPrec :: Int -> PageTransitionType -> ShowS
$cshowsPrec :: Int -> PageTransitionType -> ShowS
Show, PageTransitionType -> PageTransitionType -> Bool
(PageTransitionType -> PageTransitionType -> Bool)
-> (PageTransitionType -> PageTransitionType -> Bool)
-> Eq PageTransitionType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PageTransitionType -> PageTransitionType -> Bool
$c/= :: PageTransitionType -> PageTransitionType -> Bool
== :: PageTransitionType -> PageTransitionType -> Bool
$c== :: PageTransitionType -> PageTransitionType -> Bool
Eq)

instance P.Enum PageTransitionType where
    fromEnum :: PageTransitionType -> Int
fromEnum PageTransitionTypeReplace = 0
    fromEnum PageTransitionTypeSplit = 1
    fromEnum PageTransitionTypeBlinds = 2
    fromEnum PageTransitionTypeBox = 3
    fromEnum PageTransitionTypeWipe = 4
    fromEnum PageTransitionTypeDissolve = 5
    fromEnum PageTransitionTypeGlitter = 6
    fromEnum PageTransitionTypeFly = 7
    fromEnum PageTransitionTypePush = 8
    fromEnum PageTransitionTypeCover = 9
    fromEnum PageTransitionTypeUncover = 10
    fromEnum PageTransitionTypeFade = 11
    fromEnum (AnotherPageTransitionType k :: Int
k) = Int
k

    toEnum :: Int -> PageTransitionType
toEnum 0 = PageTransitionType
PageTransitionTypeReplace
    toEnum 1 = PageTransitionType
PageTransitionTypeSplit
    toEnum 2 = PageTransitionType
PageTransitionTypeBlinds
    toEnum 3 = PageTransitionType
PageTransitionTypeBox
    toEnum 4 = PageTransitionType
PageTransitionTypeWipe
    toEnum 5 = PageTransitionType
PageTransitionTypeDissolve
    toEnum 6 = PageTransitionType
PageTransitionTypeGlitter
    toEnum 7 = PageTransitionType
PageTransitionTypeFly
    toEnum 8 = PageTransitionType
PageTransitionTypePush
    toEnum 9 = PageTransitionType
PageTransitionTypeCover
    toEnum 10 = PageTransitionType
PageTransitionTypeUncover
    toEnum 11 = PageTransitionType
PageTransitionTypeFade
    toEnum k :: Int
k = Int -> PageTransitionType
AnotherPageTransitionType Int
k

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

foreign import ccall "poppler_page_transition_type_get_type" c_poppler_page_transition_type_get_type :: 
    IO GType

instance BoxedEnum PageTransitionType where
    boxedEnumType :: PageTransitionType -> IO GType
boxedEnumType _ = IO GType
c_poppler_page_transition_type_get_type

-- Enum PageTransitionDirection
-- | Page transition direction types for @/POPPLER_PAGE_TRANSITION_SPLIT/@,
-- @/POPPLER_PAGE_TRANSITION_BOX/@ and @/POPPLER_PAGE_TRANSITION_FLY/@ transition types
data PageTransitionDirection = 
      PageTransitionDirectionInward
    -- ^ inward from the edges of the page
    | PageTransitionDirectionOutward
    -- ^ outward from the center of the page
    | AnotherPageTransitionDirection Int
    -- ^ Catch-all for unknown values
    deriving (Int -> PageTransitionDirection -> ShowS
[PageTransitionDirection] -> ShowS
PageTransitionDirection -> String
(Int -> PageTransitionDirection -> ShowS)
-> (PageTransitionDirection -> String)
-> ([PageTransitionDirection] -> ShowS)
-> Show PageTransitionDirection
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PageTransitionDirection] -> ShowS
$cshowList :: [PageTransitionDirection] -> ShowS
show :: PageTransitionDirection -> String
$cshow :: PageTransitionDirection -> String
showsPrec :: Int -> PageTransitionDirection -> ShowS
$cshowsPrec :: Int -> PageTransitionDirection -> ShowS
Show, PageTransitionDirection -> PageTransitionDirection -> Bool
(PageTransitionDirection -> PageTransitionDirection -> Bool)
-> (PageTransitionDirection -> PageTransitionDirection -> Bool)
-> Eq PageTransitionDirection
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PageTransitionDirection -> PageTransitionDirection -> Bool
$c/= :: PageTransitionDirection -> PageTransitionDirection -> Bool
== :: PageTransitionDirection -> PageTransitionDirection -> Bool
$c== :: PageTransitionDirection -> PageTransitionDirection -> Bool
Eq)

instance P.Enum PageTransitionDirection where
    fromEnum :: PageTransitionDirection -> Int
fromEnum PageTransitionDirectionInward = 0
    fromEnum PageTransitionDirectionOutward = 1
    fromEnum (AnotherPageTransitionDirection k :: Int
k) = Int
k

    toEnum :: Int -> PageTransitionDirection
toEnum 0 = PageTransitionDirection
PageTransitionDirectionInward
    toEnum 1 = PageTransitionDirection
PageTransitionDirectionOutward
    toEnum k :: Int
k = Int -> PageTransitionDirection
AnotherPageTransitionDirection Int
k

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

foreign import ccall "poppler_page_transition_direction_get_type" c_poppler_page_transition_direction_get_type :: 
    IO GType

instance BoxedEnum PageTransitionDirection where
    boxedEnumType :: PageTransitionDirection -> IO GType
boxedEnumType _ = IO GType
c_poppler_page_transition_direction_get_type

-- Enum PageTransitionAlignment
-- | Page transition alignment types for @/POPPLER_PAGE_TRANSITION_SPLIT/@
-- and @/POPPLER_PAGE_TRANSITION_BLINDS/@ transition types
data PageTransitionAlignment = 
      PageTransitionAlignmentHorizontal
    -- ^ horizontal dimension
    | PageTransitionAlignmentVertical
    -- ^ vertical dimension
    | AnotherPageTransitionAlignment Int
    -- ^ Catch-all for unknown values
    deriving (Int -> PageTransitionAlignment -> ShowS
[PageTransitionAlignment] -> ShowS
PageTransitionAlignment -> String
(Int -> PageTransitionAlignment -> ShowS)
-> (PageTransitionAlignment -> String)
-> ([PageTransitionAlignment] -> ShowS)
-> Show PageTransitionAlignment
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PageTransitionAlignment] -> ShowS
$cshowList :: [PageTransitionAlignment] -> ShowS
show :: PageTransitionAlignment -> String
$cshow :: PageTransitionAlignment -> String
showsPrec :: Int -> PageTransitionAlignment -> ShowS
$cshowsPrec :: Int -> PageTransitionAlignment -> ShowS
Show, PageTransitionAlignment -> PageTransitionAlignment -> Bool
(PageTransitionAlignment -> PageTransitionAlignment -> Bool)
-> (PageTransitionAlignment -> PageTransitionAlignment -> Bool)
-> Eq PageTransitionAlignment
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PageTransitionAlignment -> PageTransitionAlignment -> Bool
$c/= :: PageTransitionAlignment -> PageTransitionAlignment -> Bool
== :: PageTransitionAlignment -> PageTransitionAlignment -> Bool
$c== :: PageTransitionAlignment -> PageTransitionAlignment -> Bool
Eq)

instance P.Enum PageTransitionAlignment where
    fromEnum :: PageTransitionAlignment -> Int
fromEnum PageTransitionAlignmentHorizontal = 0
    fromEnum PageTransitionAlignmentVertical = 1
    fromEnum (AnotherPageTransitionAlignment k :: Int
k) = Int
k

    toEnum :: Int -> PageTransitionAlignment
toEnum 0 = PageTransitionAlignment
PageTransitionAlignmentHorizontal
    toEnum 1 = PageTransitionAlignment
PageTransitionAlignmentVertical
    toEnum k :: Int
k = Int -> PageTransitionAlignment
AnotherPageTransitionAlignment Int
k

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

foreign import ccall "poppler_page_transition_alignment_get_type" c_poppler_page_transition_alignment_get_type :: 
    IO GType

instance BoxedEnum PageTransitionAlignment where
    boxedEnumType :: PageTransitionAlignment -> IO GType
boxedEnumType _ = IO GType
c_poppler_page_transition_alignment_get_type

-- Enum PageMode
-- | Page modes
data PageMode = 
      PageModeUnset
    -- ^ no specific mode set
    | PageModeNone
    -- ^ neither document outline nor thumbnails visible
    | PageModeUseOutlines
    -- ^ document outline visible
    | PageModeUseThumbs
    -- ^ thumbnails visible
    | PageModeFullScreen
    -- ^ full-screen mode
    | PageModeUseOc
    -- ^ layers panel visible
    | PageModeUseAttachments
    -- ^ attachments panel visible
    | AnotherPageMode Int
    -- ^ Catch-all for unknown values
    deriving (Int -> PageMode -> ShowS
[PageMode] -> ShowS
PageMode -> String
(Int -> PageMode -> ShowS)
-> (PageMode -> String) -> ([PageMode] -> ShowS) -> Show PageMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PageMode] -> ShowS
$cshowList :: [PageMode] -> ShowS
show :: PageMode -> String
$cshow :: PageMode -> String
showsPrec :: Int -> PageMode -> ShowS
$cshowsPrec :: Int -> PageMode -> ShowS
Show, PageMode -> PageMode -> Bool
(PageMode -> PageMode -> Bool)
-> (PageMode -> PageMode -> Bool) -> Eq PageMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PageMode -> PageMode -> Bool
$c/= :: PageMode -> PageMode -> Bool
== :: PageMode -> PageMode -> Bool
$c== :: PageMode -> PageMode -> Bool
Eq)

instance P.Enum PageMode where
    fromEnum :: PageMode -> Int
fromEnum PageModeUnset = 0
    fromEnum PageModeNone = 1
    fromEnum PageModeUseOutlines = 2
    fromEnum PageModeUseThumbs = 3
    fromEnum PageModeFullScreen = 4
    fromEnum PageModeUseOc = 5
    fromEnum PageModeUseAttachments = 6
    fromEnum (AnotherPageMode k :: Int
k) = Int
k

    toEnum :: Int -> PageMode
toEnum 0 = PageMode
PageModeUnset
    toEnum 1 = PageMode
PageModeNone
    toEnum 2 = PageMode
PageModeUseOutlines
    toEnum 3 = PageMode
PageModeUseThumbs
    toEnum 4 = PageMode
PageModeFullScreen
    toEnum 5 = PageMode
PageModeUseOc
    toEnum 6 = PageMode
PageModeUseAttachments
    toEnum k :: Int
k = Int -> PageMode
AnotherPageMode Int
k

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

foreign import ccall "poppler_page_mode_get_type" c_poppler_page_mode_get_type :: 
    IO GType

instance BoxedEnum PageMode where
    boxedEnumType :: PageMode -> IO GType
boxedEnumType _ = IO GType
c_poppler_page_mode_get_type

-- Enum PageLayout
-- | Page layout types
data PageLayout = 
      PageLayoutUnset
    -- ^ no specific layout set
    | PageLayoutSinglePage
    -- ^ one page at a time
    | PageLayoutOneColumn
    -- ^ pages in one column
    | PageLayoutTwoColumnLeft
    -- ^ pages in two columns with odd numbered pages on the left
    | PageLayoutTwoColumnRight
    -- ^ pages in two columns with odd numbered pages on the right
    | PageLayoutTwoPageLeft
    -- ^ two pages at a time with odd numbered pages on the left
    | PageLayoutTwoPageRight
    -- ^ two pages at a time with odd numbered pages on the right
    | AnotherPageLayout Int
    -- ^ Catch-all for unknown values
    deriving (Int -> PageLayout -> ShowS
[PageLayout] -> ShowS
PageLayout -> String
(Int -> PageLayout -> ShowS)
-> (PageLayout -> String)
-> ([PageLayout] -> ShowS)
-> Show PageLayout
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PageLayout] -> ShowS
$cshowList :: [PageLayout] -> ShowS
show :: PageLayout -> String
$cshow :: PageLayout -> String
showsPrec :: Int -> PageLayout -> ShowS
$cshowsPrec :: Int -> PageLayout -> ShowS
Show, PageLayout -> PageLayout -> Bool
(PageLayout -> PageLayout -> Bool)
-> (PageLayout -> PageLayout -> Bool) -> Eq PageLayout
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PageLayout -> PageLayout -> Bool
$c/= :: PageLayout -> PageLayout -> Bool
== :: PageLayout -> PageLayout -> Bool
$c== :: PageLayout -> PageLayout -> Bool
Eq)

instance P.Enum PageLayout where
    fromEnum :: PageLayout -> Int
fromEnum PageLayoutUnset = 0
    fromEnum PageLayoutSinglePage = 1
    fromEnum PageLayoutOneColumn = 2
    fromEnum PageLayoutTwoColumnLeft = 3
    fromEnum PageLayoutTwoColumnRight = 4
    fromEnum PageLayoutTwoPageLeft = 5
    fromEnum PageLayoutTwoPageRight = 6
    fromEnum (AnotherPageLayout k :: Int
k) = Int
k

    toEnum :: Int -> PageLayout
toEnum 0 = PageLayout
PageLayoutUnset
    toEnum 1 = PageLayout
PageLayoutSinglePage
    toEnum 2 = PageLayout
PageLayoutOneColumn
    toEnum 3 = PageLayout
PageLayoutTwoColumnLeft
    toEnum 4 = PageLayout
PageLayoutTwoColumnRight
    toEnum 5 = PageLayout
PageLayoutTwoPageLeft
    toEnum 6 = PageLayout
PageLayoutTwoPageRight
    toEnum k :: Int
k = Int -> PageLayout
AnotherPageLayout Int
k

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

foreign import ccall "poppler_page_layout_get_type" c_poppler_page_layout_get_type :: 
    IO GType

instance BoxedEnum PageLayout where
    boxedEnumType :: PageLayout -> IO GType
boxedEnumType _ = IO GType
c_poppler_page_layout_get_type

-- Enum PDFSubtype
-- | PDF Subtype
-- 
-- /Since: 0.70/
data PDFSubtype = 
      PDFSubtypeUnset
    -- ^ Null
    | PDFSubtypePdfA
    -- ^ ISO 19005 - Document management -- Electronic document file format for long-term preservation (PDF\/A)
    | PDFSubtypePdfE
    -- ^ ISO 24517 - Document management -- Engineering document format using PDF (PDF\/E)
    | PDFSubtypePdfUa
    -- ^ ISO 14289 - Document management applications -- Electronic document file format enhancement for accessibility (PDF\/UA)
    | PDFSubtypePdfVt
    -- ^ ISO 16612 - Graphic technology -- Variable data exchange (PDF\/VT)
    | PDFSubtypePdfX
    -- ^ ISO 15930 - Graphic technology -- Prepress digital data exchange (PDF\/X)
    | PDFSubtypeNone
    -- ^ Not compliant with the above standards
    | AnotherPDFSubtype Int
    -- ^ Catch-all for unknown values
    deriving (Int -> PDFSubtype -> ShowS
[PDFSubtype] -> ShowS
PDFSubtype -> String
(Int -> PDFSubtype -> ShowS)
-> (PDFSubtype -> String)
-> ([PDFSubtype] -> ShowS)
-> Show PDFSubtype
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PDFSubtype] -> ShowS
$cshowList :: [PDFSubtype] -> ShowS
show :: PDFSubtype -> String
$cshow :: PDFSubtype -> String
showsPrec :: Int -> PDFSubtype -> ShowS
$cshowsPrec :: Int -> PDFSubtype -> ShowS
Show, PDFSubtype -> PDFSubtype -> Bool
(PDFSubtype -> PDFSubtype -> Bool)
-> (PDFSubtype -> PDFSubtype -> Bool) -> Eq PDFSubtype
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PDFSubtype -> PDFSubtype -> Bool
$c/= :: PDFSubtype -> PDFSubtype -> Bool
== :: PDFSubtype -> PDFSubtype -> Bool
$c== :: PDFSubtype -> PDFSubtype -> Bool
Eq)

instance P.Enum PDFSubtype where
    fromEnum :: PDFSubtype -> Int
fromEnum PDFSubtypeUnset = 0
    fromEnum PDFSubtypePdfA = 1
    fromEnum PDFSubtypePdfE = 2
    fromEnum PDFSubtypePdfUa = 3
    fromEnum PDFSubtypePdfVt = 4
    fromEnum PDFSubtypePdfX = 5
    fromEnum PDFSubtypeNone = 6
    fromEnum (AnotherPDFSubtype k :: Int
k) = Int
k

    toEnum :: Int -> PDFSubtype
toEnum 0 = PDFSubtype
PDFSubtypeUnset
    toEnum 1 = PDFSubtype
PDFSubtypePdfA
    toEnum 2 = PDFSubtype
PDFSubtypePdfE
    toEnum 3 = PDFSubtype
PDFSubtypePdfUa
    toEnum 4 = PDFSubtype
PDFSubtypePdfVt
    toEnum 5 = PDFSubtype
PDFSubtypePdfX
    toEnum 6 = PDFSubtype
PDFSubtypeNone
    toEnum k :: Int
k = Int -> PDFSubtype
AnotherPDFSubtype Int
k

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

foreign import ccall "poppler_pdf_subtype_get_type" c_poppler_pdf_subtype_get_type :: 
    IO GType

instance BoxedEnum PDFSubtype where
    boxedEnumType :: PDFSubtype -> IO GType
boxedEnumType _ = IO GType
c_poppler_pdf_subtype_get_type

-- Enum PDFPart
-- | PDF Subtype Part
-- 
-- /Since: 0.70/
data PDFPart = 
      PDFPartUnset
    -- ^ Null
    | PDFPart1
    -- ^ 1
    | PDFPart2
    -- ^ 2
    | PDFPart3
    -- ^ 3
    | PDFPart4
    -- ^ 4
    | PDFPart5
    -- ^ 5
    | PDFPart6
    -- ^ 6
    | PDFPart7
    -- ^ 7
    | PDFPart8
    -- ^ 8
    | PDFPartNone
    -- ^ No part available
    | AnotherPDFPart Int
    -- ^ Catch-all for unknown values
    deriving (Int -> PDFPart -> ShowS
[PDFPart] -> ShowS
PDFPart -> String
(Int -> PDFPart -> ShowS)
-> (PDFPart -> String) -> ([PDFPart] -> ShowS) -> Show PDFPart
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PDFPart] -> ShowS
$cshowList :: [PDFPart] -> ShowS
show :: PDFPart -> String
$cshow :: PDFPart -> String
showsPrec :: Int -> PDFPart -> ShowS
$cshowsPrec :: Int -> PDFPart -> ShowS
Show, PDFPart -> PDFPart -> Bool
(PDFPart -> PDFPart -> Bool)
-> (PDFPart -> PDFPart -> Bool) -> Eq PDFPart
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PDFPart -> PDFPart -> Bool
$c/= :: PDFPart -> PDFPart -> Bool
== :: PDFPart -> PDFPart -> Bool
$c== :: PDFPart -> PDFPart -> Bool
Eq)

instance P.Enum PDFPart where
    fromEnum :: PDFPart -> Int
fromEnum PDFPartUnset = 0
    fromEnum PDFPart1 = 1
    fromEnum PDFPart2 = 2
    fromEnum PDFPart3 = 3
    fromEnum PDFPart4 = 4
    fromEnum PDFPart5 = 5
    fromEnum PDFPart6 = 6
    fromEnum PDFPart7 = 7
    fromEnum PDFPart8 = 8
    fromEnum PDFPartNone = 9
    fromEnum (AnotherPDFPart k :: Int
k) = Int
k

    toEnum :: Int -> PDFPart
toEnum 0 = PDFPart
PDFPartUnset
    toEnum 1 = PDFPart
PDFPart1
    toEnum 2 = PDFPart
PDFPart2
    toEnum 3 = PDFPart
PDFPart3
    toEnum 4 = PDFPart
PDFPart4
    toEnum 5 = PDFPart
PDFPart5
    toEnum 6 = PDFPart
PDFPart6
    toEnum 7 = PDFPart
PDFPart7
    toEnum 8 = PDFPart
PDFPart8
    toEnum 9 = PDFPart
PDFPartNone
    toEnum k :: Int
k = Int -> PDFPart
AnotherPDFPart Int
k

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

foreign import ccall "poppler_pdf_part_get_type" c_poppler_pdf_part_get_type :: 
    IO GType

instance BoxedEnum PDFPart where
    boxedEnumType :: PDFPart -> IO GType
boxedEnumType _ = IO GType
c_poppler_pdf_part_get_type

-- Enum PDFConformance
-- | PDF Subtype Conformance
-- 
-- /Since: 0.70/
data PDFConformance = 
      PDFConformanceUnset
    -- ^ Null
    | PDFConformanceA
    -- ^ Level A (accessible) conformance (PDF\/A)
    | PDFConformanceB
    -- ^ Level B (basic) conformance (PDF\/A)
    | PDFConformanceG
    -- ^ Level G (external graphical content) (PDF\/X)
    | PDFConformanceN
    -- ^ Level N (external ICC Profile) (PDF\/X)
    | PDFConformanceP
    -- ^ Level P (ICC Profile) (PDF\/X)
    | PDFConformancePg
    -- ^ Level PG (conjunction of P and G) (PDF\/X)
    | PDFConformanceU
    -- ^ Level U (Unicode) conformance (PDF\/A)
    | PDFConformanceNone
    -- ^ No conformance level available
    | AnotherPDFConformance Int
    -- ^ Catch-all for unknown values
    deriving (Int -> PDFConformance -> ShowS
[PDFConformance] -> ShowS
PDFConformance -> String
(Int -> PDFConformance -> ShowS)
-> (PDFConformance -> String)
-> ([PDFConformance] -> ShowS)
-> Show PDFConformance
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PDFConformance] -> ShowS
$cshowList :: [PDFConformance] -> ShowS
show :: PDFConformance -> String
$cshow :: PDFConformance -> String
showsPrec :: Int -> PDFConformance -> ShowS
$cshowsPrec :: Int -> PDFConformance -> ShowS
Show, PDFConformance -> PDFConformance -> Bool
(PDFConformance -> PDFConformance -> Bool)
-> (PDFConformance -> PDFConformance -> Bool) -> Eq PDFConformance
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PDFConformance -> PDFConformance -> Bool
$c/= :: PDFConformance -> PDFConformance -> Bool
== :: PDFConformance -> PDFConformance -> Bool
$c== :: PDFConformance -> PDFConformance -> Bool
Eq)

instance P.Enum PDFConformance where
    fromEnum :: PDFConformance -> Int
fromEnum PDFConformanceUnset = 0
    fromEnum PDFConformanceA = 1
    fromEnum PDFConformanceB = 2
    fromEnum PDFConformanceG = 3
    fromEnum PDFConformanceN = 4
    fromEnum PDFConformanceP = 5
    fromEnum PDFConformancePg = 6
    fromEnum PDFConformanceU = 7
    fromEnum PDFConformanceNone = 8
    fromEnum (AnotherPDFConformance k :: Int
k) = Int
k

    toEnum :: Int -> PDFConformance
toEnum 0 = PDFConformance
PDFConformanceUnset
    toEnum 1 = PDFConformance
PDFConformanceA
    toEnum 2 = PDFConformance
PDFConformanceB
    toEnum 3 = PDFConformance
PDFConformanceG
    toEnum 4 = PDFConformance
PDFConformanceN
    toEnum 5 = PDFConformance
PDFConformanceP
    toEnum 6 = PDFConformance
PDFConformancePg
    toEnum 7 = PDFConformance
PDFConformanceU
    toEnum 8 = PDFConformance
PDFConformanceNone
    toEnum k :: Int
k = Int -> PDFConformance
AnotherPDFConformance Int
k

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

foreign import ccall "poppler_pdf_conformance_get_type" c_poppler_pdf_conformance_get_type :: 
    IO GType

instance BoxedEnum PDFConformance where
    boxedEnumType :: PDFConformance -> IO GType
boxedEnumType _ = IO GType
c_poppler_pdf_conformance_get_type

-- Enum MoviePlayMode
-- | Play mode enum values.
-- 
-- /Since: 0.54/
data MoviePlayMode = 
      MoviePlayModeOnce
    -- ^ the movie should be played once and controls should be closed at the end.
    | MoviePlayModeOpen
    -- ^ the movie should be played once, but controls should be left open.
    | MoviePlayModeRepeat
    -- ^ the movie should be played in loop, until manually stopped.
    | MoviePlayModePalindrome
    -- ^ the movie should be played forward and backward, forward and backward,
    --   and so forth, until manually stopped.
    | AnotherMoviePlayMode Int
    -- ^ Catch-all for unknown values
    deriving (Int -> MoviePlayMode -> ShowS
[MoviePlayMode] -> ShowS
MoviePlayMode -> String
(Int -> MoviePlayMode -> ShowS)
-> (MoviePlayMode -> String)
-> ([MoviePlayMode] -> ShowS)
-> Show MoviePlayMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MoviePlayMode] -> ShowS
$cshowList :: [MoviePlayMode] -> ShowS
show :: MoviePlayMode -> String
$cshow :: MoviePlayMode -> String
showsPrec :: Int -> MoviePlayMode -> ShowS
$cshowsPrec :: Int -> MoviePlayMode -> ShowS
Show, MoviePlayMode -> MoviePlayMode -> Bool
(MoviePlayMode -> MoviePlayMode -> Bool)
-> (MoviePlayMode -> MoviePlayMode -> Bool) -> Eq MoviePlayMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MoviePlayMode -> MoviePlayMode -> Bool
$c/= :: MoviePlayMode -> MoviePlayMode -> Bool
== :: MoviePlayMode -> MoviePlayMode -> Bool
$c== :: MoviePlayMode -> MoviePlayMode -> Bool
Eq)

instance P.Enum MoviePlayMode where
    fromEnum :: MoviePlayMode -> Int
fromEnum MoviePlayModeOnce = 0
    fromEnum MoviePlayModeOpen = 1
    fromEnum MoviePlayModeRepeat = 2
    fromEnum MoviePlayModePalindrome = 3
    fromEnum (AnotherMoviePlayMode k :: Int
k) = Int
k

    toEnum :: Int -> MoviePlayMode
toEnum 0 = MoviePlayMode
MoviePlayModeOnce
    toEnum 1 = MoviePlayMode
MoviePlayModeOpen
    toEnum 2 = MoviePlayMode
MoviePlayModeRepeat
    toEnum 3 = MoviePlayMode
MoviePlayModePalindrome
    toEnum k :: Int
k = Int -> MoviePlayMode
AnotherMoviePlayMode Int
k

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

foreign import ccall "poppler_movie_play_mode_get_type" c_poppler_movie_play_mode_get_type :: 
    IO GType

instance BoxedEnum MoviePlayMode where
    boxedEnumType :: MoviePlayMode -> IO GType
boxedEnumType _ = IO GType
c_poppler_movie_play_mode_get_type

-- Enum FormTextType
-- | /No description available in the introspection data./
data FormTextType = 
      FormTextTypeNormal
    -- ^ /No description available in the introspection data./
    | FormTextTypeMultiline
    -- ^ /No description available in the introspection data./
    | FormTextTypeFileSelect
    -- ^ /No description available in the introspection data./
    | AnotherFormTextType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> FormTextType -> ShowS
[FormTextType] -> ShowS
FormTextType -> String
(Int -> FormTextType -> ShowS)
-> (FormTextType -> String)
-> ([FormTextType] -> ShowS)
-> Show FormTextType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FormTextType] -> ShowS
$cshowList :: [FormTextType] -> ShowS
show :: FormTextType -> String
$cshow :: FormTextType -> String
showsPrec :: Int -> FormTextType -> ShowS
$cshowsPrec :: Int -> FormTextType -> ShowS
Show, FormTextType -> FormTextType -> Bool
(FormTextType -> FormTextType -> Bool)
-> (FormTextType -> FormTextType -> Bool) -> Eq FormTextType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FormTextType -> FormTextType -> Bool
$c/= :: FormTextType -> FormTextType -> Bool
== :: FormTextType -> FormTextType -> Bool
$c== :: FormTextType -> FormTextType -> Bool
Eq)

instance P.Enum FormTextType where
    fromEnum :: FormTextType -> Int
fromEnum FormTextTypeNormal = 0
    fromEnum FormTextTypeMultiline = 1
    fromEnum FormTextTypeFileSelect = 2
    fromEnum (AnotherFormTextType k :: Int
k) = Int
k

    toEnum :: Int -> FormTextType
toEnum 0 = FormTextType
FormTextTypeNormal
    toEnum 1 = FormTextType
FormTextTypeMultiline
    toEnum 2 = FormTextType
FormTextTypeFileSelect
    toEnum k :: Int
k = Int -> FormTextType
AnotherFormTextType Int
k

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

foreign import ccall "poppler_form_text_type_get_type" c_poppler_form_text_type_get_type :: 
    IO GType

instance BoxedEnum FormTextType where
    boxedEnumType :: FormTextType -> IO GType
boxedEnumType _ = IO GType
c_poppler_form_text_type_get_type

-- Enum FormFieldType
-- | /No description available in the introspection data./
data FormFieldType = 
      FormFieldTypeUnknown
    -- ^ /No description available in the introspection data./
    | FormFieldTypeButton
    -- ^ /No description available in the introspection data./
    | FormFieldTypeText
    -- ^ /No description available in the introspection data./
    | FormFieldTypeChoice
    -- ^ /No description available in the introspection data./
    | FormFieldTypeSignature
    -- ^ /No description available in the introspection data./
    | AnotherFormFieldType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> FormFieldType -> ShowS
[FormFieldType] -> ShowS
FormFieldType -> String
(Int -> FormFieldType -> ShowS)
-> (FormFieldType -> String)
-> ([FormFieldType] -> ShowS)
-> Show FormFieldType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FormFieldType] -> ShowS
$cshowList :: [FormFieldType] -> ShowS
show :: FormFieldType -> String
$cshow :: FormFieldType -> String
showsPrec :: Int -> FormFieldType -> ShowS
$cshowsPrec :: Int -> FormFieldType -> ShowS
Show, FormFieldType -> FormFieldType -> Bool
(FormFieldType -> FormFieldType -> Bool)
-> (FormFieldType -> FormFieldType -> Bool) -> Eq FormFieldType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FormFieldType -> FormFieldType -> Bool
$c/= :: FormFieldType -> FormFieldType -> Bool
== :: FormFieldType -> FormFieldType -> Bool
$c== :: FormFieldType -> FormFieldType -> Bool
Eq)

instance P.Enum FormFieldType where
    fromEnum :: FormFieldType -> Int
fromEnum FormFieldTypeUnknown = 0
    fromEnum FormFieldTypeButton = 1
    fromEnum FormFieldTypeText = 2
    fromEnum FormFieldTypeChoice = 3
    fromEnum FormFieldTypeSignature = 4
    fromEnum (AnotherFormFieldType k :: Int
k) = Int
k

    toEnum :: Int -> FormFieldType
toEnum 0 = FormFieldType
FormFieldTypeUnknown
    toEnum 1 = FormFieldType
FormFieldTypeButton
    toEnum 2 = FormFieldType
FormFieldTypeText
    toEnum 3 = FormFieldType
FormFieldTypeChoice
    toEnum 4 = FormFieldType
FormFieldTypeSignature
    toEnum k :: Int
k = Int -> FormFieldType
AnotherFormFieldType Int
k

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

foreign import ccall "poppler_form_field_type_get_type" c_poppler_form_field_type_get_type :: 
    IO GType

instance BoxedEnum FormFieldType where
    boxedEnumType :: FormFieldType -> IO GType
boxedEnumType _ = IO GType
c_poppler_form_field_type_get_type

-- Enum FormChoiceType
-- | /No description available in the introspection data./
data FormChoiceType = 
      FormChoiceTypeCombo
    -- ^ /No description available in the introspection data./
    | FormChoiceTypeList
    -- ^ /No description available in the introspection data./
    | AnotherFormChoiceType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> FormChoiceType -> ShowS
[FormChoiceType] -> ShowS
FormChoiceType -> String
(Int -> FormChoiceType -> ShowS)
-> (FormChoiceType -> String)
-> ([FormChoiceType] -> ShowS)
-> Show FormChoiceType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FormChoiceType] -> ShowS
$cshowList :: [FormChoiceType] -> ShowS
show :: FormChoiceType -> String
$cshow :: FormChoiceType -> String
showsPrec :: Int -> FormChoiceType -> ShowS
$cshowsPrec :: Int -> FormChoiceType -> ShowS
Show, FormChoiceType -> FormChoiceType -> Bool
(FormChoiceType -> FormChoiceType -> Bool)
-> (FormChoiceType -> FormChoiceType -> Bool) -> Eq FormChoiceType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FormChoiceType -> FormChoiceType -> Bool
$c/= :: FormChoiceType -> FormChoiceType -> Bool
== :: FormChoiceType -> FormChoiceType -> Bool
$c== :: FormChoiceType -> FormChoiceType -> Bool
Eq)

instance P.Enum FormChoiceType where
    fromEnum :: FormChoiceType -> Int
fromEnum FormChoiceTypeCombo = 0
    fromEnum FormChoiceTypeList = 1
    fromEnum (AnotherFormChoiceType k :: Int
k) = Int
k

    toEnum :: Int -> FormChoiceType
toEnum 0 = FormChoiceType
FormChoiceTypeCombo
    toEnum 1 = FormChoiceType
FormChoiceTypeList
    toEnum k :: Int
k = Int -> FormChoiceType
AnotherFormChoiceType Int
k

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

foreign import ccall "poppler_form_choice_type_get_type" c_poppler_form_choice_type_get_type :: 
    IO GType

instance BoxedEnum FormChoiceType where
    boxedEnumType :: FormChoiceType -> IO GType
boxedEnumType _ = IO GType
c_poppler_form_choice_type_get_type

-- Enum FormButtonType
-- | /No description available in the introspection data./
data FormButtonType = 
      FormButtonTypePush
    -- ^ /No description available in the introspection data./
    | FormButtonTypeCheck
    -- ^ /No description available in the introspection data./
    | FormButtonTypeRadio
    -- ^ /No description available in the introspection data./
    | AnotherFormButtonType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> FormButtonType -> ShowS
[FormButtonType] -> ShowS
FormButtonType -> String
(Int -> FormButtonType -> ShowS)
-> (FormButtonType -> String)
-> ([FormButtonType] -> ShowS)
-> Show FormButtonType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FormButtonType] -> ShowS
$cshowList :: [FormButtonType] -> ShowS
show :: FormButtonType -> String
$cshow :: FormButtonType -> String
showsPrec :: Int -> FormButtonType -> ShowS
$cshowsPrec :: Int -> FormButtonType -> ShowS
Show, FormButtonType -> FormButtonType -> Bool
(FormButtonType -> FormButtonType -> Bool)
-> (FormButtonType -> FormButtonType -> Bool) -> Eq FormButtonType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FormButtonType -> FormButtonType -> Bool
$c/= :: FormButtonType -> FormButtonType -> Bool
== :: FormButtonType -> FormButtonType -> Bool
$c== :: FormButtonType -> FormButtonType -> Bool
Eq)

instance P.Enum FormButtonType where
    fromEnum :: FormButtonType -> Int
fromEnum FormButtonTypePush = 0
    fromEnum FormButtonTypeCheck = 1
    fromEnum FormButtonTypeRadio = 2
    fromEnum (AnotherFormButtonType k :: Int
k) = Int
k

    toEnum :: Int -> FormButtonType
toEnum 0 = FormButtonType
FormButtonTypePush
    toEnum 1 = FormButtonType
FormButtonTypeCheck
    toEnum 2 = FormButtonType
FormButtonTypeRadio
    toEnum k :: Int
k = Int -> FormButtonType
AnotherFormButtonType Int
k

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

foreign import ccall "poppler_form_button_type_get_type" c_poppler_form_button_type_get_type :: 
    IO GType

instance BoxedEnum FormButtonType where
    boxedEnumType :: FormButtonType -> IO GType
boxedEnumType _ = IO GType
c_poppler_form_button_type_get_type

-- Enum FontType
-- | Font types
data FontType = 
      FontTypeUnknown
    -- ^ unknown font type
    | FontTypeType1
    -- ^ Type 1 font type
    | FontTypeType1c
    -- ^ Type 1 font type embedded in Compact Font Format (CFF) font program
    | FontTypeType1cot
    -- ^ Type 1 font type embedded in OpenType font program
    | FontTypeType3
    -- ^ A font type that is defined with PDF graphics operators
    | FontTypeTruetype
    -- ^ TrueType font type
    | FontTypeTruetypeot
    -- ^ TrueType font type embedded in OpenType font program
    | FontTypeCidType0
    -- ^ CIDFont type based on Type 1 font technology
    | FontTypeCidType0c
    -- ^ CIDFont type based on Type 1 font technology embedded in CFF font program
    | FontTypeCidType0cot
    -- ^ CIDFont type based on Type 1 font technology embedded in OpenType font program
    | FontTypeCidType2
    -- ^ CIDFont type based on TrueType font technology
    | FontTypeCidType2ot
    -- ^ CIDFont type based on TrueType font technology embedded in OpenType font program
    | AnotherFontType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> FontType -> ShowS
[FontType] -> ShowS
FontType -> String
(Int -> FontType -> ShowS)
-> (FontType -> String) -> ([FontType] -> ShowS) -> Show FontType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FontType] -> ShowS
$cshowList :: [FontType] -> ShowS
show :: FontType -> String
$cshow :: FontType -> String
showsPrec :: Int -> FontType -> ShowS
$cshowsPrec :: Int -> FontType -> ShowS
Show, FontType -> FontType -> Bool
(FontType -> FontType -> Bool)
-> (FontType -> FontType -> Bool) -> Eq FontType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FontType -> FontType -> Bool
$c/= :: FontType -> FontType -> Bool
== :: FontType -> FontType -> Bool
$c== :: FontType -> FontType -> Bool
Eq)

instance P.Enum FontType where
    fromEnum :: FontType -> Int
fromEnum FontTypeUnknown = 0
    fromEnum FontTypeType1 = 1
    fromEnum FontTypeType1c = 2
    fromEnum FontTypeType1cot = 3
    fromEnum FontTypeType3 = 4
    fromEnum FontTypeTruetype = 5
    fromEnum FontTypeTruetypeot = 6
    fromEnum FontTypeCidType0 = 7
    fromEnum FontTypeCidType0c = 8
    fromEnum FontTypeCidType0cot = 9
    fromEnum FontTypeCidType2 = 10
    fromEnum FontTypeCidType2ot = 11
    fromEnum (AnotherFontType k :: Int
k) = Int
k

    toEnum :: Int -> FontType
toEnum 0 = FontType
FontTypeUnknown
    toEnum 1 = FontType
FontTypeType1
    toEnum 2 = FontType
FontTypeType1c
    toEnum 3 = FontType
FontTypeType1cot
    toEnum 4 = FontType
FontTypeType3
    toEnum 5 = FontType
FontTypeTruetype
    toEnum 6 = FontType
FontTypeTruetypeot
    toEnum 7 = FontType
FontTypeCidType0
    toEnum 8 = FontType
FontTypeCidType0c
    toEnum 9 = FontType
FontTypeCidType0cot
    toEnum 10 = FontType
FontTypeCidType2
    toEnum 11 = FontType
FontTypeCidType2ot
    toEnum k :: Int
k = Int -> FontType
AnotherFontType Int
k

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

foreign import ccall "poppler_font_type_get_type" c_poppler_font_type_get_type :: 
    IO GType

instance BoxedEnum FontType where
    boxedEnumType :: FontType -> IO GType
boxedEnumType _ = IO GType
c_poppler_font_type_get_type

-- Enum Error
-- | Error codes returned by t'GI.Poppler.Objects.Document.Document'
data Error = 
      ErrorInvalid
    -- ^ Generic error when a document operation fails
    | ErrorEncrypted
    -- ^ Document is encrypted
    | ErrorOpenFile
    -- ^ File could not be opened for writing when saving document
    | ErrorBadCatalog
    -- ^ Failed to read the document catalog
    | ErrorDamaged
    -- ^ Document is damaged
    | AnotherError Int
    -- ^ Catch-all for unknown values
    deriving (Int -> Error -> ShowS
[Error] -> ShowS
Error -> String
(Int -> Error -> ShowS)
-> (Error -> String) -> ([Error] -> ShowS) -> Show Error
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Error] -> ShowS
$cshowList :: [Error] -> ShowS
show :: Error -> String
$cshow :: Error -> String
showsPrec :: Int -> Error -> ShowS
$cshowsPrec :: Int -> Error -> ShowS
Show, Error -> Error -> Bool
(Error -> Error -> Bool) -> (Error -> Error -> Bool) -> Eq Error
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Error -> Error -> Bool
$c/= :: Error -> Error -> Bool
== :: Error -> Error -> Bool
$c== :: Error -> Error -> Bool
Eq)

instance P.Enum Error where
    fromEnum :: Error -> Int
fromEnum ErrorInvalid = 0
    fromEnum ErrorEncrypted = 1
    fromEnum ErrorOpenFile = 2
    fromEnum ErrorBadCatalog = 3
    fromEnum ErrorDamaged = 4
    fromEnum (AnotherError k :: Int
k) = Int
k

    toEnum :: Int -> Error
toEnum 0 = Error
ErrorInvalid
    toEnum 1 = Error
ErrorEncrypted
    toEnum 2 = Error
ErrorOpenFile
    toEnum 3 = Error
ErrorBadCatalog
    toEnum 4 = Error
ErrorDamaged
    toEnum k :: Int
k = Int -> Error
AnotherError Int
k

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

instance GErrorClass Error where
    gerrorClassDomain :: Error -> Text
gerrorClassDomain _ = "poppler-quark"

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

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

foreign import ccall "poppler_error_get_type" c_poppler_error_get_type :: 
    IO GType

instance BoxedEnum Error where
    boxedEnumType :: Error -> IO GType
boxedEnumType _ = IO GType
c_poppler_error_get_type

-- Enum DestType
-- | Destination types
data DestType = 
      DestTypeUnknown
    -- ^ unknown destination
    | DestTypeXyz
    -- ^ go to page with coordinates (left, top)
    -- positioned at the upper-left corner of the window and the contents of
    -- the page magnified by the factor zoom
    | DestTypeFit
    -- ^ go to page with its contents magnified just
    -- enough to fit the entire page within the window both horizontally and
    -- vertically
    | DestTypeFith
    -- ^ go to page with the vertical coordinate top
    -- positioned at the top edge of the window and the contents of the page
    -- magnified just enough to fit the entire width of the page within the window
    | DestTypeFitv
    -- ^ go to page with the horizontal coordinate
    -- left positioned at the left edge of the window and the contents of the
    -- page magnified just enough to fit the entire height of the page within the window
    | DestTypeFitr
    -- ^ go to page with its contents magnified just
    -- enough to fit the rectangle specified by the coordinates left, bottom,
    -- right, and top entirely within the window both horizontally and vertically
    | DestTypeFitb
    -- ^ go to page with its contents magnified just enough to fit
    -- its bounding box entirely within the window both horizontally and vertically
    | DestTypeFitbh
    -- ^ go to page with the vertical
    -- coordinate top positioned at the top edge of the window and the
    -- contents of the page magnified just enough to fit the entire width of its
    -- bounding box within the window
    | DestTypeFitbv
    -- ^ go to page with the horizontal
    -- coordinate left positioned at the left edge of the window and the
    -- contents of the page magnified just enough to fit the entire height of its
    -- bounding box within the window
    | DestTypeNamed
    -- ^ got to page specified by a name. See 'GI.Poppler.Objects.Document.documentFindDest'
    | AnotherDestType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> DestType -> ShowS
[DestType] -> ShowS
DestType -> String
(Int -> DestType -> ShowS)
-> (DestType -> String) -> ([DestType] -> ShowS) -> Show DestType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [DestType] -> ShowS
$cshowList :: [DestType] -> ShowS
show :: DestType -> String
$cshow :: DestType -> String
showsPrec :: Int -> DestType -> ShowS
$cshowsPrec :: Int -> DestType -> ShowS
Show, DestType -> DestType -> Bool
(DestType -> DestType -> Bool)
-> (DestType -> DestType -> Bool) -> Eq DestType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DestType -> DestType -> Bool
$c/= :: DestType -> DestType -> Bool
== :: DestType -> DestType -> Bool
$c== :: DestType -> DestType -> Bool
Eq)

instance P.Enum DestType where
    fromEnum :: DestType -> Int
fromEnum DestTypeUnknown = 0
    fromEnum DestTypeXyz = 1
    fromEnum DestTypeFit = 2
    fromEnum DestTypeFith = 3
    fromEnum DestTypeFitv = 4
    fromEnum DestTypeFitr = 5
    fromEnum DestTypeFitb = 6
    fromEnum DestTypeFitbh = 7
    fromEnum DestTypeFitbv = 8
    fromEnum DestTypeNamed = 9
    fromEnum (AnotherDestType k :: Int
k) = Int
k

    toEnum :: Int -> DestType
toEnum 0 = DestType
DestTypeUnknown
    toEnum 1 = DestType
DestTypeXyz
    toEnum 2 = DestType
DestTypeFit
    toEnum 3 = DestType
DestTypeFith
    toEnum 4 = DestType
DestTypeFitv
    toEnum 5 = DestType
DestTypeFitr
    toEnum 6 = DestType
DestTypeFitb
    toEnum 7 = DestType
DestTypeFitbh
    toEnum 8 = DestType
DestTypeFitbv
    toEnum 9 = DestType
DestTypeNamed
    toEnum k :: Int
k = Int -> DestType
AnotherDestType Int
k

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

foreign import ccall "poppler_dest_type_get_type" c_poppler_dest_type_get_type :: 
    IO GType

instance BoxedEnum DestType where
    boxedEnumType :: DestType -> IO GType
boxedEnumType _ = IO GType
c_poppler_dest_type_get_type

-- Enum Backend
-- | Backend codes returned by 'GI.Poppler.Functions.getBackend'.
data Backend = 
      BackendUnknown
    -- ^ Unknown backend
    | BackendSplash
    -- ^ Splash backend
    | BackendCairo
    -- ^ Cairo backend
    | AnotherBackend Int
    -- ^ Catch-all for unknown values
    deriving (Int -> Backend -> ShowS
[Backend] -> ShowS
Backend -> String
(Int -> Backend -> ShowS)
-> (Backend -> String) -> ([Backend] -> ShowS) -> Show Backend
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Backend] -> ShowS
$cshowList :: [Backend] -> ShowS
show :: Backend -> String
$cshow :: Backend -> String
showsPrec :: Int -> Backend -> ShowS
$cshowsPrec :: Int -> Backend -> ShowS
Show, Backend -> Backend -> Bool
(Backend -> Backend -> Bool)
-> (Backend -> Backend -> Bool) -> Eq Backend
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Backend -> Backend -> Bool
$c/= :: Backend -> Backend -> Bool
== :: Backend -> Backend -> Bool
$c== :: Backend -> Backend -> Bool
Eq)

instance P.Enum Backend where
    fromEnum :: Backend -> Int
fromEnum BackendUnknown = 0
    fromEnum BackendSplash = 1
    fromEnum BackendCairo = 2
    fromEnum (AnotherBackend k :: Int
k) = Int
k

    toEnum :: Int -> Backend
toEnum 0 = Backend
BackendUnknown
    toEnum 1 = Backend
BackendSplash
    toEnum 2 = Backend
BackendCairo
    toEnum k :: Int
k = Int -> Backend
AnotherBackend Int
k

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

foreign import ccall "poppler_backend_get_type" c_poppler_backend_get_type :: 
    IO GType

instance BoxedEnum Backend where
    boxedEnumType :: Backend -> IO GType
boxedEnumType _ = IO GType
c_poppler_backend_get_type

-- Enum AnnotType
-- | /No description available in the introspection data./
data AnnotType = 
      AnnotTypeUnknown
    -- ^ /No description available in the introspection data./
    | AnnotTypeText
    -- ^ /No description available in the introspection data./
    | AnnotTypeLink
    -- ^ /No description available in the introspection data./
    | AnnotTypeFreeText
    -- ^ /No description available in the introspection data./
    | AnnotTypeLine
    -- ^ /No description available in the introspection data./
    | AnnotTypeSquare
    -- ^ /No description available in the introspection data./
    | AnnotTypeCircle
    -- ^ /No description available in the introspection data./
    | AnnotTypePolygon
    -- ^ /No description available in the introspection data./
    | AnnotTypePolyLine
    -- ^ /No description available in the introspection data./
    | AnnotTypeHighlight
    -- ^ /No description available in the introspection data./
    | AnnotTypeUnderline
    -- ^ /No description available in the introspection data./
    | AnnotTypeSquiggly
    -- ^ /No description available in the introspection data./
    | AnnotTypeStrikeOut
    -- ^ /No description available in the introspection data./
    | AnnotTypeStamp
    -- ^ /No description available in the introspection data./
    | AnnotTypeCaret
    -- ^ /No description available in the introspection data./
    | AnnotTypeInk
    -- ^ /No description available in the introspection data./
    | AnnotTypePopup
    -- ^ /No description available in the introspection data./
    | AnnotTypeFileAttachment
    -- ^ /No description available in the introspection data./
    | AnnotTypeSound
    -- ^ /No description available in the introspection data./
    | AnnotTypeMovie
    -- ^ /No description available in the introspection data./
    | AnnotTypeWidget
    -- ^ /No description available in the introspection data./
    | AnnotTypeScreen
    -- ^ /No description available in the introspection data./
    | AnnotTypePrinterMark
    -- ^ /No description available in the introspection data./
    | AnnotTypeTrapNet
    -- ^ /No description available in the introspection data./
    | AnnotTypeWatermark
    -- ^ /No description available in the introspection data./
    | AnnotType3d
    -- ^ /No description available in the introspection data./
    | AnotherAnnotType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> AnnotType -> ShowS
[AnnotType] -> ShowS
AnnotType -> String
(Int -> AnnotType -> ShowS)
-> (AnnotType -> String)
-> ([AnnotType] -> ShowS)
-> Show AnnotType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AnnotType] -> ShowS
$cshowList :: [AnnotType] -> ShowS
show :: AnnotType -> String
$cshow :: AnnotType -> String
showsPrec :: Int -> AnnotType -> ShowS
$cshowsPrec :: Int -> AnnotType -> ShowS
Show, AnnotType -> AnnotType -> Bool
(AnnotType -> AnnotType -> Bool)
-> (AnnotType -> AnnotType -> Bool) -> Eq AnnotType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AnnotType -> AnnotType -> Bool
$c/= :: AnnotType -> AnnotType -> Bool
== :: AnnotType -> AnnotType -> Bool
$c== :: AnnotType -> AnnotType -> Bool
Eq)

instance P.Enum AnnotType where
    fromEnum :: AnnotType -> Int
fromEnum AnnotTypeUnknown = 0
    fromEnum AnnotTypeText = 1
    fromEnum AnnotTypeLink = 2
    fromEnum AnnotTypeFreeText = 3
    fromEnum AnnotTypeLine = 4
    fromEnum AnnotTypeSquare = 5
    fromEnum AnnotTypeCircle = 6
    fromEnum AnnotTypePolygon = 7
    fromEnum AnnotTypePolyLine = 8
    fromEnum AnnotTypeHighlight = 9
    fromEnum AnnotTypeUnderline = 10
    fromEnum AnnotTypeSquiggly = 11
    fromEnum AnnotTypeStrikeOut = 12
    fromEnum AnnotTypeStamp = 13
    fromEnum AnnotTypeCaret = 14
    fromEnum AnnotTypeInk = 15
    fromEnum AnnotTypePopup = 16
    fromEnum AnnotTypeFileAttachment = 17
    fromEnum AnnotTypeSound = 18
    fromEnum AnnotTypeMovie = 19
    fromEnum AnnotTypeWidget = 20
    fromEnum AnnotTypeScreen = 21
    fromEnum AnnotTypePrinterMark = 22
    fromEnum AnnotTypeTrapNet = 23
    fromEnum AnnotTypeWatermark = 24
    fromEnum AnnotType3d = 25
    fromEnum (AnotherAnnotType k :: Int
k) = Int
k

    toEnum :: Int -> AnnotType
toEnum 0 = AnnotType
AnnotTypeUnknown
    toEnum 1 = AnnotType
AnnotTypeText
    toEnum 2 = AnnotType
AnnotTypeLink
    toEnum 3 = AnnotType
AnnotTypeFreeText
    toEnum 4 = AnnotType
AnnotTypeLine
    toEnum 5 = AnnotType
AnnotTypeSquare
    toEnum 6 = AnnotType
AnnotTypeCircle
    toEnum 7 = AnnotType
AnnotTypePolygon
    toEnum 8 = AnnotType
AnnotTypePolyLine
    toEnum 9 = AnnotType
AnnotTypeHighlight
    toEnum 10 = AnnotType
AnnotTypeUnderline
    toEnum 11 = AnnotType
AnnotTypeSquiggly
    toEnum 12 = AnnotType
AnnotTypeStrikeOut
    toEnum 13 = AnnotType
AnnotTypeStamp
    toEnum 14 = AnnotType
AnnotTypeCaret
    toEnum 15 = AnnotType
AnnotTypeInk
    toEnum 16 = AnnotType
AnnotTypePopup
    toEnum 17 = AnnotType
AnnotTypeFileAttachment
    toEnum 18 = AnnotType
AnnotTypeSound
    toEnum 19 = AnnotType
AnnotTypeMovie
    toEnum 20 = AnnotType
AnnotTypeWidget
    toEnum 21 = AnnotType
AnnotTypeScreen
    toEnum 22 = AnnotType
AnnotTypePrinterMark
    toEnum 23 = AnnotType
AnnotTypeTrapNet
    toEnum 24 = AnnotType
AnnotTypeWatermark
    toEnum 25 = AnnotType
AnnotType3d
    toEnum k :: Int
k = Int -> AnnotType
AnotherAnnotType Int
k

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

foreign import ccall "poppler_annot_type_get_type" c_poppler_annot_type_get_type :: 
    IO GType

instance BoxedEnum AnnotType where
    boxedEnumType :: AnnotType -> IO GType
boxedEnumType _ = IO GType
c_poppler_annot_type_get_type

-- Enum AnnotTextState
-- | /No description available in the introspection data./
data AnnotTextState = 
      AnnotTextStateMarked
    -- ^ /No description available in the introspection data./
    | AnnotTextStateUnmarked
    -- ^ /No description available in the introspection data./
    | AnnotTextStateAccepted
    -- ^ /No description available in the introspection data./
    | AnnotTextStateRejected
    -- ^ /No description available in the introspection data./
    | AnnotTextStateCancelled
    -- ^ /No description available in the introspection data./
    | AnnotTextStateCompleted
    -- ^ /No description available in the introspection data./
    | AnnotTextStateNone
    -- ^ /No description available in the introspection data./
    | AnnotTextStateUnknown
    -- ^ /No description available in the introspection data./
    | AnotherAnnotTextState Int
    -- ^ Catch-all for unknown values
    deriving (Int -> AnnotTextState -> ShowS
[AnnotTextState] -> ShowS
AnnotTextState -> String
(Int -> AnnotTextState -> ShowS)
-> (AnnotTextState -> String)
-> ([AnnotTextState] -> ShowS)
-> Show AnnotTextState
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AnnotTextState] -> ShowS
$cshowList :: [AnnotTextState] -> ShowS
show :: AnnotTextState -> String
$cshow :: AnnotTextState -> String
showsPrec :: Int -> AnnotTextState -> ShowS
$cshowsPrec :: Int -> AnnotTextState -> ShowS
Show, AnnotTextState -> AnnotTextState -> Bool
(AnnotTextState -> AnnotTextState -> Bool)
-> (AnnotTextState -> AnnotTextState -> Bool) -> Eq AnnotTextState
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AnnotTextState -> AnnotTextState -> Bool
$c/= :: AnnotTextState -> AnnotTextState -> Bool
== :: AnnotTextState -> AnnotTextState -> Bool
$c== :: AnnotTextState -> AnnotTextState -> Bool
Eq)

instance P.Enum AnnotTextState where
    fromEnum :: AnnotTextState -> Int
fromEnum AnnotTextStateMarked = 0
    fromEnum AnnotTextStateUnmarked = 1
    fromEnum AnnotTextStateAccepted = 2
    fromEnum AnnotTextStateRejected = 3
    fromEnum AnnotTextStateCancelled = 4
    fromEnum AnnotTextStateCompleted = 5
    fromEnum AnnotTextStateNone = 6
    fromEnum AnnotTextStateUnknown = 7
    fromEnum (AnotherAnnotTextState k :: Int
k) = Int
k

    toEnum :: Int -> AnnotTextState
toEnum 0 = AnnotTextState
AnnotTextStateMarked
    toEnum 1 = AnnotTextState
AnnotTextStateUnmarked
    toEnum 2 = AnnotTextState
AnnotTextStateAccepted
    toEnum 3 = AnnotTextState
AnnotTextStateRejected
    toEnum 4 = AnnotTextState
AnnotTextStateCancelled
    toEnum 5 = AnnotTextState
AnnotTextStateCompleted
    toEnum 6 = AnnotTextState
AnnotTextStateNone
    toEnum 7 = AnnotTextState
AnnotTextStateUnknown
    toEnum k :: Int
k = Int -> AnnotTextState
AnotherAnnotTextState Int
k

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

foreign import ccall "poppler_annot_text_state_get_type" c_poppler_annot_text_state_get_type :: 
    IO GType

instance BoxedEnum AnnotTextState where
    boxedEnumType :: AnnotTextState -> IO GType
boxedEnumType _ = IO GType
c_poppler_annot_text_state_get_type

-- Enum AnnotMarkupReplyType
-- | /No description available in the introspection data./
data AnnotMarkupReplyType = 
      AnnotMarkupReplyTypeR
    -- ^ /No description available in the introspection data./
    | AnnotMarkupReplyTypeGroup
    -- ^ /No description available in the introspection data./
    | AnotherAnnotMarkupReplyType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> AnnotMarkupReplyType -> ShowS
[AnnotMarkupReplyType] -> ShowS
AnnotMarkupReplyType -> String
(Int -> AnnotMarkupReplyType -> ShowS)
-> (AnnotMarkupReplyType -> String)
-> ([AnnotMarkupReplyType] -> ShowS)
-> Show AnnotMarkupReplyType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AnnotMarkupReplyType] -> ShowS
$cshowList :: [AnnotMarkupReplyType] -> ShowS
show :: AnnotMarkupReplyType -> String
$cshow :: AnnotMarkupReplyType -> String
showsPrec :: Int -> AnnotMarkupReplyType -> ShowS
$cshowsPrec :: Int -> AnnotMarkupReplyType -> ShowS
Show, AnnotMarkupReplyType -> AnnotMarkupReplyType -> Bool
(AnnotMarkupReplyType -> AnnotMarkupReplyType -> Bool)
-> (AnnotMarkupReplyType -> AnnotMarkupReplyType -> Bool)
-> Eq AnnotMarkupReplyType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AnnotMarkupReplyType -> AnnotMarkupReplyType -> Bool
$c/= :: AnnotMarkupReplyType -> AnnotMarkupReplyType -> Bool
== :: AnnotMarkupReplyType -> AnnotMarkupReplyType -> Bool
$c== :: AnnotMarkupReplyType -> AnnotMarkupReplyType -> Bool
Eq)

instance P.Enum AnnotMarkupReplyType where
    fromEnum :: AnnotMarkupReplyType -> Int
fromEnum AnnotMarkupReplyTypeR = 0
    fromEnum AnnotMarkupReplyTypeGroup = 1
    fromEnum (AnotherAnnotMarkupReplyType k :: Int
k) = Int
k

    toEnum :: Int -> AnnotMarkupReplyType
toEnum 0 = AnnotMarkupReplyType
AnnotMarkupReplyTypeR
    toEnum 1 = AnnotMarkupReplyType
AnnotMarkupReplyTypeGroup
    toEnum k :: Int
k = Int -> AnnotMarkupReplyType
AnotherAnnotMarkupReplyType Int
k

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

foreign import ccall "poppler_annot_markup_reply_type_get_type" c_poppler_annot_markup_reply_type_get_type :: 
    IO GType

instance BoxedEnum AnnotMarkupReplyType where
    boxedEnumType :: AnnotMarkupReplyType -> IO GType
boxedEnumType _ = IO GType
c_poppler_annot_markup_reply_type_get_type

-- Enum AnnotFreeTextQuadding
-- | /No description available in the introspection data./
data AnnotFreeTextQuadding = 
      AnnotFreeTextQuaddingLeftJustified
    -- ^ /No description available in the introspection data./
    | AnnotFreeTextQuaddingCentered
    -- ^ /No description available in the introspection data./
    | AnnotFreeTextQuaddingRightJustified
    -- ^ /No description available in the introspection data./
    | AnotherAnnotFreeTextQuadding Int
    -- ^ Catch-all for unknown values
    deriving (Int -> AnnotFreeTextQuadding -> ShowS
[AnnotFreeTextQuadding] -> ShowS
AnnotFreeTextQuadding -> String
(Int -> AnnotFreeTextQuadding -> ShowS)
-> (AnnotFreeTextQuadding -> String)
-> ([AnnotFreeTextQuadding] -> ShowS)
-> Show AnnotFreeTextQuadding
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AnnotFreeTextQuadding] -> ShowS
$cshowList :: [AnnotFreeTextQuadding] -> ShowS
show :: AnnotFreeTextQuadding -> String
$cshow :: AnnotFreeTextQuadding -> String
showsPrec :: Int -> AnnotFreeTextQuadding -> ShowS
$cshowsPrec :: Int -> AnnotFreeTextQuadding -> ShowS
Show, AnnotFreeTextQuadding -> AnnotFreeTextQuadding -> Bool
(AnnotFreeTextQuadding -> AnnotFreeTextQuadding -> Bool)
-> (AnnotFreeTextQuadding -> AnnotFreeTextQuadding -> Bool)
-> Eq AnnotFreeTextQuadding
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AnnotFreeTextQuadding -> AnnotFreeTextQuadding -> Bool
$c/= :: AnnotFreeTextQuadding -> AnnotFreeTextQuadding -> Bool
== :: AnnotFreeTextQuadding -> AnnotFreeTextQuadding -> Bool
$c== :: AnnotFreeTextQuadding -> AnnotFreeTextQuadding -> Bool
Eq)

instance P.Enum AnnotFreeTextQuadding where
    fromEnum :: AnnotFreeTextQuadding -> Int
fromEnum AnnotFreeTextQuaddingLeftJustified = 0
    fromEnum AnnotFreeTextQuaddingCentered = 1
    fromEnum AnnotFreeTextQuaddingRightJustified = 2
    fromEnum (AnotherAnnotFreeTextQuadding k :: Int
k) = Int
k

    toEnum :: Int -> AnnotFreeTextQuadding
toEnum 0 = AnnotFreeTextQuadding
AnnotFreeTextQuaddingLeftJustified
    toEnum 1 = AnnotFreeTextQuadding
AnnotFreeTextQuaddingCentered
    toEnum 2 = AnnotFreeTextQuadding
AnnotFreeTextQuaddingRightJustified
    toEnum k :: Int
k = Int -> AnnotFreeTextQuadding
AnotherAnnotFreeTextQuadding Int
k

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

foreign import ccall "poppler_annot_free_text_quadding_get_type" c_poppler_annot_free_text_quadding_get_type :: 
    IO GType

instance BoxedEnum AnnotFreeTextQuadding where
    boxedEnumType :: AnnotFreeTextQuadding -> IO GType
boxedEnumType _ = IO GType
c_poppler_annot_free_text_quadding_get_type

-- Enum AnnotExternalDataType
-- | /No description available in the introspection data./
data AnnotExternalDataType = 
      AnnotExternalDataType3d
    -- ^ /No description available in the introspection data./
    | AnnotExternalDataTypeUnknown
    -- ^ /No description available in the introspection data./
    | AnotherAnnotExternalDataType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> AnnotExternalDataType -> ShowS
[AnnotExternalDataType] -> ShowS
AnnotExternalDataType -> String
(Int -> AnnotExternalDataType -> ShowS)
-> (AnnotExternalDataType -> String)
-> ([AnnotExternalDataType] -> ShowS)
-> Show AnnotExternalDataType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AnnotExternalDataType] -> ShowS
$cshowList :: [AnnotExternalDataType] -> ShowS
show :: AnnotExternalDataType -> String
$cshow :: AnnotExternalDataType -> String
showsPrec :: Int -> AnnotExternalDataType -> ShowS
$cshowsPrec :: Int -> AnnotExternalDataType -> ShowS
Show, AnnotExternalDataType -> AnnotExternalDataType -> Bool
(AnnotExternalDataType -> AnnotExternalDataType -> Bool)
-> (AnnotExternalDataType -> AnnotExternalDataType -> Bool)
-> Eq AnnotExternalDataType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AnnotExternalDataType -> AnnotExternalDataType -> Bool
$c/= :: AnnotExternalDataType -> AnnotExternalDataType -> Bool
== :: AnnotExternalDataType -> AnnotExternalDataType -> Bool
$c== :: AnnotExternalDataType -> AnnotExternalDataType -> Bool
Eq)

instance P.Enum AnnotExternalDataType where
    fromEnum :: AnnotExternalDataType -> Int
fromEnum AnnotExternalDataType3d = 0
    fromEnum AnnotExternalDataTypeUnknown = 1
    fromEnum (AnotherAnnotExternalDataType k :: Int
k) = Int
k

    toEnum :: Int -> AnnotExternalDataType
toEnum 0 = AnnotExternalDataType
AnnotExternalDataType3d
    toEnum 1 = AnnotExternalDataType
AnnotExternalDataTypeUnknown
    toEnum k :: Int
k = Int -> AnnotExternalDataType
AnotherAnnotExternalDataType Int
k

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

foreign import ccall "poppler_annot_external_data_type_get_type" c_poppler_annot_external_data_type_get_type :: 
    IO GType

instance BoxedEnum AnnotExternalDataType where
    boxedEnumType :: AnnotExternalDataType -> IO GType
boxedEnumType _ = IO GType
c_poppler_annot_external_data_type_get_type

-- Enum AdditionalActionType
-- | Form field additional action types to be passed to /@popplerFormFieldGetAdditionalAction@/
-- 
-- /Since: 0.72/
data AdditionalActionType = 
      AdditionalActionTypeFieldModified
    -- ^ The action to be performed when the user modifies the field.
    | AdditionalActionTypeFormatField
    -- ^ The action to be performed before the field is formatted to
    -- display its value.
    | AdditionalActionTypeValidateField
    -- ^ The action to be performed when the field value changes.
    | AdditionalActionTypeCalculateField
    -- ^ The action to be performed when the field needs to be
    -- recalculated.
    | AnotherAdditionalActionType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> AdditionalActionType -> ShowS
[AdditionalActionType] -> ShowS
AdditionalActionType -> String
(Int -> AdditionalActionType -> ShowS)
-> (AdditionalActionType -> String)
-> ([AdditionalActionType] -> ShowS)
-> Show AdditionalActionType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AdditionalActionType] -> ShowS
$cshowList :: [AdditionalActionType] -> ShowS
show :: AdditionalActionType -> String
$cshow :: AdditionalActionType -> String
showsPrec :: Int -> AdditionalActionType -> ShowS
$cshowsPrec :: Int -> AdditionalActionType -> ShowS
Show, AdditionalActionType -> AdditionalActionType -> Bool
(AdditionalActionType -> AdditionalActionType -> Bool)
-> (AdditionalActionType -> AdditionalActionType -> Bool)
-> Eq AdditionalActionType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: AdditionalActionType -> AdditionalActionType -> Bool
$c/= :: AdditionalActionType -> AdditionalActionType -> Bool
== :: AdditionalActionType -> AdditionalActionType -> Bool
$c== :: AdditionalActionType -> AdditionalActionType -> Bool
Eq)

instance P.Enum AdditionalActionType where
    fromEnum :: AdditionalActionType -> Int
fromEnum AdditionalActionTypeFieldModified = 0
    fromEnum AdditionalActionTypeFormatField = 1
    fromEnum AdditionalActionTypeValidateField = 2
    fromEnum AdditionalActionTypeCalculateField = 3
    fromEnum (AnotherAdditionalActionType k :: Int
k) = Int
k

    toEnum :: Int -> AdditionalActionType
toEnum 0 = AdditionalActionType
AdditionalActionTypeFieldModified
    toEnum 1 = AdditionalActionType
AdditionalActionTypeFormatField
    toEnum 2 = AdditionalActionType
AdditionalActionTypeValidateField
    toEnum 3 = AdditionalActionType
AdditionalActionTypeCalculateField
    toEnum k :: Int
k = Int -> AdditionalActionType
AnotherAdditionalActionType Int
k

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

foreign import ccall "poppler_additional_action_type_get_type" c_poppler_additional_action_type_get_type :: 
    IO GType

instance BoxedEnum AdditionalActionType where
    boxedEnumType :: AdditionalActionType -> IO GType
boxedEnumType _ = IO GType
c_poppler_additional_action_type_get_type

-- Enum ActionType
-- | Action types
data ActionType = 
      ActionTypeUnknown
    -- ^ unknown action
    | ActionTypeNone
    -- ^ no action specified
    | ActionTypeGotoDest
    -- ^ go to destination
    | ActionTypeGotoRemote
    -- ^ go to destination in another document
    | ActionTypeLaunch
    -- ^ launch app (or open document
    | ActionTypeUri
    -- ^ URI
    | ActionTypeNamed
    -- ^ predefined action
    | ActionTypeMovie
    -- ^ play movies. Since 0.14
    | ActionTypeRendition
    -- ^ play multimedia content. Since 0.14
    | ActionTypeOcgState
    -- ^ state of layer. Since 0.14
    | ActionTypeJavascript
    -- ^ Javascript. Since 0.18
    | AnotherActionType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ActionType -> ShowS
[ActionType] -> ShowS
ActionType -> String
(Int -> ActionType -> ShowS)
-> (ActionType -> String)
-> ([ActionType] -> ShowS)
-> Show ActionType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ActionType] -> ShowS
$cshowList :: [ActionType] -> ShowS
show :: ActionType -> String
$cshow :: ActionType -> String
showsPrec :: Int -> ActionType -> ShowS
$cshowsPrec :: Int -> ActionType -> ShowS
Show, ActionType -> ActionType -> Bool
(ActionType -> ActionType -> Bool)
-> (ActionType -> ActionType -> Bool) -> Eq ActionType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ActionType -> ActionType -> Bool
$c/= :: ActionType -> ActionType -> Bool
== :: ActionType -> ActionType -> Bool
$c== :: ActionType -> ActionType -> Bool
Eq)

instance P.Enum ActionType where
    fromEnum :: ActionType -> Int
fromEnum ActionTypeUnknown = 0
    fromEnum ActionTypeNone = 1
    fromEnum ActionTypeGotoDest = 2
    fromEnum ActionTypeGotoRemote = 3
    fromEnum ActionTypeLaunch = 4
    fromEnum ActionTypeUri = 5
    fromEnum ActionTypeNamed = 6
    fromEnum ActionTypeMovie = 7
    fromEnum ActionTypeRendition = 8
    fromEnum ActionTypeOcgState = 9
    fromEnum ActionTypeJavascript = 10
    fromEnum (AnotherActionType k :: Int
k) = Int
k

    toEnum :: Int -> ActionType
toEnum 0 = ActionType
ActionTypeUnknown
    toEnum 1 = ActionType
ActionTypeNone
    toEnum 2 = ActionType
ActionTypeGotoDest
    toEnum 3 = ActionType
ActionTypeGotoRemote
    toEnum 4 = ActionType
ActionTypeLaunch
    toEnum 5 = ActionType
ActionTypeUri
    toEnum 6 = ActionType
ActionTypeNamed
    toEnum 7 = ActionType
ActionTypeMovie
    toEnum 8 = ActionType
ActionTypeRendition
    toEnum 9 = ActionType
ActionTypeOcgState
    toEnum 10 = ActionType
ActionTypeJavascript
    toEnum k :: Int
k = Int -> ActionType
AnotherActionType Int
k

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

foreign import ccall "poppler_action_type_get_type" c_poppler_action_type_get_type :: 
    IO GType

instance BoxedEnum ActionType where
    boxedEnumType :: ActionType -> IO GType
boxedEnumType _ = IO GType
c_poppler_action_type_get_type

-- Enum ActionMovieOperation
-- | Movie operations
-- 
-- /Since: 0.14/
data ActionMovieOperation = 
      ActionMovieOperationPlay
    -- ^ play movie
    | ActionMovieOperationPause
    -- ^ pause playing movie
    | ActionMovieOperationResume
    -- ^ resume paused movie
    | ActionMovieOperationStop
    -- ^ stop playing movie
    | AnotherActionMovieOperation Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ActionMovieOperation -> ShowS
[ActionMovieOperation] -> ShowS
ActionMovieOperation -> String
(Int -> ActionMovieOperation -> ShowS)
-> (ActionMovieOperation -> String)
-> ([ActionMovieOperation] -> ShowS)
-> Show ActionMovieOperation
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ActionMovieOperation] -> ShowS
$cshowList :: [ActionMovieOperation] -> ShowS
show :: ActionMovieOperation -> String
$cshow :: ActionMovieOperation -> String
showsPrec :: Int -> ActionMovieOperation -> ShowS
$cshowsPrec :: Int -> ActionMovieOperation -> ShowS
Show, ActionMovieOperation -> ActionMovieOperation -> Bool
(ActionMovieOperation -> ActionMovieOperation -> Bool)
-> (ActionMovieOperation -> ActionMovieOperation -> Bool)
-> Eq ActionMovieOperation
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ActionMovieOperation -> ActionMovieOperation -> Bool
$c/= :: ActionMovieOperation -> ActionMovieOperation -> Bool
== :: ActionMovieOperation -> ActionMovieOperation -> Bool
$c== :: ActionMovieOperation -> ActionMovieOperation -> Bool
Eq)

instance P.Enum ActionMovieOperation where
    fromEnum :: ActionMovieOperation -> Int
fromEnum ActionMovieOperationPlay = 0
    fromEnum ActionMovieOperationPause = 1
    fromEnum ActionMovieOperationResume = 2
    fromEnum ActionMovieOperationStop = 3
    fromEnum (AnotherActionMovieOperation k :: Int
k) = Int
k

    toEnum :: Int -> ActionMovieOperation
toEnum 0 = ActionMovieOperation
ActionMovieOperationPlay
    toEnum 1 = ActionMovieOperation
ActionMovieOperationPause
    toEnum 2 = ActionMovieOperation
ActionMovieOperationResume
    toEnum 3 = ActionMovieOperation
ActionMovieOperationStop
    toEnum k :: Int
k = Int -> ActionMovieOperation
AnotherActionMovieOperation Int
k

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

foreign import ccall "poppler_action_movie_operation_get_type" c_poppler_action_movie_operation_get_type :: 
    IO GType

instance BoxedEnum ActionMovieOperation where
    boxedEnumType :: ActionMovieOperation -> IO GType
boxedEnumType _ = IO GType
c_poppler_action_movie_operation_get_type

-- Enum ActionLayerAction
-- | Layer actions
-- 
-- /Since: 0.14/
data ActionLayerAction = 
      ActionLayerActionOn
    -- ^ set layer visibility on
    | ActionLayerActionOff
    -- ^ set layer visibility off
    | ActionLayerActionToggle
    -- ^ reverse the layer visibility state
    | AnotherActionLayerAction Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ActionLayerAction -> ShowS
[ActionLayerAction] -> ShowS
ActionLayerAction -> String
(Int -> ActionLayerAction -> ShowS)
-> (ActionLayerAction -> String)
-> ([ActionLayerAction] -> ShowS)
-> Show ActionLayerAction
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ActionLayerAction] -> ShowS
$cshowList :: [ActionLayerAction] -> ShowS
show :: ActionLayerAction -> String
$cshow :: ActionLayerAction -> String
showsPrec :: Int -> ActionLayerAction -> ShowS
$cshowsPrec :: Int -> ActionLayerAction -> ShowS
Show, ActionLayerAction -> ActionLayerAction -> Bool
(ActionLayerAction -> ActionLayerAction -> Bool)
-> (ActionLayerAction -> ActionLayerAction -> Bool)
-> Eq ActionLayerAction
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ActionLayerAction -> ActionLayerAction -> Bool
$c/= :: ActionLayerAction -> ActionLayerAction -> Bool
== :: ActionLayerAction -> ActionLayerAction -> Bool
$c== :: ActionLayerAction -> ActionLayerAction -> Bool
Eq)

instance P.Enum ActionLayerAction where
    fromEnum :: ActionLayerAction -> Int
fromEnum ActionLayerActionOn = 0
    fromEnum ActionLayerActionOff = 1
    fromEnum ActionLayerActionToggle = 2
    fromEnum (AnotherActionLayerAction k :: Int
k) = Int
k

    toEnum :: Int -> ActionLayerAction
toEnum 0 = ActionLayerAction
ActionLayerActionOn
    toEnum 1 = ActionLayerAction
ActionLayerActionOff
    toEnum 2 = ActionLayerAction
ActionLayerActionToggle
    toEnum k :: Int
k = Int -> ActionLayerAction
AnotherActionLayerAction Int
k

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

foreign import ccall "poppler_action_layer_action_get_type" c_poppler_action_layer_action_get_type :: 
    IO GType

instance BoxedEnum ActionLayerAction where
    boxedEnumType :: ActionLayerAction -> IO GType
boxedEnumType _ = IO GType
c_poppler_action_layer_action_get_type