-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- 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.Vips.Enums
    ( 

 -- * Enumerations


-- ** Access #enum:Access#

    Access(..)                              ,


-- ** Align #enum:Align#

    Align(..)                               ,


-- ** Angle #enum:Angle#

    Angle(..)                               ,


-- ** Angle45 #enum:Angle45#

    Angle45(..)                             ,


-- ** BandFormat #enum:BandFormat#

    BandFormat(..)                          ,


-- ** BlendMode #enum:BlendMode#

    BlendMode(..)                           ,


-- ** Coding #enum:Coding#

    Coding(..)                              ,


-- ** Combine #enum:Combine#

    Combine(..)                             ,


-- ** CombineMode #enum:CombineMode#

    CombineMode(..)                         ,


-- ** CompassDirection #enum:CompassDirection#

    CompassDirection(..)                    ,


-- ** DemandStyle #enum:DemandStyle#

    DemandStyle(..)                         ,


-- ** Direction #enum:Direction#

    Direction(..)                           ,


-- ** Extend #enum:Extend#

    Extend(..)                              ,


-- ** FailOn #enum:FailOn#

    FailOn(..)                              ,


-- ** ForeignDzContainer #enum:ForeignDzContainer#

    ForeignDzContainer(..)                  ,


-- ** ForeignDzDepth #enum:ForeignDzDepth#

    ForeignDzDepth(..)                      ,


-- ** ForeignDzLayout #enum:ForeignDzLayout#

    ForeignDzLayout(..)                     ,


-- ** ForeignHeifCompression #enum:ForeignHeifCompression#

    ForeignHeifCompression(..)              ,


-- ** ForeignJpegSubsample #enum:ForeignJpegSubsample#

    ForeignJpegSubsample(..)                ,


-- ** ForeignPpmFormat #enum:ForeignPpmFormat#

    ForeignPpmFormat(..)                    ,


-- ** ForeignSubsample #enum:ForeignSubsample#

    ForeignSubsample(..)                    ,


-- ** ForeignTiffCompression #enum:ForeignTiffCompression#

    ForeignTiffCompression(..)              ,


-- ** ForeignTiffPredictor #enum:ForeignTiffPredictor#

    ForeignTiffPredictor(..)                ,


-- ** ForeignTiffResunit #enum:ForeignTiffResunit#

    ForeignTiffResunit(..)                  ,


-- ** ForeignWebpPreset #enum:ForeignWebpPreset#

    ForeignWebpPreset(..)                   ,


-- ** ImageType #enum:ImageType#

    ImageType(..)                           ,


-- ** Intent #enum:Intent#

    Intent(..)                              ,


-- ** Interesting #enum:Interesting#

    Interesting(..)                         ,


-- ** Interpretation #enum:Interpretation#

    Interpretation(..)                      ,


-- ** Kernel #enum:Kernel#

    Kernel(..)                              ,


-- ** OperationBoolean #enum:OperationBoolean#

    OperationBoolean(..)                    ,


-- ** OperationComplex #enum:OperationComplex#

    OperationComplex(..)                    ,


-- ** OperationComplex2 #enum:OperationComplex2#

    OperationComplex2(..)                   ,


-- ** OperationComplexget #enum:OperationComplexget#

    OperationComplexget(..)                 ,


-- ** OperationMath #enum:OperationMath#

    OperationMath(..)                       ,


-- ** OperationMath2 #enum:OperationMath2#

    OperationMath2(..)                      ,


-- ** OperationMorphology #enum:OperationMorphology#

    OperationMorphology(..)                 ,


-- ** OperationRelational #enum:OperationRelational#

    OperationRelational(..)                 ,


-- ** OperationRound #enum:OperationRound#

    OperationRound(..)                      ,


-- ** PCS #enum:PCS#

    PCS(..)                                 ,


-- ** Precision #enum:Precision#

    Precision(..)                           ,


-- ** RegionShrink #enum:RegionShrink#

    RegionShrink(..)                        ,


-- ** Saveable #enum:Saveable#

    Saveable(..)                            ,


-- ** Size #enum:Size#

    Size(..)                                ,


-- ** Token #enum:Token#

    Token(..)                               ,




    ) where

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

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R


-- Enum Token
-- | /No description available in the introspection data./
data Token = 
      TokenLeft
    -- ^ /No description available in the introspection data./
    | TokenRight
    -- ^ /No description available in the introspection data./
    | TokenString
    -- ^ /No description available in the introspection data./
    | TokenEquals
    -- ^ /No description available in the introspection data./
    | TokenComma
    -- ^ /No description available in the introspection data./
    | AnotherToken Int
    -- ^ Catch-all for unknown values
    deriving (Int -> Token -> ShowS
[Token] -> ShowS
Token -> String
(Int -> Token -> ShowS)
-> (Token -> String) -> ([Token] -> ShowS) -> Show Token
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Token -> ShowS
showsPrec :: Int -> Token -> ShowS
$cshow :: Token -> String
show :: Token -> String
$cshowList :: [Token] -> ShowS
showList :: [Token] -> ShowS
Show, Token -> Token -> Bool
(Token -> Token -> Bool) -> (Token -> Token -> Bool) -> Eq Token
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Token -> Token -> Bool
== :: Token -> Token -> Bool
$c/= :: Token -> Token -> Bool
/= :: Token -> Token -> Bool
Eq)

instance P.Enum Token where
    fromEnum :: Token -> Int
fromEnum Token
TokenLeft = Int
1
    fromEnum Token
TokenRight = Int
2
    fromEnum Token
TokenString = Int
3
    fromEnum Token
TokenEquals = Int
4
    fromEnum Token
TokenComma = Int
5
    fromEnum (AnotherToken Int
k) = Int
k

    toEnum :: Int -> Token
toEnum Int
1 = Token
TokenLeft
    toEnum Int
2 = Token
TokenRight
    toEnum Int
3 = Token
TokenString
    toEnum Int
4 = Token
TokenEquals
    toEnum Int
5 = Token
TokenComma
    toEnum Int
k = Int -> Token
AnotherToken Int
k

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

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

foreign import ccall "vips_token_get_type" c_vips_token_get_type :: 
    IO GType

instance B.Types.TypedObject Token where
    glibType :: IO GType
glibType = IO GType
c_vips_token_get_type

instance B.Types.BoxedEnum Token

-- Enum Size
-- | Controls whether an operation should upsize, downsize, both up and
-- downsize, or force a size.
-- 
-- See also: @/vips_thumbnail()/@.
data Size = 
      SizeBoth
    -- ^ size both up and down
    | SizeUp
    -- ^ only upsize
    | SizeDown
    -- ^ only downsize
    | SizeForce
    -- ^ force size, that is, break aspect ratio
    | SizeLast
    -- ^ /No description available in the introspection data./
    | AnotherSize Int
    -- ^ Catch-all for unknown values
    deriving (Int -> Size -> ShowS
[Size] -> ShowS
Size -> String
(Int -> Size -> ShowS)
-> (Size -> String) -> ([Size] -> ShowS) -> Show Size
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Size -> ShowS
showsPrec :: Int -> Size -> ShowS
$cshow :: Size -> String
show :: Size -> String
$cshowList :: [Size] -> ShowS
showList :: [Size] -> ShowS
Show, Size -> Size -> Bool
(Size -> Size -> Bool) -> (Size -> Size -> Bool) -> Eq Size
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Size -> Size -> Bool
== :: Size -> Size -> Bool
$c/= :: Size -> Size -> Bool
/= :: Size -> Size -> Bool
Eq)

instance P.Enum Size where
    fromEnum :: Size -> Int
fromEnum Size
SizeBoth = Int
0
    fromEnum Size
SizeUp = Int
1
    fromEnum Size
SizeDown = Int
2
    fromEnum Size
SizeForce = Int
3
    fromEnum Size
SizeLast = Int
4
    fromEnum (AnotherSize Int
k) = Int
k

    toEnum :: Int -> Size
toEnum Int
0 = Size
SizeBoth
    toEnum Int
1 = Size
SizeUp
    toEnum Int
2 = Size
SizeDown
    toEnum Int
3 = Size
SizeForce
    toEnum Int
4 = Size
SizeLast
    toEnum Int
k = Int -> Size
AnotherSize Int
k

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

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

foreign import ccall "vips_size_get_type" c_vips_size_get_type :: 
    IO GType

instance B.Types.TypedObject Size where
    glibType :: IO GType
glibType = IO GType
c_vips_size_get_type

instance B.Types.BoxedEnum Size

-- Enum Saveable
-- | See also: t'GI.Vips.Objects.ForeignSave.ForeignSave'.
data Saveable = 
      SaveableMono
    -- ^ 1 band (eg. CSV)
    | SaveableRgb
    -- ^ 1 or 3 bands (eg. PPM)
    | SaveableRgba
    -- ^ 1, 2, 3 or 4 bands (eg. PNG)
    | SaveableRgbaOnly
    -- ^ 3 or 4 bands (eg. WEBP)
    | SaveableRgbCmyk
    -- ^ 1, 3 or 4 bands (eg. JPEG)
    | SaveableAny
    -- ^ any number of bands (eg. TIFF)
    | SaveableLast
    -- ^ /No description available in the introspection data./
    | AnotherSaveable Int
    -- ^ Catch-all for unknown values
    deriving (Int -> Saveable -> ShowS
[Saveable] -> ShowS
Saveable -> String
(Int -> Saveable -> ShowS)
-> (Saveable -> String) -> ([Saveable] -> ShowS) -> Show Saveable
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Saveable -> ShowS
showsPrec :: Int -> Saveable -> ShowS
$cshow :: Saveable -> String
show :: Saveable -> String
$cshowList :: [Saveable] -> ShowS
showList :: [Saveable] -> ShowS
Show, Saveable -> Saveable -> Bool
(Saveable -> Saveable -> Bool)
-> (Saveable -> Saveable -> Bool) -> Eq Saveable
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Saveable -> Saveable -> Bool
== :: Saveable -> Saveable -> Bool
$c/= :: Saveable -> Saveable -> Bool
/= :: Saveable -> Saveable -> Bool
Eq)

instance P.Enum Saveable where
    fromEnum :: Saveable -> Int
fromEnum Saveable
SaveableMono = Int
0
    fromEnum Saveable
SaveableRgb = Int
1
    fromEnum Saveable
SaveableRgba = Int
2
    fromEnum Saveable
SaveableRgbaOnly = Int
3
    fromEnum Saveable
SaveableRgbCmyk = Int
4
    fromEnum Saveable
SaveableAny = Int
5
    fromEnum Saveable
SaveableLast = Int
6
    fromEnum (AnotherSaveable Int
k) = Int
k

    toEnum :: Int -> Saveable
toEnum Int
0 = Saveable
SaveableMono
    toEnum Int
1 = Saveable
SaveableRgb
    toEnum Int
2 = Saveable
SaveableRgba
    toEnum Int
3 = Saveable
SaveableRgbaOnly
    toEnum Int
4 = Saveable
SaveableRgbCmyk
    toEnum Int
5 = Saveable
SaveableAny
    toEnum Int
6 = Saveable
SaveableLast
    toEnum Int
k = Int -> Saveable
AnotherSaveable Int
k

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

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

foreign import ccall "vips_saveable_get_type" c_vips_saveable_get_type :: 
    IO GType

instance B.Types.TypedObject Saveable where
    glibType :: IO GType
glibType = IO GType
c_vips_saveable_get_type

instance B.Types.BoxedEnum Saveable

-- Enum RegionShrink
-- | How to calculate the output pixels when shrinking a 2x2 region.
data RegionShrink = 
      RegionShrinkMean
    -- ^ use the average
    | RegionShrinkMedian
    -- ^ use the median
    | RegionShrinkMode
    -- ^ use the mode
    | RegionShrinkMax
    -- ^ use the maximum
    | RegionShrinkMin
    -- ^ use the minimum
    | RegionShrinkNearest
    -- ^ use the top-left pixel
    | RegionShrinkLast
    -- ^ /No description available in the introspection data./
    | AnotherRegionShrink Int
    -- ^ Catch-all for unknown values
    deriving (Int -> RegionShrink -> ShowS
[RegionShrink] -> ShowS
RegionShrink -> String
(Int -> RegionShrink -> ShowS)
-> (RegionShrink -> String)
-> ([RegionShrink] -> ShowS)
-> Show RegionShrink
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RegionShrink -> ShowS
showsPrec :: Int -> RegionShrink -> ShowS
$cshow :: RegionShrink -> String
show :: RegionShrink -> String
$cshowList :: [RegionShrink] -> ShowS
showList :: [RegionShrink] -> ShowS
Show, RegionShrink -> RegionShrink -> Bool
(RegionShrink -> RegionShrink -> Bool)
-> (RegionShrink -> RegionShrink -> Bool) -> Eq RegionShrink
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RegionShrink -> RegionShrink -> Bool
== :: RegionShrink -> RegionShrink -> Bool
$c/= :: RegionShrink -> RegionShrink -> Bool
/= :: RegionShrink -> RegionShrink -> Bool
Eq)

instance P.Enum RegionShrink where
    fromEnum :: RegionShrink -> Int
fromEnum RegionShrink
RegionShrinkMean = Int
0
    fromEnum RegionShrink
RegionShrinkMedian = Int
1
    fromEnum RegionShrink
RegionShrinkMode = Int
2
    fromEnum RegionShrink
RegionShrinkMax = Int
3
    fromEnum RegionShrink
RegionShrinkMin = Int
4
    fromEnum RegionShrink
RegionShrinkNearest = Int
5
    fromEnum RegionShrink
RegionShrinkLast = Int
6
    fromEnum (AnotherRegionShrink Int
k) = Int
k

    toEnum :: Int -> RegionShrink
toEnum Int
0 = RegionShrink
RegionShrinkMean
    toEnum Int
1 = RegionShrink
RegionShrinkMedian
    toEnum Int
2 = RegionShrink
RegionShrinkMode
    toEnum Int
3 = RegionShrink
RegionShrinkMax
    toEnum Int
4 = RegionShrink
RegionShrinkMin
    toEnum Int
5 = RegionShrink
RegionShrinkNearest
    toEnum Int
6 = RegionShrink
RegionShrinkLast
    toEnum Int
k = Int -> RegionShrink
AnotherRegionShrink Int
k

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

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

foreign import ccall "vips_region_shrink_get_type" c_vips_region_shrink_get_type :: 
    IO GType

instance B.Types.TypedObject RegionShrink where
    glibType :: IO GType
glibType = IO GType
c_vips_region_shrink_get_type

instance B.Types.BoxedEnum RegionShrink

-- Enum Precision
-- | How accurate an operation should be.
data Precision = 
      PrecisionInteger
    -- ^ int everywhere
    | PrecisionFloat
    -- ^ float everywhere
    | PrecisionApproximate
    -- ^ approximate integer output
    | PrecisionLast
    -- ^ /No description available in the introspection data./
    | AnotherPrecision Int
    -- ^ Catch-all for unknown values
    deriving (Int -> Precision -> ShowS
[Precision] -> ShowS
Precision -> String
(Int -> Precision -> ShowS)
-> (Precision -> String)
-> ([Precision] -> ShowS)
-> Show Precision
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Precision -> ShowS
showsPrec :: Int -> Precision -> ShowS
$cshow :: Precision -> String
show :: Precision -> String
$cshowList :: [Precision] -> ShowS
showList :: [Precision] -> ShowS
Show, Precision -> Precision -> Bool
(Precision -> Precision -> Bool)
-> (Precision -> Precision -> Bool) -> Eq Precision
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Precision -> Precision -> Bool
== :: Precision -> Precision -> Bool
$c/= :: Precision -> Precision -> Bool
/= :: Precision -> Precision -> Bool
Eq)

instance P.Enum Precision where
    fromEnum :: Precision -> Int
fromEnum Precision
PrecisionInteger = Int
0
    fromEnum Precision
PrecisionFloat = Int
1
    fromEnum Precision
PrecisionApproximate = Int
2
    fromEnum Precision
PrecisionLast = Int
3
    fromEnum (AnotherPrecision Int
k) = Int
k

    toEnum :: Int -> Precision
toEnum Int
0 = Precision
PrecisionInteger
    toEnum Int
1 = Precision
PrecisionFloat
    toEnum Int
2 = Precision
PrecisionApproximate
    toEnum Int
3 = Precision
PrecisionLast
    toEnum Int
k = Int -> Precision
AnotherPrecision Int
k

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

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

foreign import ccall "vips_precision_get_type" c_vips_precision_get_type :: 
    IO GType

instance B.Types.TypedObject Precision where
    glibType :: IO GType
glibType = IO GType
c_vips_precision_get_type

instance B.Types.BoxedEnum Precision

-- Enum PCS
-- | Pick a Profile Connection Space for @/vips_icc_import()/@ and
-- @/vips_icc_export()/@. LAB is usually best, XYZ can be more convenient in some
-- cases.
data PCS = 
      PCSLab
    -- ^ use CIELAB D65 as the Profile Connection Space
    | PCSXyz
    -- ^ use XYZ as the Profile Connection Space
    | PCSLast
    -- ^ /No description available in the introspection data./
    | AnotherPCS Int
    -- ^ Catch-all for unknown values
    deriving (Int -> PCS -> ShowS
[PCS] -> ShowS
PCS -> String
(Int -> PCS -> ShowS)
-> (PCS -> String) -> ([PCS] -> ShowS) -> Show PCS
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PCS -> ShowS
showsPrec :: Int -> PCS -> ShowS
$cshow :: PCS -> String
show :: PCS -> String
$cshowList :: [PCS] -> ShowS
showList :: [PCS] -> ShowS
Show, PCS -> PCS -> Bool
(PCS -> PCS -> Bool) -> (PCS -> PCS -> Bool) -> Eq PCS
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PCS -> PCS -> Bool
== :: PCS -> PCS -> Bool
$c/= :: PCS -> PCS -> Bool
/= :: PCS -> PCS -> Bool
Eq)

instance P.Enum PCS where
    fromEnum :: PCS -> Int
fromEnum PCS
PCSLab = Int
0
    fromEnum PCS
PCSXyz = Int
1
    fromEnum PCS
PCSLast = Int
2
    fromEnum (AnotherPCS Int
k) = Int
k

    toEnum :: Int -> PCS
toEnum Int
0 = PCS
PCSLab
    toEnum Int
1 = PCS
PCSXyz
    toEnum Int
2 = PCS
PCSLast
    toEnum Int
k = Int -> PCS
AnotherPCS Int
k

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

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

foreign import ccall "vips_pcs_get_type" c_vips_pcs_get_type :: 
    IO GType

instance B.Types.TypedObject PCS where
    glibType :: IO GType
glibType = IO GType
c_vips_pcs_get_type

instance B.Types.BoxedEnum PCS

-- Enum OperationRound
-- | See also: @/vips_round()/@.
data OperationRound = 
      OperationRoundRint
    -- ^ round to nearest
    | OperationRoundCeil
    -- ^ the smallest integral value not less than
    | OperationRoundFloor
    -- ^ largest integral value not greater than
    | OperationRoundLast
    -- ^ /No description available in the introspection data./
    | AnotherOperationRound Int
    -- ^ Catch-all for unknown values
    deriving (Int -> OperationRound -> ShowS
[OperationRound] -> ShowS
OperationRound -> String
(Int -> OperationRound -> ShowS)
-> (OperationRound -> String)
-> ([OperationRound] -> ShowS)
-> Show OperationRound
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> OperationRound -> ShowS
showsPrec :: Int -> OperationRound -> ShowS
$cshow :: OperationRound -> String
show :: OperationRound -> String
$cshowList :: [OperationRound] -> ShowS
showList :: [OperationRound] -> ShowS
Show, OperationRound -> OperationRound -> Bool
(OperationRound -> OperationRound -> Bool)
-> (OperationRound -> OperationRound -> Bool) -> Eq OperationRound
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: OperationRound -> OperationRound -> Bool
== :: OperationRound -> OperationRound -> Bool
$c/= :: OperationRound -> OperationRound -> Bool
/= :: OperationRound -> OperationRound -> Bool
Eq)

instance P.Enum OperationRound where
    fromEnum :: OperationRound -> Int
fromEnum OperationRound
OperationRoundRint = Int
0
    fromEnum OperationRound
OperationRoundCeil = Int
1
    fromEnum OperationRound
OperationRoundFloor = Int
2
    fromEnum OperationRound
OperationRoundLast = Int
3
    fromEnum (AnotherOperationRound Int
k) = Int
k

    toEnum :: Int -> OperationRound
toEnum Int
0 = OperationRound
OperationRoundRint
    toEnum Int
1 = OperationRound
OperationRoundCeil
    toEnum Int
2 = OperationRound
OperationRoundFloor
    toEnum Int
3 = OperationRound
OperationRoundLast
    toEnum Int
k = Int -> OperationRound
AnotherOperationRound Int
k

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

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

foreign import ccall "vips_operation_round_get_type" c_vips_operation_round_get_type :: 
    IO GType

instance B.Types.TypedObject OperationRound where
    glibType :: IO GType
glibType = IO GType
c_vips_operation_round_get_type

instance B.Types.BoxedEnum OperationRound

-- Enum OperationRelational
-- | See also: @/vips_relational()/@.
data OperationRelational = 
      OperationRelationalEqual
    -- ^ ==
    | OperationRelationalNoteq
    -- ^ !=
    | OperationRelationalLess
    -- ^ \<
    | OperationRelationalLesseq
    -- ^ \<=
    | OperationRelationalMore
    -- ^ >
    | OperationRelationalMoreeq
    -- ^ >=
    | OperationRelationalLast
    -- ^ /No description available in the introspection data./
    | AnotherOperationRelational Int
    -- ^ Catch-all for unknown values
    deriving (Int -> OperationRelational -> ShowS
[OperationRelational] -> ShowS
OperationRelational -> String
(Int -> OperationRelational -> ShowS)
-> (OperationRelational -> String)
-> ([OperationRelational] -> ShowS)
-> Show OperationRelational
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> OperationRelational -> ShowS
showsPrec :: Int -> OperationRelational -> ShowS
$cshow :: OperationRelational -> String
show :: OperationRelational -> String
$cshowList :: [OperationRelational] -> ShowS
showList :: [OperationRelational] -> ShowS
Show, OperationRelational -> OperationRelational -> Bool
(OperationRelational -> OperationRelational -> Bool)
-> (OperationRelational -> OperationRelational -> Bool)
-> Eq OperationRelational
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: OperationRelational -> OperationRelational -> Bool
== :: OperationRelational -> OperationRelational -> Bool
$c/= :: OperationRelational -> OperationRelational -> Bool
/= :: OperationRelational -> OperationRelational -> Bool
Eq)

instance P.Enum OperationRelational where
    fromEnum :: OperationRelational -> Int
fromEnum OperationRelational
OperationRelationalEqual = Int
0
    fromEnum OperationRelational
OperationRelationalNoteq = Int
1
    fromEnum OperationRelational
OperationRelationalLess = Int
2
    fromEnum OperationRelational
OperationRelationalLesseq = Int
3
    fromEnum OperationRelational
OperationRelationalMore = Int
4
    fromEnum OperationRelational
OperationRelationalMoreeq = Int
5
    fromEnum OperationRelational
OperationRelationalLast = Int
6
    fromEnum (AnotherOperationRelational Int
k) = Int
k

    toEnum :: Int -> OperationRelational
toEnum Int
0 = OperationRelational
OperationRelationalEqual
    toEnum Int
1 = OperationRelational
OperationRelationalNoteq
    toEnum Int
2 = OperationRelational
OperationRelationalLess
    toEnum Int
3 = OperationRelational
OperationRelationalLesseq
    toEnum Int
4 = OperationRelational
OperationRelationalMore
    toEnum Int
5 = OperationRelational
OperationRelationalMoreeq
    toEnum Int
6 = OperationRelational
OperationRelationalLast
    toEnum Int
k = Int -> OperationRelational
AnotherOperationRelational Int
k

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

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

foreign import ccall "vips_operation_relational_get_type" c_vips_operation_relational_get_type :: 
    IO GType

instance B.Types.TypedObject OperationRelational where
    glibType :: IO GType
glibType = IO GType
c_vips_operation_relational_get_type

instance B.Types.BoxedEnum OperationRelational

-- Enum OperationMorphology
-- | More like hit-miss, really.
-- 
-- See also: @/vips_morph()/@.
data OperationMorphology = 
      OperationMorphologyErode
    -- ^ true if all set
    | OperationMorphologyDilate
    -- ^ true if one set
    | OperationMorphologyLast
    -- ^ /No description available in the introspection data./
    | AnotherOperationMorphology Int
    -- ^ Catch-all for unknown values
    deriving (Int -> OperationMorphology -> ShowS
[OperationMorphology] -> ShowS
OperationMorphology -> String
(Int -> OperationMorphology -> ShowS)
-> (OperationMorphology -> String)
-> ([OperationMorphology] -> ShowS)
-> Show OperationMorphology
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> OperationMorphology -> ShowS
showsPrec :: Int -> OperationMorphology -> ShowS
$cshow :: OperationMorphology -> String
show :: OperationMorphology -> String
$cshowList :: [OperationMorphology] -> ShowS
showList :: [OperationMorphology] -> ShowS
Show, OperationMorphology -> OperationMorphology -> Bool
(OperationMorphology -> OperationMorphology -> Bool)
-> (OperationMorphology -> OperationMorphology -> Bool)
-> Eq OperationMorphology
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: OperationMorphology -> OperationMorphology -> Bool
== :: OperationMorphology -> OperationMorphology -> Bool
$c/= :: OperationMorphology -> OperationMorphology -> Bool
/= :: OperationMorphology -> OperationMorphology -> Bool
Eq)

instance P.Enum OperationMorphology where
    fromEnum :: OperationMorphology -> Int
fromEnum OperationMorphology
OperationMorphologyErode = Int
0
    fromEnum OperationMorphology
OperationMorphologyDilate = Int
1
    fromEnum OperationMorphology
OperationMorphologyLast = Int
2
    fromEnum (AnotherOperationMorphology Int
k) = Int
k

    toEnum :: Int -> OperationMorphology
toEnum Int
0 = OperationMorphology
OperationMorphologyErode
    toEnum Int
1 = OperationMorphology
OperationMorphologyDilate
    toEnum Int
2 = OperationMorphology
OperationMorphologyLast
    toEnum Int
k = Int -> OperationMorphology
AnotherOperationMorphology Int
k

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

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

foreign import ccall "vips_operation_morphology_get_type" c_vips_operation_morphology_get_type :: 
    IO GType

instance B.Types.TypedObject OperationMorphology where
    glibType :: IO GType
glibType = IO GType
c_vips_operation_morphology_get_type

instance B.Types.BoxedEnum OperationMorphology

-- Enum OperationMath2
-- | See also: @/vips_math()/@.
data OperationMath2 = 
      OperationMath2Pow
    -- ^ pow( left, right )
    | OperationMath2Wop
    -- ^ pow( right, left )
    | OperationMath2Atan2
    -- ^ atan2( left, right )
    | OperationMath2Last
    -- ^ /No description available in the introspection data./
    | AnotherOperationMath2 Int
    -- ^ Catch-all for unknown values
    deriving (Int -> OperationMath2 -> ShowS
[OperationMath2] -> ShowS
OperationMath2 -> String
(Int -> OperationMath2 -> ShowS)
-> (OperationMath2 -> String)
-> ([OperationMath2] -> ShowS)
-> Show OperationMath2
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> OperationMath2 -> ShowS
showsPrec :: Int -> OperationMath2 -> ShowS
$cshow :: OperationMath2 -> String
show :: OperationMath2 -> String
$cshowList :: [OperationMath2] -> ShowS
showList :: [OperationMath2] -> ShowS
Show, OperationMath2 -> OperationMath2 -> Bool
(OperationMath2 -> OperationMath2 -> Bool)
-> (OperationMath2 -> OperationMath2 -> Bool) -> Eq OperationMath2
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: OperationMath2 -> OperationMath2 -> Bool
== :: OperationMath2 -> OperationMath2 -> Bool
$c/= :: OperationMath2 -> OperationMath2 -> Bool
/= :: OperationMath2 -> OperationMath2 -> Bool
Eq)

instance P.Enum OperationMath2 where
    fromEnum :: OperationMath2 -> Int
fromEnum OperationMath2
OperationMath2Pow = Int
0
    fromEnum OperationMath2
OperationMath2Wop = Int
1
    fromEnum OperationMath2
OperationMath2Atan2 = Int
2
    fromEnum OperationMath2
OperationMath2Last = Int
3
    fromEnum (AnotherOperationMath2 Int
k) = Int
k

    toEnum :: Int -> OperationMath2
toEnum Int
0 = OperationMath2
OperationMath2Pow
    toEnum Int
1 = OperationMath2
OperationMath2Wop
    toEnum Int
2 = OperationMath2
OperationMath2Atan2
    toEnum Int
3 = OperationMath2
OperationMath2Last
    toEnum Int
k = Int -> OperationMath2
AnotherOperationMath2 Int
k

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

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

foreign import ccall "vips_operation_math2_get_type" c_vips_operation_math2_get_type :: 
    IO GType

instance B.Types.TypedObject OperationMath2 where
    glibType :: IO GType
glibType = IO GType
c_vips_operation_math2_get_type

instance B.Types.BoxedEnum OperationMath2

-- Enum OperationMath
-- | See also: @/vips_math()/@.
data OperationMath = 
      OperationMathSin
    -- ^ @/sin()/@, angles in degrees
    | OperationMathCos
    -- ^ @/cos()/@, angles in degrees
    | OperationMathTan
    -- ^ @/tan()/@, angles in degrees
    | OperationMathAsin
    -- ^ @/asin()/@, angles in degrees
    | OperationMathAcos
    -- ^ @/acos()/@, angles in degrees
    | OperationMathAtan
    -- ^ @/atan()/@, angles in degrees
    | OperationMathLog
    -- ^ log base e
    | OperationMathLog10
    -- ^ log base 10
    | OperationMathExp
    -- ^ e to the something
    | OperationMathExp10
    -- ^ 10 to the something
    | OperationMathSinh
    -- ^ @/sinh()/@, angles in radians
    | OperationMathCosh
    -- ^ @/cosh()/@, angles in radians
    | OperationMathTanh
    -- ^ @/tanh()/@, angles in radians
    | OperationMathAsinh
    -- ^ @/asinh()/@, angles in radians
    | OperationMathAcosh
    -- ^ @/acosh()/@, angles in radians
    | OperationMathAtanh
    -- ^ @/atanh()/@, angles in radians
    | OperationMathLast
    -- ^ /No description available in the introspection data./
    | AnotherOperationMath Int
    -- ^ Catch-all for unknown values
    deriving (Int -> OperationMath -> ShowS
[OperationMath] -> ShowS
OperationMath -> String
(Int -> OperationMath -> ShowS)
-> (OperationMath -> String)
-> ([OperationMath] -> ShowS)
-> Show OperationMath
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> OperationMath -> ShowS
showsPrec :: Int -> OperationMath -> ShowS
$cshow :: OperationMath -> String
show :: OperationMath -> String
$cshowList :: [OperationMath] -> ShowS
showList :: [OperationMath] -> ShowS
Show, OperationMath -> OperationMath -> Bool
(OperationMath -> OperationMath -> Bool)
-> (OperationMath -> OperationMath -> Bool) -> Eq OperationMath
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: OperationMath -> OperationMath -> Bool
== :: OperationMath -> OperationMath -> Bool
$c/= :: OperationMath -> OperationMath -> Bool
/= :: OperationMath -> OperationMath -> Bool
Eq)

instance P.Enum OperationMath where
    fromEnum :: OperationMath -> Int
fromEnum OperationMath
OperationMathSin = Int
0
    fromEnum OperationMath
OperationMathCos = Int
1
    fromEnum OperationMath
OperationMathTan = Int
2
    fromEnum OperationMath
OperationMathAsin = Int
3
    fromEnum OperationMath
OperationMathAcos = Int
4
    fromEnum OperationMath
OperationMathAtan = Int
5
    fromEnum OperationMath
OperationMathLog = Int
6
    fromEnum OperationMath
OperationMathLog10 = Int
7
    fromEnum OperationMath
OperationMathExp = Int
8
    fromEnum OperationMath
OperationMathExp10 = Int
9
    fromEnum OperationMath
OperationMathSinh = Int
10
    fromEnum OperationMath
OperationMathCosh = Int
11
    fromEnum OperationMath
OperationMathTanh = Int
12
    fromEnum OperationMath
OperationMathAsinh = Int
13
    fromEnum OperationMath
OperationMathAcosh = Int
14
    fromEnum OperationMath
OperationMathAtanh = Int
15
    fromEnum OperationMath
OperationMathLast = Int
16
    fromEnum (AnotherOperationMath Int
k) = Int
k

    toEnum :: Int -> OperationMath
toEnum Int
0 = OperationMath
OperationMathSin
    toEnum Int
1 = OperationMath
OperationMathCos
    toEnum Int
2 = OperationMath
OperationMathTan
    toEnum Int
3 = OperationMath
OperationMathAsin
    toEnum Int
4 = OperationMath
OperationMathAcos
    toEnum Int
5 = OperationMath
OperationMathAtan
    toEnum Int
6 = OperationMath
OperationMathLog
    toEnum Int
7 = OperationMath
OperationMathLog10
    toEnum Int
8 = OperationMath
OperationMathExp
    toEnum Int
9 = OperationMath
OperationMathExp10
    toEnum Int
10 = OperationMath
OperationMathSinh
    toEnum Int
11 = OperationMath
OperationMathCosh
    toEnum Int
12 = OperationMath
OperationMathTanh
    toEnum Int
13 = OperationMath
OperationMathAsinh
    toEnum Int
14 = OperationMath
OperationMathAcosh
    toEnum Int
15 = OperationMath
OperationMathAtanh
    toEnum Int
16 = OperationMath
OperationMathLast
    toEnum Int
k = Int -> OperationMath
AnotherOperationMath Int
k

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

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

foreign import ccall "vips_operation_math_get_type" c_vips_operation_math_get_type :: 
    IO GType

instance B.Types.TypedObject OperationMath where
    glibType :: IO GType
glibType = IO GType
c_vips_operation_math_get_type

instance B.Types.BoxedEnum OperationMath

-- Enum OperationComplexget
-- | See also: @/vips_complexget()/@.
data OperationComplexget = 
      OperationComplexgetReal
    -- ^ get real component
    | OperationComplexgetImag
    -- ^ get imaginary component
    | OperationComplexgetLast
    -- ^ /No description available in the introspection data./
    | AnotherOperationComplexget Int
    -- ^ Catch-all for unknown values
    deriving (Int -> OperationComplexget -> ShowS
[OperationComplexget] -> ShowS
OperationComplexget -> String
(Int -> OperationComplexget -> ShowS)
-> (OperationComplexget -> String)
-> ([OperationComplexget] -> ShowS)
-> Show OperationComplexget
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> OperationComplexget -> ShowS
showsPrec :: Int -> OperationComplexget -> ShowS
$cshow :: OperationComplexget -> String
show :: OperationComplexget -> String
$cshowList :: [OperationComplexget] -> ShowS
showList :: [OperationComplexget] -> ShowS
Show, OperationComplexget -> OperationComplexget -> Bool
(OperationComplexget -> OperationComplexget -> Bool)
-> (OperationComplexget -> OperationComplexget -> Bool)
-> Eq OperationComplexget
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: OperationComplexget -> OperationComplexget -> Bool
== :: OperationComplexget -> OperationComplexget -> Bool
$c/= :: OperationComplexget -> OperationComplexget -> Bool
/= :: OperationComplexget -> OperationComplexget -> Bool
Eq)

instance P.Enum OperationComplexget where
    fromEnum :: OperationComplexget -> Int
fromEnum OperationComplexget
OperationComplexgetReal = Int
0
    fromEnum OperationComplexget
OperationComplexgetImag = Int
1
    fromEnum OperationComplexget
OperationComplexgetLast = Int
2
    fromEnum (AnotherOperationComplexget Int
k) = Int
k

    toEnum :: Int -> OperationComplexget
toEnum Int
0 = OperationComplexget
OperationComplexgetReal
    toEnum Int
1 = OperationComplexget
OperationComplexgetImag
    toEnum Int
2 = OperationComplexget
OperationComplexgetLast
    toEnum Int
k = Int -> OperationComplexget
AnotherOperationComplexget Int
k

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

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

foreign import ccall "vips_operation_complexget_get_type" c_vips_operation_complexget_get_type :: 
    IO GType

instance B.Types.TypedObject OperationComplexget where
    glibType :: IO GType
glibType = IO GType
c_vips_operation_complexget_get_type

instance B.Types.BoxedEnum OperationComplexget

-- Enum OperationComplex2
-- | See also: @/vips_complex2()/@.
data OperationComplex2 = 
      OperationComplex2CrossPhase
    -- ^ convert to polar coordinates
    | OperationComplex2Last
    -- ^ /No description available in the introspection data./
    | AnotherOperationComplex2 Int
    -- ^ Catch-all for unknown values
    deriving (Int -> OperationComplex2 -> ShowS
[OperationComplex2] -> ShowS
OperationComplex2 -> String
(Int -> OperationComplex2 -> ShowS)
-> (OperationComplex2 -> String)
-> ([OperationComplex2] -> ShowS)
-> Show OperationComplex2
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> OperationComplex2 -> ShowS
showsPrec :: Int -> OperationComplex2 -> ShowS
$cshow :: OperationComplex2 -> String
show :: OperationComplex2 -> String
$cshowList :: [OperationComplex2] -> ShowS
showList :: [OperationComplex2] -> ShowS
Show, OperationComplex2 -> OperationComplex2 -> Bool
(OperationComplex2 -> OperationComplex2 -> Bool)
-> (OperationComplex2 -> OperationComplex2 -> Bool)
-> Eq OperationComplex2
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: OperationComplex2 -> OperationComplex2 -> Bool
== :: OperationComplex2 -> OperationComplex2 -> Bool
$c/= :: OperationComplex2 -> OperationComplex2 -> Bool
/= :: OperationComplex2 -> OperationComplex2 -> Bool
Eq)

instance P.Enum OperationComplex2 where
    fromEnum :: OperationComplex2 -> Int
fromEnum OperationComplex2
OperationComplex2CrossPhase = Int
0
    fromEnum OperationComplex2
OperationComplex2Last = Int
1
    fromEnum (AnotherOperationComplex2 Int
k) = Int
k

    toEnum :: Int -> OperationComplex2
toEnum Int
0 = OperationComplex2
OperationComplex2CrossPhase
    toEnum Int
1 = OperationComplex2
OperationComplex2Last
    toEnum Int
k = Int -> OperationComplex2
AnotherOperationComplex2 Int
k

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

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

foreign import ccall "vips_operation_complex2_get_type" c_vips_operation_complex2_get_type :: 
    IO GType

instance B.Types.TypedObject OperationComplex2 where
    glibType :: IO GType
glibType = IO GType
c_vips_operation_complex2_get_type

instance B.Types.BoxedEnum OperationComplex2

-- Enum OperationComplex
-- | See also: @/vips_complex()/@.
data OperationComplex = 
      OperationComplexPolar
    -- ^ convert to polar coordinates
    | OperationComplexRect
    -- ^ convert to rectangular coordinates
    | OperationComplexConj
    -- ^ complex conjugate
    | OperationComplexLast
    -- ^ /No description available in the introspection data./
    | AnotherOperationComplex Int
    -- ^ Catch-all for unknown values
    deriving (Int -> OperationComplex -> ShowS
[OperationComplex] -> ShowS
OperationComplex -> String
(Int -> OperationComplex -> ShowS)
-> (OperationComplex -> String)
-> ([OperationComplex] -> ShowS)
-> Show OperationComplex
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> OperationComplex -> ShowS
showsPrec :: Int -> OperationComplex -> ShowS
$cshow :: OperationComplex -> String
show :: OperationComplex -> String
$cshowList :: [OperationComplex] -> ShowS
showList :: [OperationComplex] -> ShowS
Show, OperationComplex -> OperationComplex -> Bool
(OperationComplex -> OperationComplex -> Bool)
-> (OperationComplex -> OperationComplex -> Bool)
-> Eq OperationComplex
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: OperationComplex -> OperationComplex -> Bool
== :: OperationComplex -> OperationComplex -> Bool
$c/= :: OperationComplex -> OperationComplex -> Bool
/= :: OperationComplex -> OperationComplex -> Bool
Eq)

instance P.Enum OperationComplex where
    fromEnum :: OperationComplex -> Int
fromEnum OperationComplex
OperationComplexPolar = Int
0
    fromEnum OperationComplex
OperationComplexRect = Int
1
    fromEnum OperationComplex
OperationComplexConj = Int
2
    fromEnum OperationComplex
OperationComplexLast = Int
3
    fromEnum (AnotherOperationComplex Int
k) = Int
k

    toEnum :: Int -> OperationComplex
toEnum Int
0 = OperationComplex
OperationComplexPolar
    toEnum Int
1 = OperationComplex
OperationComplexRect
    toEnum Int
2 = OperationComplex
OperationComplexConj
    toEnum Int
3 = OperationComplex
OperationComplexLast
    toEnum Int
k = Int -> OperationComplex
AnotherOperationComplex Int
k

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

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

foreign import ccall "vips_operation_complex_get_type" c_vips_operation_complex_get_type :: 
    IO GType

instance B.Types.TypedObject OperationComplex where
    glibType :: IO GType
glibType = IO GType
c_vips_operation_complex_get_type

instance B.Types.BoxedEnum OperationComplex

-- Enum OperationBoolean
-- | See also: @/vips_boolean()/@.
data OperationBoolean = 
      OperationBooleanAnd
    -- ^ &
    | OperationBooleanOr
    -- ^ |
    | OperationBooleanEor
    -- ^ ^
    | OperationBooleanLshift
    -- ^ >>
    | OperationBooleanRshift
    -- ^ \<\<
    | OperationBooleanLast
    -- ^ /No description available in the introspection data./
    | AnotherOperationBoolean Int
    -- ^ Catch-all for unknown values
    deriving (Int -> OperationBoolean -> ShowS
[OperationBoolean] -> ShowS
OperationBoolean -> String
(Int -> OperationBoolean -> ShowS)
-> (OperationBoolean -> String)
-> ([OperationBoolean] -> ShowS)
-> Show OperationBoolean
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> OperationBoolean -> ShowS
showsPrec :: Int -> OperationBoolean -> ShowS
$cshow :: OperationBoolean -> String
show :: OperationBoolean -> String
$cshowList :: [OperationBoolean] -> ShowS
showList :: [OperationBoolean] -> ShowS
Show, OperationBoolean -> OperationBoolean -> Bool
(OperationBoolean -> OperationBoolean -> Bool)
-> (OperationBoolean -> OperationBoolean -> Bool)
-> Eq OperationBoolean
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: OperationBoolean -> OperationBoolean -> Bool
== :: OperationBoolean -> OperationBoolean -> Bool
$c/= :: OperationBoolean -> OperationBoolean -> Bool
/= :: OperationBoolean -> OperationBoolean -> Bool
Eq)

instance P.Enum OperationBoolean where
    fromEnum :: OperationBoolean -> Int
fromEnum OperationBoolean
OperationBooleanAnd = Int
0
    fromEnum OperationBoolean
OperationBooleanOr = Int
1
    fromEnum OperationBoolean
OperationBooleanEor = Int
2
    fromEnum OperationBoolean
OperationBooleanLshift = Int
3
    fromEnum OperationBoolean
OperationBooleanRshift = Int
4
    fromEnum OperationBoolean
OperationBooleanLast = Int
5
    fromEnum (AnotherOperationBoolean Int
k) = Int
k

    toEnum :: Int -> OperationBoolean
toEnum Int
0 = OperationBoolean
OperationBooleanAnd
    toEnum Int
1 = OperationBoolean
OperationBooleanOr
    toEnum Int
2 = OperationBoolean
OperationBooleanEor
    toEnum Int
3 = OperationBoolean
OperationBooleanLshift
    toEnum Int
4 = OperationBoolean
OperationBooleanRshift
    toEnum Int
5 = OperationBoolean
OperationBooleanLast
    toEnum Int
k = Int -> OperationBoolean
AnotherOperationBoolean Int
k

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

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

foreign import ccall "vips_operation_boolean_get_type" c_vips_operation_boolean_get_type :: 
    IO GType

instance B.Types.TypedObject OperationBoolean where
    glibType :: IO GType
glibType = IO GType
c_vips_operation_boolean_get_type

instance B.Types.BoxedEnum OperationBoolean

-- Enum Kernel
-- | The resampling kernels vips supports. See @/vips_reduce()/@, for example.
data Kernel = 
      KernelNearest
    -- ^ The nearest pixel to the point.
    | KernelLinear
    -- ^ Convolve with a triangle filter.
    | KernelCubic
    -- ^ Convolve with a cubic filter.
    | KernelMitchell
    -- ^ Convolve with a Mitchell kernel.
    | KernelLanczos2
    -- ^ Convolve with a two-lobe Lanczos kernel.
    | KernelLanczos3
    -- ^ Convolve with a three-lobe Lanczos kernel.
    | KernelLast
    -- ^ /No description available in the introspection data./
    | AnotherKernel Int
    -- ^ Catch-all for unknown values
    deriving (Int -> Kernel -> ShowS
[Kernel] -> ShowS
Kernel -> String
(Int -> Kernel -> ShowS)
-> (Kernel -> String) -> ([Kernel] -> ShowS) -> Show Kernel
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Kernel -> ShowS
showsPrec :: Int -> Kernel -> ShowS
$cshow :: Kernel -> String
show :: Kernel -> String
$cshowList :: [Kernel] -> ShowS
showList :: [Kernel] -> ShowS
Show, Kernel -> Kernel -> Bool
(Kernel -> Kernel -> Bool)
-> (Kernel -> Kernel -> Bool) -> Eq Kernel
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Kernel -> Kernel -> Bool
== :: Kernel -> Kernel -> Bool
$c/= :: Kernel -> Kernel -> Bool
/= :: Kernel -> Kernel -> Bool
Eq)

instance P.Enum Kernel where
    fromEnum :: Kernel -> Int
fromEnum Kernel
KernelNearest = Int
0
    fromEnum Kernel
KernelLinear = Int
1
    fromEnum Kernel
KernelCubic = Int
2
    fromEnum Kernel
KernelMitchell = Int
3
    fromEnum Kernel
KernelLanczos2 = Int
4
    fromEnum Kernel
KernelLanczos3 = Int
5
    fromEnum Kernel
KernelLast = Int
6
    fromEnum (AnotherKernel Int
k) = Int
k

    toEnum :: Int -> Kernel
toEnum Int
0 = Kernel
KernelNearest
    toEnum Int
1 = Kernel
KernelLinear
    toEnum Int
2 = Kernel
KernelCubic
    toEnum Int
3 = Kernel
KernelMitchell
    toEnum Int
4 = Kernel
KernelLanczos2
    toEnum Int
5 = Kernel
KernelLanczos3
    toEnum Int
6 = Kernel
KernelLast
    toEnum Int
k = Int -> Kernel
AnotherKernel Int
k

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

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

foreign import ccall "vips_kernel_get_type" c_vips_kernel_get_type :: 
    IO GType

instance B.Types.TypedObject Kernel where
    glibType :: IO GType
glibType = IO GType
c_vips_kernel_get_type

instance B.Types.BoxedEnum Kernel

-- Enum Interpretation
-- | How the values in an image should be interpreted. For example, a
-- three-band float image of type @/VIPS_INTERPRETATION_LAB/@ should have its
-- pixels interpreted as coordinates in CIE Lab space.
-- 
-- RGB and sRGB are treated in the same way. Use the colourspace functions if
-- you want some other behaviour.
-- 
-- The gaps in numbering are historical and must be maintained. Allocate
-- new numbers from the end.
data Interpretation = 
      InterpretationError
    -- ^ /No description available in the introspection data./
    | InterpretationMultiband
    -- ^ generic many-band image
    | InterpretationBW
    -- ^ some kind of single-band image
    | InterpretationHistogram
    -- ^ a 1D image, eg. histogram or lookup table
    | InterpretationXyz
    -- ^ the first three bands are CIE XYZ
    | InterpretationLab
    -- ^ pixels are in CIE Lab space
    | InterpretationCmyk
    -- ^ the first four bands are in CMYK space
    | InterpretationLabq
    -- ^ implies @/VIPS_CODING_LABQ/@
    | InterpretationRgb
    -- ^ generic RGB space
    | InterpretationCmc
    -- ^ a uniform colourspace based on CMC(1:1)
    | InterpretationLch
    -- ^ pixels are in CIE LCh space
    | InterpretationLabs
    -- ^ CIE LAB coded as three signed 16-bit values
    | InterpretationSrgb
    -- ^ pixels are sRGB
    | InterpretationYxy
    -- ^ pixels are CIE Yxy
    | InterpretationFourier
    -- ^ image is in fourier space
    | InterpretationRgb16
    -- ^ generic 16-bit RGB
    | InterpretationGrey16
    -- ^ generic 16-bit mono
    | InterpretationMatrix
    -- ^ a matrix
    | InterpretationScrgb
    -- ^ pixels are scRGB
    | InterpretationHsv
    -- ^ pixels are HSV
    | InterpretationLast
    -- ^ /No description available in the introspection data./
    | AnotherInterpretation Int
    -- ^ Catch-all for unknown values
    deriving (Int -> Interpretation -> ShowS
[Interpretation] -> ShowS
Interpretation -> String
(Int -> Interpretation -> ShowS)
-> (Interpretation -> String)
-> ([Interpretation] -> ShowS)
-> Show Interpretation
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Interpretation -> ShowS
showsPrec :: Int -> Interpretation -> ShowS
$cshow :: Interpretation -> String
show :: Interpretation -> String
$cshowList :: [Interpretation] -> ShowS
showList :: [Interpretation] -> ShowS
Show, Interpretation -> Interpretation -> Bool
(Interpretation -> Interpretation -> Bool)
-> (Interpretation -> Interpretation -> Bool) -> Eq Interpretation
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Interpretation -> Interpretation -> Bool
== :: Interpretation -> Interpretation -> Bool
$c/= :: Interpretation -> Interpretation -> Bool
/= :: Interpretation -> Interpretation -> Bool
Eq)

instance P.Enum Interpretation where
    fromEnum :: Interpretation -> Int
fromEnum Interpretation
InterpretationError = Int
-1
    fromEnum Interpretation
InterpretationMultiband = Int
0
    fromEnum Interpretation
InterpretationBW = Int
1
    fromEnum Interpretation
InterpretationHistogram = Int
10
    fromEnum Interpretation
InterpretationXyz = Int
12
    fromEnum Interpretation
InterpretationLab = Int
13
    fromEnum Interpretation
InterpretationCmyk = Int
15
    fromEnum Interpretation
InterpretationLabq = Int
16
    fromEnum Interpretation
InterpretationRgb = Int
17
    fromEnum Interpretation
InterpretationCmc = Int
18
    fromEnum Interpretation
InterpretationLch = Int
19
    fromEnum Interpretation
InterpretationLabs = Int
21
    fromEnum Interpretation
InterpretationSrgb = Int
22
    fromEnum Interpretation
InterpretationYxy = Int
23
    fromEnum Interpretation
InterpretationFourier = Int
24
    fromEnum Interpretation
InterpretationRgb16 = Int
25
    fromEnum Interpretation
InterpretationGrey16 = Int
26
    fromEnum Interpretation
InterpretationMatrix = Int
27
    fromEnum Interpretation
InterpretationScrgb = Int
28
    fromEnum Interpretation
InterpretationHsv = Int
29
    fromEnum Interpretation
InterpretationLast = Int
30
    fromEnum (AnotherInterpretation Int
k) = Int
k

    toEnum :: Int -> Interpretation
toEnum Int
-1 = Interpretation
InterpretationError
    toEnum Int
0 = Interpretation
InterpretationMultiband
    toEnum Int
1 = Interpretation
InterpretationBW
    toEnum Int
10 = Interpretation
InterpretationHistogram
    toEnum Int
12 = Interpretation
InterpretationXyz
    toEnum Int
13 = Interpretation
InterpretationLab
    toEnum Int
15 = Interpretation
InterpretationCmyk
    toEnum Int
16 = Interpretation
InterpretationLabq
    toEnum Int
17 = Interpretation
InterpretationRgb
    toEnum Int
18 = Interpretation
InterpretationCmc
    toEnum Int
19 = Interpretation
InterpretationLch
    toEnum Int
21 = Interpretation
InterpretationLabs
    toEnum Int
22 = Interpretation
InterpretationSrgb
    toEnum Int
23 = Interpretation
InterpretationYxy
    toEnum Int
24 = Interpretation
InterpretationFourier
    toEnum Int
25 = Interpretation
InterpretationRgb16
    toEnum Int
26 = Interpretation
InterpretationGrey16
    toEnum Int
27 = Interpretation
InterpretationMatrix
    toEnum Int
28 = Interpretation
InterpretationScrgb
    toEnum Int
29 = Interpretation
InterpretationHsv
    toEnum Int
30 = Interpretation
InterpretationLast
    toEnum Int
k = Int -> Interpretation
AnotherInterpretation Int
k

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

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

foreign import ccall "vips_interpretation_get_type" c_vips_interpretation_get_type :: 
    IO GType

instance B.Types.TypedObject Interpretation where
    glibType :: IO GType
glibType = IO GType
c_vips_interpretation_get_type

instance B.Types.BoxedEnum Interpretation

-- Enum Interesting
-- | Pick the algorithm vips uses to decide image \"interestingness\". This is used
-- by @/vips_smartcrop()/@, for example, to decide what parts of the image to
-- keep.
-- 
-- @/VIPS_INTERESTING_NONE/@ and @/VIPS_INTERESTING_LOW/@ mean the same -- the
-- crop is positioned at the top or left. @/VIPS_INTERESTING_HIGH/@ positions at
-- the bottom or right.
-- 
-- See also: @/vips_smartcrop()/@.
data Interesting = 
      InterestingNone
    -- ^ do nothing
    | InterestingCentre
    -- ^ just take the centre
    | InterestingEntropy
    -- ^ use an entropy measure
    | InterestingAttention
    -- ^ look for features likely to draw human attention
    | InterestingLow
    -- ^ position the crop towards the low coordinate
    | InterestingHigh
    -- ^ position the crop towards the high coordinate
    | InterestingAll
    -- ^ everything is interesting
    | InterestingLast
    -- ^ /No description available in the introspection data./
    | AnotherInteresting Int
    -- ^ Catch-all for unknown values
    deriving (Int -> Interesting -> ShowS
[Interesting] -> ShowS
Interesting -> String
(Int -> Interesting -> ShowS)
-> (Interesting -> String)
-> ([Interesting] -> ShowS)
-> Show Interesting
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Interesting -> ShowS
showsPrec :: Int -> Interesting -> ShowS
$cshow :: Interesting -> String
show :: Interesting -> String
$cshowList :: [Interesting] -> ShowS
showList :: [Interesting] -> ShowS
Show, Interesting -> Interesting -> Bool
(Interesting -> Interesting -> Bool)
-> (Interesting -> Interesting -> Bool) -> Eq Interesting
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Interesting -> Interesting -> Bool
== :: Interesting -> Interesting -> Bool
$c/= :: Interesting -> Interesting -> Bool
/= :: Interesting -> Interesting -> Bool
Eq)

instance P.Enum Interesting where
    fromEnum :: Interesting -> Int
fromEnum Interesting
InterestingNone = Int
0
    fromEnum Interesting
InterestingCentre = Int
1
    fromEnum Interesting
InterestingEntropy = Int
2
    fromEnum Interesting
InterestingAttention = Int
3
    fromEnum Interesting
InterestingLow = Int
4
    fromEnum Interesting
InterestingHigh = Int
5
    fromEnum Interesting
InterestingAll = Int
6
    fromEnum Interesting
InterestingLast = Int
7
    fromEnum (AnotherInteresting Int
k) = Int
k

    toEnum :: Int -> Interesting
toEnum Int
0 = Interesting
InterestingNone
    toEnum Int
1 = Interesting
InterestingCentre
    toEnum Int
2 = Interesting
InterestingEntropy
    toEnum Int
3 = Interesting
InterestingAttention
    toEnum Int
4 = Interesting
InterestingLow
    toEnum Int
5 = Interesting
InterestingHigh
    toEnum Int
6 = Interesting
InterestingAll
    toEnum Int
7 = Interesting
InterestingLast
    toEnum Int
k = Int -> Interesting
AnotherInteresting Int
k

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

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

foreign import ccall "vips_interesting_get_type" c_vips_interesting_get_type :: 
    IO GType

instance B.Types.TypedObject Interesting where
    glibType :: IO GType
glibType = IO GType
c_vips_interesting_get_type

instance B.Types.BoxedEnum Interesting

-- Enum Intent
-- | The rendering intent. @/VIPS_INTENT_ABSOLUTE/@ is best for
-- scientific work, @/VIPS_INTENT_RELATIVE/@ is usually best for
-- accurate communication with other imaging libraries.
data Intent = 
      IntentPerceptual
    -- ^ perceptual rendering intent
    | IntentRelative
    -- ^ relative colorimetric rendering intent
    | IntentSaturation
    -- ^ saturation rendering intent
    | IntentAbsolute
    -- ^ absolute colorimetric rendering intent
    | IntentLast
    -- ^ /No description available in the introspection data./
    | AnotherIntent Int
    -- ^ Catch-all for unknown values
    deriving (Int -> Intent -> ShowS
[Intent] -> ShowS
Intent -> String
(Int -> Intent -> ShowS)
-> (Intent -> String) -> ([Intent] -> ShowS) -> Show Intent
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Intent -> ShowS
showsPrec :: Int -> Intent -> ShowS
$cshow :: Intent -> String
show :: Intent -> String
$cshowList :: [Intent] -> ShowS
showList :: [Intent] -> ShowS
Show, Intent -> Intent -> Bool
(Intent -> Intent -> Bool)
-> (Intent -> Intent -> Bool) -> Eq Intent
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Intent -> Intent -> Bool
== :: Intent -> Intent -> Bool
$c/= :: Intent -> Intent -> Bool
/= :: Intent -> Intent -> Bool
Eq)

instance P.Enum Intent where
    fromEnum :: Intent -> Int
fromEnum Intent
IntentPerceptual = Int
0
    fromEnum Intent
IntentRelative = Int
1
    fromEnum Intent
IntentSaturation = Int
2
    fromEnum Intent
IntentAbsolute = Int
3
    fromEnum Intent
IntentLast = Int
4
    fromEnum (AnotherIntent Int
k) = Int
k

    toEnum :: Int -> Intent
toEnum Int
0 = Intent
IntentPerceptual
    toEnum Int
1 = Intent
IntentRelative
    toEnum Int
2 = Intent
IntentSaturation
    toEnum Int
3 = Intent
IntentAbsolute
    toEnum Int
4 = Intent
IntentLast
    toEnum Int
k = Int -> Intent
AnotherIntent Int
k

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

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

foreign import ccall "vips_intent_get_type" c_vips_intent_get_type :: 
    IO GType

instance B.Types.TypedObject Intent where
    glibType :: IO GType
glibType = IO GType
c_vips_intent_get_type

instance B.Types.BoxedEnum Intent

-- Enum ImageType
-- | /No description available in the introspection data./
data ImageType = 
      ImageTypeError
    -- ^ /No description available in the introspection data./
    | ImageTypeNone
    -- ^ /No description available in the introspection data./
    | ImageTypeSetbuf
    -- ^ /No description available in the introspection data./
    | ImageTypeSetbufForeign
    -- ^ /No description available in the introspection data./
    | ImageTypeOpenin
    -- ^ /No description available in the introspection data./
    | ImageTypeMmapin
    -- ^ /No description available in the introspection data./
    | ImageTypeMmapinrw
    -- ^ /No description available in the introspection data./
    | ImageTypeOpenout
    -- ^ /No description available in the introspection data./
    | ImageTypePartial
    -- ^ /No description available in the introspection data./
    | AnotherImageType Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ImageType -> ShowS
[ImageType] -> ShowS
ImageType -> String
(Int -> ImageType -> ShowS)
-> (ImageType -> String)
-> ([ImageType] -> ShowS)
-> Show ImageType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ImageType -> ShowS
showsPrec :: Int -> ImageType -> ShowS
$cshow :: ImageType -> String
show :: ImageType -> String
$cshowList :: [ImageType] -> ShowS
showList :: [ImageType] -> ShowS
Show, ImageType -> ImageType -> Bool
(ImageType -> ImageType -> Bool)
-> (ImageType -> ImageType -> Bool) -> Eq ImageType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ImageType -> ImageType -> Bool
== :: ImageType -> ImageType -> Bool
$c/= :: ImageType -> ImageType -> Bool
/= :: ImageType -> ImageType -> Bool
Eq)

instance P.Enum ImageType where
    fromEnum :: ImageType -> Int
fromEnum ImageType
ImageTypeError = Int
-1
    fromEnum ImageType
ImageTypeNone = Int
0
    fromEnum ImageType
ImageTypeSetbuf = Int
1
    fromEnum ImageType
ImageTypeSetbufForeign = Int
2
    fromEnum ImageType
ImageTypeOpenin = Int
3
    fromEnum ImageType
ImageTypeMmapin = Int
4
    fromEnum ImageType
ImageTypeMmapinrw = Int
5
    fromEnum ImageType
ImageTypeOpenout = Int
6
    fromEnum ImageType
ImageTypePartial = Int
7
    fromEnum (AnotherImageType Int
k) = Int
k

    toEnum :: Int -> ImageType
toEnum Int
-1 = ImageType
ImageTypeError
    toEnum Int
0 = ImageType
ImageTypeNone
    toEnum Int
1 = ImageType
ImageTypeSetbuf
    toEnum Int
2 = ImageType
ImageTypeSetbufForeign
    toEnum Int
3 = ImageType
ImageTypeOpenin
    toEnum Int
4 = ImageType
ImageTypeMmapin
    toEnum Int
5 = ImageType
ImageTypeMmapinrw
    toEnum Int
6 = ImageType
ImageTypeOpenout
    toEnum Int
7 = ImageType
ImageTypePartial
    toEnum Int
k = Int -> ImageType
AnotherImageType Int
k

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

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

foreign import ccall "vips_image_type_get_type" c_vips_image_type_get_type :: 
    IO GType

instance B.Types.TypedObject ImageType where
    glibType :: IO GType
glibType = IO GType
c_vips_image_type_get_type

instance B.Types.BoxedEnum ImageType

-- Enum ForeignWebpPreset
-- | Tune lossy encoder settings for different image types.
data ForeignWebpPreset = 
      ForeignWebpPresetDefault
    -- ^ default preset
    | ForeignWebpPresetPicture
    -- ^ digital picture, like portrait, inner shot
    | ForeignWebpPresetPhoto
    -- ^ outdoor photograph, with natural lighting
    | ForeignWebpPresetDrawing
    -- ^ hand or line drawing, with high-contrast details
    | ForeignWebpPresetIcon
    -- ^ small-sized colorful images
    | ForeignWebpPresetText
    -- ^ text-like
    | ForeignWebpPresetLast
    -- ^ /No description available in the introspection data./
    | AnotherForeignWebpPreset Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ForeignWebpPreset -> ShowS
[ForeignWebpPreset] -> ShowS
ForeignWebpPreset -> String
(Int -> ForeignWebpPreset -> ShowS)
-> (ForeignWebpPreset -> String)
-> ([ForeignWebpPreset] -> ShowS)
-> Show ForeignWebpPreset
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ForeignWebpPreset -> ShowS
showsPrec :: Int -> ForeignWebpPreset -> ShowS
$cshow :: ForeignWebpPreset -> String
show :: ForeignWebpPreset -> String
$cshowList :: [ForeignWebpPreset] -> ShowS
showList :: [ForeignWebpPreset] -> ShowS
Show, ForeignWebpPreset -> ForeignWebpPreset -> Bool
(ForeignWebpPreset -> ForeignWebpPreset -> Bool)
-> (ForeignWebpPreset -> ForeignWebpPreset -> Bool)
-> Eq ForeignWebpPreset
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ForeignWebpPreset -> ForeignWebpPreset -> Bool
== :: ForeignWebpPreset -> ForeignWebpPreset -> Bool
$c/= :: ForeignWebpPreset -> ForeignWebpPreset -> Bool
/= :: ForeignWebpPreset -> ForeignWebpPreset -> Bool
Eq)

instance P.Enum ForeignWebpPreset where
    fromEnum :: ForeignWebpPreset -> Int
fromEnum ForeignWebpPreset
ForeignWebpPresetDefault = Int
0
    fromEnum ForeignWebpPreset
ForeignWebpPresetPicture = Int
1
    fromEnum ForeignWebpPreset
ForeignWebpPresetPhoto = Int
2
    fromEnum ForeignWebpPreset
ForeignWebpPresetDrawing = Int
3
    fromEnum ForeignWebpPreset
ForeignWebpPresetIcon = Int
4
    fromEnum ForeignWebpPreset
ForeignWebpPresetText = Int
5
    fromEnum ForeignWebpPreset
ForeignWebpPresetLast = Int
6
    fromEnum (AnotherForeignWebpPreset Int
k) = Int
k

    toEnum :: Int -> ForeignWebpPreset
toEnum Int
0 = ForeignWebpPreset
ForeignWebpPresetDefault
    toEnum Int
1 = ForeignWebpPreset
ForeignWebpPresetPicture
    toEnum Int
2 = ForeignWebpPreset
ForeignWebpPresetPhoto
    toEnum Int
3 = ForeignWebpPreset
ForeignWebpPresetDrawing
    toEnum Int
4 = ForeignWebpPreset
ForeignWebpPresetIcon
    toEnum Int
5 = ForeignWebpPreset
ForeignWebpPresetText
    toEnum Int
6 = ForeignWebpPreset
ForeignWebpPresetLast
    toEnum Int
k = Int -> ForeignWebpPreset
AnotherForeignWebpPreset Int
k

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

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

foreign import ccall "vips_foreign_webp_preset_get_type" c_vips_foreign_webp_preset_get_type :: 
    IO GType

instance B.Types.TypedObject ForeignWebpPreset where
    glibType :: IO GType
glibType = IO GType
c_vips_foreign_webp_preset_get_type

instance B.Types.BoxedEnum ForeignWebpPreset

-- Enum ForeignTiffResunit
-- | Use inches or centimeters as the resolution unit for a tiff file.
data ForeignTiffResunit = 
      ForeignTiffResunitCm
    -- ^ use centimeters
    | ForeignTiffResunitInch
    -- ^ use inches
    | ForeignTiffResunitLast
    -- ^ /No description available in the introspection data./
    | AnotherForeignTiffResunit Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ForeignTiffResunit -> ShowS
[ForeignTiffResunit] -> ShowS
ForeignTiffResunit -> String
(Int -> ForeignTiffResunit -> ShowS)
-> (ForeignTiffResunit -> String)
-> ([ForeignTiffResunit] -> ShowS)
-> Show ForeignTiffResunit
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ForeignTiffResunit -> ShowS
showsPrec :: Int -> ForeignTiffResunit -> ShowS
$cshow :: ForeignTiffResunit -> String
show :: ForeignTiffResunit -> String
$cshowList :: [ForeignTiffResunit] -> ShowS
showList :: [ForeignTiffResunit] -> ShowS
Show, ForeignTiffResunit -> ForeignTiffResunit -> Bool
(ForeignTiffResunit -> ForeignTiffResunit -> Bool)
-> (ForeignTiffResunit -> ForeignTiffResunit -> Bool)
-> Eq ForeignTiffResunit
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ForeignTiffResunit -> ForeignTiffResunit -> Bool
== :: ForeignTiffResunit -> ForeignTiffResunit -> Bool
$c/= :: ForeignTiffResunit -> ForeignTiffResunit -> Bool
/= :: ForeignTiffResunit -> ForeignTiffResunit -> Bool
Eq)

instance P.Enum ForeignTiffResunit where
    fromEnum :: ForeignTiffResunit -> Int
fromEnum ForeignTiffResunit
ForeignTiffResunitCm = Int
0
    fromEnum ForeignTiffResunit
ForeignTiffResunitInch = Int
1
    fromEnum ForeignTiffResunit
ForeignTiffResunitLast = Int
2
    fromEnum (AnotherForeignTiffResunit Int
k) = Int
k

    toEnum :: Int -> ForeignTiffResunit
toEnum Int
0 = ForeignTiffResunit
ForeignTiffResunitCm
    toEnum Int
1 = ForeignTiffResunit
ForeignTiffResunitInch
    toEnum Int
2 = ForeignTiffResunit
ForeignTiffResunitLast
    toEnum Int
k = Int -> ForeignTiffResunit
AnotherForeignTiffResunit Int
k

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

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

foreign import ccall "vips_foreign_tiff_resunit_get_type" c_vips_foreign_tiff_resunit_get_type :: 
    IO GType

instance B.Types.TypedObject ForeignTiffResunit where
    glibType :: IO GType
glibType = IO GType
c_vips_foreign_tiff_resunit_get_type

instance B.Types.BoxedEnum ForeignTiffResunit

-- Enum ForeignTiffPredictor
-- | The predictor can help deflate and lzw compression. The values are fixed by
-- the tiff library.
data ForeignTiffPredictor = 
      ForeignTiffPredictorNone
    -- ^ no prediction
    | ForeignTiffPredictorHorizontal
    -- ^ horizontal differencing
    | ForeignTiffPredictorFloat
    -- ^ float predictor
    | ForeignTiffPredictorLast
    -- ^ /No description available in the introspection data./
    | AnotherForeignTiffPredictor Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ForeignTiffPredictor -> ShowS
[ForeignTiffPredictor] -> ShowS
ForeignTiffPredictor -> String
(Int -> ForeignTiffPredictor -> ShowS)
-> (ForeignTiffPredictor -> String)
-> ([ForeignTiffPredictor] -> ShowS)
-> Show ForeignTiffPredictor
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ForeignTiffPredictor -> ShowS
showsPrec :: Int -> ForeignTiffPredictor -> ShowS
$cshow :: ForeignTiffPredictor -> String
show :: ForeignTiffPredictor -> String
$cshowList :: [ForeignTiffPredictor] -> ShowS
showList :: [ForeignTiffPredictor] -> ShowS
Show, ForeignTiffPredictor -> ForeignTiffPredictor -> Bool
(ForeignTiffPredictor -> ForeignTiffPredictor -> Bool)
-> (ForeignTiffPredictor -> ForeignTiffPredictor -> Bool)
-> Eq ForeignTiffPredictor
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ForeignTiffPredictor -> ForeignTiffPredictor -> Bool
== :: ForeignTiffPredictor -> ForeignTiffPredictor -> Bool
$c/= :: ForeignTiffPredictor -> ForeignTiffPredictor -> Bool
/= :: ForeignTiffPredictor -> ForeignTiffPredictor -> Bool
Eq)

instance P.Enum ForeignTiffPredictor where
    fromEnum :: ForeignTiffPredictor -> Int
fromEnum ForeignTiffPredictor
ForeignTiffPredictorNone = Int
1
    fromEnum ForeignTiffPredictor
ForeignTiffPredictorHorizontal = Int
2
    fromEnum ForeignTiffPredictor
ForeignTiffPredictorFloat = Int
3
    fromEnum ForeignTiffPredictor
ForeignTiffPredictorLast = Int
4
    fromEnum (AnotherForeignTiffPredictor Int
k) = Int
k

    toEnum :: Int -> ForeignTiffPredictor
toEnum Int
1 = ForeignTiffPredictor
ForeignTiffPredictorNone
    toEnum Int
2 = ForeignTiffPredictor
ForeignTiffPredictorHorizontal
    toEnum Int
3 = ForeignTiffPredictor
ForeignTiffPredictorFloat
    toEnum Int
4 = ForeignTiffPredictor
ForeignTiffPredictorLast
    toEnum Int
k = Int -> ForeignTiffPredictor
AnotherForeignTiffPredictor Int
k

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

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

foreign import ccall "vips_foreign_tiff_predictor_get_type" c_vips_foreign_tiff_predictor_get_type :: 
    IO GType

instance B.Types.TypedObject ForeignTiffPredictor where
    glibType :: IO GType
glibType = IO GType
c_vips_foreign_tiff_predictor_get_type

instance B.Types.BoxedEnum ForeignTiffPredictor

-- Enum ForeignTiffCompression
-- | The compression types supported by the tiff writer.
-- 
-- Use /@q@/ to set the jpeg compression level, default 75.
-- 
-- Use /@predictor@/ to set the lzw or deflate prediction, default horizontal.
-- 
-- Use /@lossless@/ to set WEBP lossless compression.
-- 
-- Use /@level@/ to set webp and zstd compression level.
data ForeignTiffCompression = 
      ForeignTiffCompressionNone
    -- ^ no compression
    | ForeignTiffCompressionJpeg
    -- ^ jpeg compression
    | ForeignTiffCompressionDeflate
    -- ^ deflate (zip) compression
    | ForeignTiffCompressionPackbits
    -- ^ packbits compression
    | ForeignTiffCompressionCcittfax4
    -- ^ fax4 compression
    | ForeignTiffCompressionLzw
    -- ^ LZW compression
    | ForeignTiffCompressionWebp
    -- ^ WEBP compression
    | ForeignTiffCompressionZstd
    -- ^ ZSTD compression
    | ForeignTiffCompressionJp2k
    -- ^ JP2K compression
    | ForeignTiffCompressionLast
    -- ^ /No description available in the introspection data./
    | AnotherForeignTiffCompression Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ForeignTiffCompression -> ShowS
[ForeignTiffCompression] -> ShowS
ForeignTiffCompression -> String
(Int -> ForeignTiffCompression -> ShowS)
-> (ForeignTiffCompression -> String)
-> ([ForeignTiffCompression] -> ShowS)
-> Show ForeignTiffCompression
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ForeignTiffCompression -> ShowS
showsPrec :: Int -> ForeignTiffCompression -> ShowS
$cshow :: ForeignTiffCompression -> String
show :: ForeignTiffCompression -> String
$cshowList :: [ForeignTiffCompression] -> ShowS
showList :: [ForeignTiffCompression] -> ShowS
Show, ForeignTiffCompression -> ForeignTiffCompression -> Bool
(ForeignTiffCompression -> ForeignTiffCompression -> Bool)
-> (ForeignTiffCompression -> ForeignTiffCompression -> Bool)
-> Eq ForeignTiffCompression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ForeignTiffCompression -> ForeignTiffCompression -> Bool
== :: ForeignTiffCompression -> ForeignTiffCompression -> Bool
$c/= :: ForeignTiffCompression -> ForeignTiffCompression -> Bool
/= :: ForeignTiffCompression -> ForeignTiffCompression -> Bool
Eq)

instance P.Enum ForeignTiffCompression where
    fromEnum :: ForeignTiffCompression -> Int
fromEnum ForeignTiffCompression
ForeignTiffCompressionNone = Int
0
    fromEnum ForeignTiffCompression
ForeignTiffCompressionJpeg = Int
1
    fromEnum ForeignTiffCompression
ForeignTiffCompressionDeflate = Int
2
    fromEnum ForeignTiffCompression
ForeignTiffCompressionPackbits = Int
3
    fromEnum ForeignTiffCompression
ForeignTiffCompressionCcittfax4 = Int
4
    fromEnum ForeignTiffCompression
ForeignTiffCompressionLzw = Int
5
    fromEnum ForeignTiffCompression
ForeignTiffCompressionWebp = Int
6
    fromEnum ForeignTiffCompression
ForeignTiffCompressionZstd = Int
7
    fromEnum ForeignTiffCompression
ForeignTiffCompressionJp2k = Int
8
    fromEnum ForeignTiffCompression
ForeignTiffCompressionLast = Int
9
    fromEnum (AnotherForeignTiffCompression Int
k) = Int
k

    toEnum :: Int -> ForeignTiffCompression
toEnum Int
0 = ForeignTiffCompression
ForeignTiffCompressionNone
    toEnum Int
1 = ForeignTiffCompression
ForeignTiffCompressionJpeg
    toEnum Int
2 = ForeignTiffCompression
ForeignTiffCompressionDeflate
    toEnum Int
3 = ForeignTiffCompression
ForeignTiffCompressionPackbits
    toEnum Int
4 = ForeignTiffCompression
ForeignTiffCompressionCcittfax4
    toEnum Int
5 = ForeignTiffCompression
ForeignTiffCompressionLzw
    toEnum Int
6 = ForeignTiffCompression
ForeignTiffCompressionWebp
    toEnum Int
7 = ForeignTiffCompression
ForeignTiffCompressionZstd
    toEnum Int
8 = ForeignTiffCompression
ForeignTiffCompressionJp2k
    toEnum Int
9 = ForeignTiffCompression
ForeignTiffCompressionLast
    toEnum Int
k = Int -> ForeignTiffCompression
AnotherForeignTiffCompression Int
k

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

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

foreign import ccall "vips_foreign_tiff_compression_get_type" c_vips_foreign_tiff_compression_get_type :: 
    IO GType

instance B.Types.TypedObject ForeignTiffCompression where
    glibType :: IO GType
glibType = IO GType
c_vips_foreign_tiff_compression_get_type

instance B.Types.BoxedEnum ForeignTiffCompression

-- Enum ForeignSubsample
-- | Set subsampling mode.
data ForeignSubsample = 
      ForeignSubsampleAuto
    -- ^ prevent subsampling when quality >= 90
    | ForeignSubsampleOn
    -- ^ always perform subsampling
    | ForeignSubsampleOff
    -- ^ never perform subsampling
    | ForeignSubsampleLast
    -- ^ /No description available in the introspection data./
    | AnotherForeignSubsample Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ForeignSubsample -> ShowS
[ForeignSubsample] -> ShowS
ForeignSubsample -> String
(Int -> ForeignSubsample -> ShowS)
-> (ForeignSubsample -> String)
-> ([ForeignSubsample] -> ShowS)
-> Show ForeignSubsample
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ForeignSubsample -> ShowS
showsPrec :: Int -> ForeignSubsample -> ShowS
$cshow :: ForeignSubsample -> String
show :: ForeignSubsample -> String
$cshowList :: [ForeignSubsample] -> ShowS
showList :: [ForeignSubsample] -> ShowS
Show, ForeignSubsample -> ForeignSubsample -> Bool
(ForeignSubsample -> ForeignSubsample -> Bool)
-> (ForeignSubsample -> ForeignSubsample -> Bool)
-> Eq ForeignSubsample
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ForeignSubsample -> ForeignSubsample -> Bool
== :: ForeignSubsample -> ForeignSubsample -> Bool
$c/= :: ForeignSubsample -> ForeignSubsample -> Bool
/= :: ForeignSubsample -> ForeignSubsample -> Bool
Eq)

instance P.Enum ForeignSubsample where
    fromEnum :: ForeignSubsample -> Int
fromEnum ForeignSubsample
ForeignSubsampleAuto = Int
0
    fromEnum ForeignSubsample
ForeignSubsampleOn = Int
1
    fromEnum ForeignSubsample
ForeignSubsampleOff = Int
2
    fromEnum ForeignSubsample
ForeignSubsampleLast = Int
3
    fromEnum (AnotherForeignSubsample Int
k) = Int
k

    toEnum :: Int -> ForeignSubsample
toEnum Int
0 = ForeignSubsample
ForeignSubsampleAuto
    toEnum Int
1 = ForeignSubsample
ForeignSubsampleOn
    toEnum Int
2 = ForeignSubsample
ForeignSubsampleOff
    toEnum Int
3 = ForeignSubsample
ForeignSubsampleLast
    toEnum Int
k = Int -> ForeignSubsample
AnotherForeignSubsample Int
k

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

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

foreign import ccall "vips_foreign_subsample_get_type" c_vips_foreign_subsample_get_type :: 
    IO GType

instance B.Types.TypedObject ForeignSubsample where
    glibType :: IO GType
glibType = IO GType
c_vips_foreign_subsample_get_type

instance B.Types.BoxedEnum ForeignSubsample

-- Enum ForeignPpmFormat
-- | The netpbm file format to save as.
-- 
-- @/VIPS_FOREIGN_PPM_FORMAT_PBM/@ images are single bit.
-- 
-- @/VIPS_FOREIGN_PPM_FORMAT_PGM/@ images are 8, 16, or 32-bits, one band.
-- 
-- @/VIPS_FOREIGN_PPM_FORMAT_PPM/@ images are 8, 16, or 32-bits, three bands.
-- 
-- @/VIPS_FOREIGN_PPM_FORMAT_PFM/@ images are 32-bit float pixels.
data ForeignPpmFormat = 
      ForeignPpmFormatPbm
    -- ^ portable bitmap
    | ForeignPpmFormatPgm
    -- ^ portable greymap
    | ForeignPpmFormatPpm
    -- ^ portable pixmap
    | ForeignPpmFormatPfm
    -- ^ portable float map
    | ForeignPpmFormatLast
    -- ^ /No description available in the introspection data./
    | AnotherForeignPpmFormat Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ForeignPpmFormat -> ShowS
[ForeignPpmFormat] -> ShowS
ForeignPpmFormat -> String
(Int -> ForeignPpmFormat -> ShowS)
-> (ForeignPpmFormat -> String)
-> ([ForeignPpmFormat] -> ShowS)
-> Show ForeignPpmFormat
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ForeignPpmFormat -> ShowS
showsPrec :: Int -> ForeignPpmFormat -> ShowS
$cshow :: ForeignPpmFormat -> String
show :: ForeignPpmFormat -> String
$cshowList :: [ForeignPpmFormat] -> ShowS
showList :: [ForeignPpmFormat] -> ShowS
Show, ForeignPpmFormat -> ForeignPpmFormat -> Bool
(ForeignPpmFormat -> ForeignPpmFormat -> Bool)
-> (ForeignPpmFormat -> ForeignPpmFormat -> Bool)
-> Eq ForeignPpmFormat
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ForeignPpmFormat -> ForeignPpmFormat -> Bool
== :: ForeignPpmFormat -> ForeignPpmFormat -> Bool
$c/= :: ForeignPpmFormat -> ForeignPpmFormat -> Bool
/= :: ForeignPpmFormat -> ForeignPpmFormat -> Bool
Eq)

instance P.Enum ForeignPpmFormat where
    fromEnum :: ForeignPpmFormat -> Int
fromEnum ForeignPpmFormat
ForeignPpmFormatPbm = Int
0
    fromEnum ForeignPpmFormat
ForeignPpmFormatPgm = Int
1
    fromEnum ForeignPpmFormat
ForeignPpmFormatPpm = Int
2
    fromEnum ForeignPpmFormat
ForeignPpmFormatPfm = Int
3
    fromEnum ForeignPpmFormat
ForeignPpmFormatLast = Int
4
    fromEnum (AnotherForeignPpmFormat Int
k) = Int
k

    toEnum :: Int -> ForeignPpmFormat
toEnum Int
0 = ForeignPpmFormat
ForeignPpmFormatPbm
    toEnum Int
1 = ForeignPpmFormat
ForeignPpmFormatPgm
    toEnum Int
2 = ForeignPpmFormat
ForeignPpmFormatPpm
    toEnum Int
3 = ForeignPpmFormat
ForeignPpmFormatPfm
    toEnum Int
4 = ForeignPpmFormat
ForeignPpmFormatLast
    toEnum Int
k = Int -> ForeignPpmFormat
AnotherForeignPpmFormat Int
k

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

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

foreign import ccall "vips_foreign_ppm_format_get_type" c_vips_foreign_ppm_format_get_type :: 
    IO GType

instance B.Types.TypedObject ForeignPpmFormat where
    glibType :: IO GType
glibType = IO GType
c_vips_foreign_ppm_format_get_type

instance B.Types.BoxedEnum ForeignPpmFormat

-- Enum ForeignJpegSubsample
{-# DEPRECATED ForeignJpegSubsample ["use t'GI.Vips.Enums.ForeignSubsample'"] #-}
-- | Set jpeg subsampling mode.
data ForeignJpegSubsample = 
      ForeignJpegSubsampleAuto
    -- ^ default preset
    | ForeignJpegSubsampleOn
    -- ^ always perform subsampling
    | ForeignJpegSubsampleOff
    -- ^ never perform subsampling
    | ForeignJpegSubsampleLast
    -- ^ /No description available in the introspection data./
    | AnotherForeignJpegSubsample Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ForeignJpegSubsample -> ShowS
[ForeignJpegSubsample] -> ShowS
ForeignJpegSubsample -> String
(Int -> ForeignJpegSubsample -> ShowS)
-> (ForeignJpegSubsample -> String)
-> ([ForeignJpegSubsample] -> ShowS)
-> Show ForeignJpegSubsample
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ForeignJpegSubsample -> ShowS
showsPrec :: Int -> ForeignJpegSubsample -> ShowS
$cshow :: ForeignJpegSubsample -> String
show :: ForeignJpegSubsample -> String
$cshowList :: [ForeignJpegSubsample] -> ShowS
showList :: [ForeignJpegSubsample] -> ShowS
Show, ForeignJpegSubsample -> ForeignJpegSubsample -> Bool
(ForeignJpegSubsample -> ForeignJpegSubsample -> Bool)
-> (ForeignJpegSubsample -> ForeignJpegSubsample -> Bool)
-> Eq ForeignJpegSubsample
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ForeignJpegSubsample -> ForeignJpegSubsample -> Bool
== :: ForeignJpegSubsample -> ForeignJpegSubsample -> Bool
$c/= :: ForeignJpegSubsample -> ForeignJpegSubsample -> Bool
/= :: ForeignJpegSubsample -> ForeignJpegSubsample -> Bool
Eq)

instance P.Enum ForeignJpegSubsample where
    fromEnum :: ForeignJpegSubsample -> Int
fromEnum ForeignJpegSubsample
ForeignJpegSubsampleAuto = Int
0
    fromEnum ForeignJpegSubsample
ForeignJpegSubsampleOn = Int
1
    fromEnum ForeignJpegSubsample
ForeignJpegSubsampleOff = Int
2
    fromEnum ForeignJpegSubsample
ForeignJpegSubsampleLast = Int
3
    fromEnum (AnotherForeignJpegSubsample Int
k) = Int
k

    toEnum :: Int -> ForeignJpegSubsample
toEnum Int
0 = ForeignJpegSubsample
ForeignJpegSubsampleAuto
    toEnum Int
1 = ForeignJpegSubsample
ForeignJpegSubsampleOn
    toEnum Int
2 = ForeignJpegSubsample
ForeignJpegSubsampleOff
    toEnum Int
3 = ForeignJpegSubsample
ForeignJpegSubsampleLast
    toEnum Int
k = Int -> ForeignJpegSubsample
AnotherForeignJpegSubsample Int
k

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

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

foreign import ccall "vips_foreign_jpeg_subsample_get_type" c_vips_foreign_jpeg_subsample_get_type :: 
    IO GType

instance B.Types.TypedObject ForeignJpegSubsample where
    glibType :: IO GType
glibType = IO GType
c_vips_foreign_jpeg_subsample_get_type

instance B.Types.BoxedEnum ForeignJpegSubsample

-- Enum ForeignHeifCompression
-- | The compression format to use inside a HEIF container.
-- 
-- This is assumed to use the same numbering as @/heif_compression_format/@.
data ForeignHeifCompression = 
      ForeignHeifCompressionHevc
    -- ^ x265
    | ForeignHeifCompressionAvc
    -- ^ x264
    | ForeignHeifCompressionJpeg
    -- ^ jpeg
    | ForeignHeifCompressionAv1
    -- ^ aom
    | ForeignHeifCompressionLast
    -- ^ /No description available in the introspection data./
    | AnotherForeignHeifCompression Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ForeignHeifCompression -> ShowS
[ForeignHeifCompression] -> ShowS
ForeignHeifCompression -> String
(Int -> ForeignHeifCompression -> ShowS)
-> (ForeignHeifCompression -> String)
-> ([ForeignHeifCompression] -> ShowS)
-> Show ForeignHeifCompression
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ForeignHeifCompression -> ShowS
showsPrec :: Int -> ForeignHeifCompression -> ShowS
$cshow :: ForeignHeifCompression -> String
show :: ForeignHeifCompression -> String
$cshowList :: [ForeignHeifCompression] -> ShowS
showList :: [ForeignHeifCompression] -> ShowS
Show, ForeignHeifCompression -> ForeignHeifCompression -> Bool
(ForeignHeifCompression -> ForeignHeifCompression -> Bool)
-> (ForeignHeifCompression -> ForeignHeifCompression -> Bool)
-> Eq ForeignHeifCompression
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ForeignHeifCompression -> ForeignHeifCompression -> Bool
== :: ForeignHeifCompression -> ForeignHeifCompression -> Bool
$c/= :: ForeignHeifCompression -> ForeignHeifCompression -> Bool
/= :: ForeignHeifCompression -> ForeignHeifCompression -> Bool
Eq)

instance P.Enum ForeignHeifCompression where
    fromEnum :: ForeignHeifCompression -> Int
fromEnum ForeignHeifCompression
ForeignHeifCompressionHevc = Int
1
    fromEnum ForeignHeifCompression
ForeignHeifCompressionAvc = Int
2
    fromEnum ForeignHeifCompression
ForeignHeifCompressionJpeg = Int
3
    fromEnum ForeignHeifCompression
ForeignHeifCompressionAv1 = Int
4
    fromEnum ForeignHeifCompression
ForeignHeifCompressionLast = Int
5
    fromEnum (AnotherForeignHeifCompression Int
k) = Int
k

    toEnum :: Int -> ForeignHeifCompression
toEnum Int
1 = ForeignHeifCompression
ForeignHeifCompressionHevc
    toEnum Int
2 = ForeignHeifCompression
ForeignHeifCompressionAvc
    toEnum Int
3 = ForeignHeifCompression
ForeignHeifCompressionJpeg
    toEnum Int
4 = ForeignHeifCompression
ForeignHeifCompressionAv1
    toEnum Int
5 = ForeignHeifCompression
ForeignHeifCompressionLast
    toEnum Int
k = Int -> ForeignHeifCompression
AnotherForeignHeifCompression Int
k

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

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

foreign import ccall "vips_foreign_heif_compression_get_type" c_vips_foreign_heif_compression_get_type :: 
    IO GType

instance B.Types.TypedObject ForeignHeifCompression where
    glibType :: IO GType
glibType = IO GType
c_vips_foreign_heif_compression_get_type

instance B.Types.BoxedEnum ForeignHeifCompression

-- Enum ForeignDzLayout
-- | What directory layout and metadata standard to use.
data ForeignDzLayout = 
      ForeignDzLayoutDz
    -- ^ use DeepZoom directory layout
    | ForeignDzLayoutZoomify
    -- ^ use Zoomify directory layout
    | ForeignDzLayoutGoogle
    -- ^ use Google maps directory layout
    | ForeignDzLayoutIiif
    -- ^ use IIIF v2 directory layout
    | ForeignDzLayoutIiif3
    -- ^ use IIIF v3 directory layout
    | ForeignDzLayoutLast
    -- ^ /No description available in the introspection data./
    | AnotherForeignDzLayout Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ForeignDzLayout -> ShowS
[ForeignDzLayout] -> ShowS
ForeignDzLayout -> String
(Int -> ForeignDzLayout -> ShowS)
-> (ForeignDzLayout -> String)
-> ([ForeignDzLayout] -> ShowS)
-> Show ForeignDzLayout
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ForeignDzLayout -> ShowS
showsPrec :: Int -> ForeignDzLayout -> ShowS
$cshow :: ForeignDzLayout -> String
show :: ForeignDzLayout -> String
$cshowList :: [ForeignDzLayout] -> ShowS
showList :: [ForeignDzLayout] -> ShowS
Show, ForeignDzLayout -> ForeignDzLayout -> Bool
(ForeignDzLayout -> ForeignDzLayout -> Bool)
-> (ForeignDzLayout -> ForeignDzLayout -> Bool)
-> Eq ForeignDzLayout
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ForeignDzLayout -> ForeignDzLayout -> Bool
== :: ForeignDzLayout -> ForeignDzLayout -> Bool
$c/= :: ForeignDzLayout -> ForeignDzLayout -> Bool
/= :: ForeignDzLayout -> ForeignDzLayout -> Bool
Eq)

instance P.Enum ForeignDzLayout where
    fromEnum :: ForeignDzLayout -> Int
fromEnum ForeignDzLayout
ForeignDzLayoutDz = Int
0
    fromEnum ForeignDzLayout
ForeignDzLayoutZoomify = Int
1
    fromEnum ForeignDzLayout
ForeignDzLayoutGoogle = Int
2
    fromEnum ForeignDzLayout
ForeignDzLayoutIiif = Int
3
    fromEnum ForeignDzLayout
ForeignDzLayoutIiif3 = Int
4
    fromEnum ForeignDzLayout
ForeignDzLayoutLast = Int
5
    fromEnum (AnotherForeignDzLayout Int
k) = Int
k

    toEnum :: Int -> ForeignDzLayout
toEnum Int
0 = ForeignDzLayout
ForeignDzLayoutDz
    toEnum Int
1 = ForeignDzLayout
ForeignDzLayoutZoomify
    toEnum Int
2 = ForeignDzLayout
ForeignDzLayoutGoogle
    toEnum Int
3 = ForeignDzLayout
ForeignDzLayoutIiif
    toEnum Int
4 = ForeignDzLayout
ForeignDzLayoutIiif3
    toEnum Int
5 = ForeignDzLayout
ForeignDzLayoutLast
    toEnum Int
k = Int -> ForeignDzLayout
AnotherForeignDzLayout Int
k

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

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

foreign import ccall "vips_foreign_dz_layout_get_type" c_vips_foreign_dz_layout_get_type :: 
    IO GType

instance B.Types.TypedObject ForeignDzLayout where
    glibType :: IO GType
glibType = IO GType
c_vips_foreign_dz_layout_get_type

instance B.Types.BoxedEnum ForeignDzLayout

-- Enum ForeignDzDepth
-- | How many pyramid layers to create.
data ForeignDzDepth = 
      ForeignDzDepthOnepixel
    -- ^ create layers down to 1x1 pixel
    | ForeignDzDepthOnetile
    -- ^ create layers down to 1x1 tile
    | ForeignDzDepthOne
    -- ^ only create a single layer
    | ForeignDzDepthLast
    -- ^ /No description available in the introspection data./
    | AnotherForeignDzDepth Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ForeignDzDepth -> ShowS
[ForeignDzDepth] -> ShowS
ForeignDzDepth -> String
(Int -> ForeignDzDepth -> ShowS)
-> (ForeignDzDepth -> String)
-> ([ForeignDzDepth] -> ShowS)
-> Show ForeignDzDepth
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ForeignDzDepth -> ShowS
showsPrec :: Int -> ForeignDzDepth -> ShowS
$cshow :: ForeignDzDepth -> String
show :: ForeignDzDepth -> String
$cshowList :: [ForeignDzDepth] -> ShowS
showList :: [ForeignDzDepth] -> ShowS
Show, ForeignDzDepth -> ForeignDzDepth -> Bool
(ForeignDzDepth -> ForeignDzDepth -> Bool)
-> (ForeignDzDepth -> ForeignDzDepth -> Bool) -> Eq ForeignDzDepth
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ForeignDzDepth -> ForeignDzDepth -> Bool
== :: ForeignDzDepth -> ForeignDzDepth -> Bool
$c/= :: ForeignDzDepth -> ForeignDzDepth -> Bool
/= :: ForeignDzDepth -> ForeignDzDepth -> Bool
Eq)

instance P.Enum ForeignDzDepth where
    fromEnum :: ForeignDzDepth -> Int
fromEnum ForeignDzDepth
ForeignDzDepthOnepixel = Int
0
    fromEnum ForeignDzDepth
ForeignDzDepthOnetile = Int
1
    fromEnum ForeignDzDepth
ForeignDzDepthOne = Int
2
    fromEnum ForeignDzDepth
ForeignDzDepthLast = Int
3
    fromEnum (AnotherForeignDzDepth Int
k) = Int
k

    toEnum :: Int -> ForeignDzDepth
toEnum Int
0 = ForeignDzDepth
ForeignDzDepthOnepixel
    toEnum Int
1 = ForeignDzDepth
ForeignDzDepthOnetile
    toEnum Int
2 = ForeignDzDepth
ForeignDzDepthOne
    toEnum Int
3 = ForeignDzDepth
ForeignDzDepthLast
    toEnum Int
k = Int -> ForeignDzDepth
AnotherForeignDzDepth Int
k

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

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

foreign import ccall "vips_foreign_dz_depth_get_type" c_vips_foreign_dz_depth_get_type :: 
    IO GType

instance B.Types.TypedObject ForeignDzDepth where
    glibType :: IO GType
glibType = IO GType
c_vips_foreign_dz_depth_get_type

instance B.Types.BoxedEnum ForeignDzDepth

-- Enum ForeignDzContainer
-- | How many pyramid layers to create.
data ForeignDzContainer = 
      ForeignDzContainerFs
    -- ^ write tiles to the filesystem
    | ForeignDzContainerZip
    -- ^ write tiles to a zip file
    | ForeignDzContainerSzi
    -- ^ write to a szi file
    | ForeignDzContainerLast
    -- ^ /No description available in the introspection data./
    | AnotherForeignDzContainer Int
    -- ^ Catch-all for unknown values
    deriving (Int -> ForeignDzContainer -> ShowS
[ForeignDzContainer] -> ShowS
ForeignDzContainer -> String
(Int -> ForeignDzContainer -> ShowS)
-> (ForeignDzContainer -> String)
-> ([ForeignDzContainer] -> ShowS)
-> Show ForeignDzContainer
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ForeignDzContainer -> ShowS
showsPrec :: Int -> ForeignDzContainer -> ShowS
$cshow :: ForeignDzContainer -> String
show :: ForeignDzContainer -> String
$cshowList :: [ForeignDzContainer] -> ShowS
showList :: [ForeignDzContainer] -> ShowS
Show, ForeignDzContainer -> ForeignDzContainer -> Bool
(ForeignDzContainer -> ForeignDzContainer -> Bool)
-> (ForeignDzContainer -> ForeignDzContainer -> Bool)
-> Eq ForeignDzContainer
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ForeignDzContainer -> ForeignDzContainer -> Bool
== :: ForeignDzContainer -> ForeignDzContainer -> Bool
$c/= :: ForeignDzContainer -> ForeignDzContainer -> Bool
/= :: ForeignDzContainer -> ForeignDzContainer -> Bool
Eq)

instance P.Enum ForeignDzContainer where
    fromEnum :: ForeignDzContainer -> Int
fromEnum ForeignDzContainer
ForeignDzContainerFs = Int
0
    fromEnum ForeignDzContainer
ForeignDzContainerZip = Int
1
    fromEnum ForeignDzContainer
ForeignDzContainerSzi = Int
2
    fromEnum ForeignDzContainer
ForeignDzContainerLast = Int
3
    fromEnum (AnotherForeignDzContainer Int
k) = Int
k

    toEnum :: Int -> ForeignDzContainer
toEnum Int
0 = ForeignDzContainer
ForeignDzContainerFs
    toEnum Int
1 = ForeignDzContainer
ForeignDzContainerZip
    toEnum Int
2 = ForeignDzContainer
ForeignDzContainerSzi
    toEnum Int
3 = ForeignDzContainer
ForeignDzContainerLast
    toEnum Int
k = Int -> ForeignDzContainer
AnotherForeignDzContainer Int
k

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

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

foreign import ccall "vips_foreign_dz_container_get_type" c_vips_foreign_dz_container_get_type :: 
    IO GType

instance B.Types.TypedObject ForeignDzContainer where
    glibType :: IO GType
glibType = IO GType
c_vips_foreign_dz_container_get_type

instance B.Types.BoxedEnum ForeignDzContainer

-- Enum FailOn
-- | How sensitive loaders are to errors, from never stop (very insensitive), to
-- stop on the smallest warning (very sensitive).
-- 
-- Each one implies the ones before it, so @/VIPS_FAIL_ON_ERROR/@ implies
-- @/VIPS_FAIL_ON_TRUNCATED/@.
data FailOn = 
      FailOnNone
    -- ^ never stop
    | FailOnTruncated
    -- ^ stop on image truncated, nothing else
    | FailOnError
    -- ^ stop on serious error or truncation
    | FailOnWarning
    -- ^ stop on anything, even warnings
    | FailOnLast
    -- ^ /No description available in the introspection data./
    | AnotherFailOn Int
    -- ^ Catch-all for unknown values
    deriving (Int -> FailOn -> ShowS
[FailOn] -> ShowS
FailOn -> String
(Int -> FailOn -> ShowS)
-> (FailOn -> String) -> ([FailOn] -> ShowS) -> Show FailOn
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FailOn -> ShowS
showsPrec :: Int -> FailOn -> ShowS
$cshow :: FailOn -> String
show :: FailOn -> String
$cshowList :: [FailOn] -> ShowS
showList :: [FailOn] -> ShowS
Show, FailOn -> FailOn -> Bool
(FailOn -> FailOn -> Bool)
-> (FailOn -> FailOn -> Bool) -> Eq FailOn
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FailOn -> FailOn -> Bool
== :: FailOn -> FailOn -> Bool
$c/= :: FailOn -> FailOn -> Bool
/= :: FailOn -> FailOn -> Bool
Eq)

instance P.Enum FailOn where
    fromEnum :: FailOn -> Int
fromEnum FailOn
FailOnNone = Int
0
    fromEnum FailOn
FailOnTruncated = Int
1
    fromEnum FailOn
FailOnError = Int
2
    fromEnum FailOn
FailOnWarning = Int
3
    fromEnum FailOn
FailOnLast = Int
4
    fromEnum (AnotherFailOn Int
k) = Int
k

    toEnum :: Int -> FailOn
toEnum Int
0 = FailOn
FailOnNone
    toEnum Int
1 = FailOn
FailOnTruncated
    toEnum Int
2 = FailOn
FailOnError
    toEnum Int
3 = FailOn
FailOnWarning
    toEnum Int
4 = FailOn
FailOnLast
    toEnum Int
k = Int -> FailOn
AnotherFailOn Int
k

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

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

foreign import ccall "vips_fail_on_get_type" c_vips_fail_on_get_type :: 
    IO GType

instance B.Types.TypedObject FailOn where
    glibType :: IO GType
glibType = IO GType
c_vips_fail_on_get_type

instance B.Types.BoxedEnum FailOn

-- Enum Extend
-- | See @/vips_embed()/@, @/vips_conv()/@, @/vips_affine()/@ and so on.
-- 
-- When the edges of an image are extended, you can specify
-- how you want the extension done.
-- 
-- @/VIPS_EXTEND_BLACK/@ --- new pixels are black, ie. all bits are zero.
-- 
-- @/VIPS_EXTEND_COPY/@ --- each new pixel takes the value of the nearest edge
-- pixel
-- 
-- @/VIPS_EXTEND_REPEAT/@ --- the image is tiled to fill the new area
-- 
-- @/VIPS_EXTEND_MIRROR/@ --- the image is reflected and tiled to reduce hash
-- edges
-- 
-- @/VIPS_EXTEND_WHITE/@ --- new pixels are white, ie. all bits are set
-- 
-- @/VIPS_EXTEND_BACKGROUND/@ --- colour set from the /@background@/ property
-- 
-- We have to specify the exact value of each enum member since we have to
-- keep these frozen for back compat with vips7.
-- 
-- See also: @/vips_embed()/@.
data Extend = 
      ExtendBlack
    -- ^ extend with black (all 0) pixels
    | ExtendCopy
    -- ^ copy the image edges
    | ExtendRepeat
    -- ^ repeat the whole image
    | ExtendMirror
    -- ^ mirror the whole image
    | ExtendWhite
    -- ^ extend with white (all bits set) pixels
    | ExtendBackground
    -- ^ extend with colour from the /@background@/ property
    | ExtendLast
    -- ^ /No description available in the introspection data./
    | AnotherExtend Int
    -- ^ Catch-all for unknown values
    deriving (Int -> Extend -> ShowS
[Extend] -> ShowS
Extend -> String
(Int -> Extend -> ShowS)
-> (Extend -> String) -> ([Extend] -> ShowS) -> Show Extend
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Extend -> ShowS
showsPrec :: Int -> Extend -> ShowS
$cshow :: Extend -> String
show :: Extend -> String
$cshowList :: [Extend] -> ShowS
showList :: [Extend] -> ShowS
Show, Extend -> Extend -> Bool
(Extend -> Extend -> Bool)
-> (Extend -> Extend -> Bool) -> Eq Extend
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Extend -> Extend -> Bool
== :: Extend -> Extend -> Bool
$c/= :: Extend -> Extend -> Bool
/= :: Extend -> Extend -> Bool
Eq)

instance P.Enum Extend where
    fromEnum :: Extend -> Int
fromEnum Extend
ExtendBlack = Int
0
    fromEnum Extend
ExtendCopy = Int
1
    fromEnum Extend
ExtendRepeat = Int
2
    fromEnum Extend
ExtendMirror = Int
3
    fromEnum Extend
ExtendWhite = Int
4
    fromEnum Extend
ExtendBackground = Int
5
    fromEnum Extend
ExtendLast = Int
6
    fromEnum (AnotherExtend Int
k) = Int
k

    toEnum :: Int -> Extend
toEnum Int
0 = Extend
ExtendBlack
    toEnum Int
1 = Extend
ExtendCopy
    toEnum Int
2 = Extend
ExtendRepeat
    toEnum Int
3 = Extend
ExtendMirror
    toEnum Int
4 = Extend
ExtendWhite
    toEnum Int
5 = Extend
ExtendBackground
    toEnum Int
6 = Extend
ExtendLast
    toEnum Int
k = Int -> Extend
AnotherExtend Int
k

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

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

foreign import ccall "vips_extend_get_type" c_vips_extend_get_type :: 
    IO GType

instance B.Types.TypedObject Extend where
    glibType :: IO GType
glibType = IO GType
c_vips_extend_get_type

instance B.Types.BoxedEnum Extend

-- Enum Direction
-- | See @/vips_flip()/@, @/vips_join()/@ and so on.
-- 
-- Operations like @/vips_flip()/@ need to be told whether to flip left-right or
-- top-bottom.
-- 
-- See also: @/vips_flip()/@, @/vips_join()/@.
data Direction = 
      DirectionHorizontal
    -- ^ left-right
    | DirectionVertical
    -- ^ top-bottom
    | DirectionLast
    -- ^ /No description available in the introspection data./
    | AnotherDirection Int
    -- ^ Catch-all for unknown values
    deriving (Int -> Direction -> ShowS
[Direction] -> ShowS
Direction -> String
(Int -> Direction -> ShowS)
-> (Direction -> String)
-> ([Direction] -> ShowS)
-> Show Direction
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Direction -> ShowS
showsPrec :: Int -> Direction -> ShowS
$cshow :: Direction -> String
show :: Direction -> String
$cshowList :: [Direction] -> ShowS
showList :: [Direction] -> ShowS
Show, Direction -> Direction -> Bool
(Direction -> Direction -> Bool)
-> (Direction -> Direction -> Bool) -> Eq Direction
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Direction -> Direction -> Bool
== :: Direction -> Direction -> Bool
$c/= :: Direction -> Direction -> Bool
/= :: Direction -> Direction -> Bool
Eq)

instance P.Enum Direction where
    fromEnum :: Direction -> Int
fromEnum Direction
DirectionHorizontal = Int
0
    fromEnum Direction
DirectionVertical = Int
1
    fromEnum Direction
DirectionLast = Int
2
    fromEnum (AnotherDirection Int
k) = Int
k

    toEnum :: Int -> Direction
toEnum Int
0 = Direction
DirectionHorizontal
    toEnum Int
1 = Direction
DirectionVertical
    toEnum Int
2 = Direction
DirectionLast
    toEnum Int
k = Int -> Direction
AnotherDirection Int
k

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

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

foreign import ccall "vips_direction_get_type" c_vips_direction_get_type :: 
    IO GType

instance B.Types.TypedObject Direction where
    glibType :: IO GType
glibType = IO GType
c_vips_direction_get_type

instance B.Types.BoxedEnum Direction

-- Enum DemandStyle
-- | See @/vips_image_pipelinev()/@. Operations can hint to the VIPS image IO
-- system about the kind of demand geometry they prefer.
-- 
-- These demand styles are given below in order of increasing
-- restrictiveness.  When demanding output from a pipeline,
-- @/vips_image_generate()/@
-- will use the most restrictive of the styles requested by the operations
-- in the pipeline.
-- 
-- @/VIPS_DEMAND_STYLE_THINSTRIP/@ --- This operation would like to output strips
-- the width of the image and a few pels high. This is option suitable for
-- point-to-point operations, such as those in the arithmetic package.
-- 
-- This option is only efficient for cases where each output pel depends
-- upon the pel in the corresponding position in the input image.
-- 
-- @/VIPS_DEMAND_STYLE_FATSTRIP/@ --- This operation would like to output strips
-- the width of the image and as high as possible. This option is suitable
-- for area operations which do not violently transform coordinates, such
-- as @/vips_conv()/@.
-- 
-- @/VIPS_DEMAND_STYLE_SMALLTILE/@ --- This is the most general demand format.
-- Output is demanded in small (around 100x100 pel) sections. This style works
-- reasonably efficiently, even for bizzare operations like 45 degree rotate.
-- 
-- @/VIPS_DEMAND_STYLE_ANY/@ --- This image is not being demand-read from a disc
-- file (even indirectly) so any demand style is OK. It\'s used for things like
-- @/vips_black()/@ where the pixels are calculated.
-- 
-- See also: @/vips_image_pipelinev()/@.
data DemandStyle = 
      DemandStyleError
    -- ^ /No description available in the introspection data./
    | DemandStyleSmalltile
    -- ^ demand in small (typically 64x64 pixel) tiles
    | DemandStyleFatstrip
    -- ^ demand in fat (typically 10 pixel high) strips
    | DemandStyleThinstrip
    -- ^ demand in thin (typically 1 pixel high) strips
    | DemandStyleAny
    -- ^ demand geometry does not matter
    | AnotherDemandStyle Int
    -- ^ Catch-all for unknown values
    deriving (Int -> DemandStyle -> ShowS
[DemandStyle] -> ShowS
DemandStyle -> String
(Int -> DemandStyle -> ShowS)
-> (DemandStyle -> String)
-> ([DemandStyle] -> ShowS)
-> Show DemandStyle
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DemandStyle -> ShowS
showsPrec :: Int -> DemandStyle -> ShowS
$cshow :: DemandStyle -> String
show :: DemandStyle -> String
$cshowList :: [DemandStyle] -> ShowS
showList :: [DemandStyle] -> ShowS
Show, DemandStyle -> DemandStyle -> Bool
(DemandStyle -> DemandStyle -> Bool)
-> (DemandStyle -> DemandStyle -> Bool) -> Eq DemandStyle
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DemandStyle -> DemandStyle -> Bool
== :: DemandStyle -> DemandStyle -> Bool
$c/= :: DemandStyle -> DemandStyle -> Bool
/= :: DemandStyle -> DemandStyle -> Bool
Eq)

instance P.Enum DemandStyle where
    fromEnum :: DemandStyle -> Int
fromEnum DemandStyle
DemandStyleError = Int
-1
    fromEnum DemandStyle
DemandStyleSmalltile = Int
0
    fromEnum DemandStyle
DemandStyleFatstrip = Int
1
    fromEnum DemandStyle
DemandStyleThinstrip = Int
2
    fromEnum DemandStyle
DemandStyleAny = Int
3
    fromEnum (AnotherDemandStyle Int
k) = Int
k

    toEnum :: Int -> DemandStyle
toEnum Int
-1 = DemandStyle
DemandStyleError
    toEnum Int
0 = DemandStyle
DemandStyleSmalltile
    toEnum Int
1 = DemandStyle
DemandStyleFatstrip
    toEnum Int
2 = DemandStyle
DemandStyleThinstrip
    toEnum Int
3 = DemandStyle
DemandStyleAny
    toEnum Int
k = Int -> DemandStyle
AnotherDemandStyle Int
k

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

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

foreign import ccall "vips_demand_style_get_type" c_vips_demand_style_get_type :: 
    IO GType

instance B.Types.TypedObject DemandStyle where
    glibType :: IO GType
glibType = IO GType
c_vips_demand_style_get_type

instance B.Types.BoxedEnum DemandStyle

-- Enum CompassDirection
-- | A direction on a compass. Used for @/vips_gravity()/@, for example.
data CompassDirection = 
      CompassDirectionCentre
    -- ^ centre
    | CompassDirectionNorth
    -- ^ north
    | CompassDirectionEast
    -- ^ east
    | CompassDirectionSouth
    -- ^ south
    | CompassDirectionWest
    -- ^ west
    | CompassDirectionNorthEast
    -- ^ north-east
    | CompassDirectionSouthEast
    -- ^ south-east
    | CompassDirectionSouthWest
    -- ^ south-west
    | CompassDirectionNorthWest
    -- ^ north-west
    | CompassDirectionLast
    -- ^ /No description available in the introspection data./
    | AnotherCompassDirection Int
    -- ^ Catch-all for unknown values
    deriving (Int -> CompassDirection -> ShowS
[CompassDirection] -> ShowS
CompassDirection -> String
(Int -> CompassDirection -> ShowS)
-> (CompassDirection -> String)
-> ([CompassDirection] -> ShowS)
-> Show CompassDirection
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CompassDirection -> ShowS
showsPrec :: Int -> CompassDirection -> ShowS
$cshow :: CompassDirection -> String
show :: CompassDirection -> String
$cshowList :: [CompassDirection] -> ShowS
showList :: [CompassDirection] -> ShowS
Show, CompassDirection -> CompassDirection -> Bool
(CompassDirection -> CompassDirection -> Bool)
-> (CompassDirection -> CompassDirection -> Bool)
-> Eq CompassDirection
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CompassDirection -> CompassDirection -> Bool
== :: CompassDirection -> CompassDirection -> Bool
$c/= :: CompassDirection -> CompassDirection -> Bool
/= :: CompassDirection -> CompassDirection -> Bool
Eq)

instance P.Enum CompassDirection where
    fromEnum :: CompassDirection -> Int
fromEnum CompassDirection
CompassDirectionCentre = Int
0
    fromEnum CompassDirection
CompassDirectionNorth = Int
1
    fromEnum CompassDirection
CompassDirectionEast = Int
2
    fromEnum CompassDirection
CompassDirectionSouth = Int
3
    fromEnum CompassDirection
CompassDirectionWest = Int
4
    fromEnum CompassDirection
CompassDirectionNorthEast = Int
5
    fromEnum CompassDirection
CompassDirectionSouthEast = Int
6
    fromEnum CompassDirection
CompassDirectionSouthWest = Int
7
    fromEnum CompassDirection
CompassDirectionNorthWest = Int
8
    fromEnum CompassDirection
CompassDirectionLast = Int
9
    fromEnum (AnotherCompassDirection Int
k) = Int
k

    toEnum :: Int -> CompassDirection
toEnum Int
0 = CompassDirection
CompassDirectionCentre
    toEnum Int
1 = CompassDirection
CompassDirectionNorth
    toEnum Int
2 = CompassDirection
CompassDirectionEast
    toEnum Int
3 = CompassDirection
CompassDirectionSouth
    toEnum Int
4 = CompassDirection
CompassDirectionWest
    toEnum Int
5 = CompassDirection
CompassDirectionNorthEast
    toEnum Int
6 = CompassDirection
CompassDirectionSouthEast
    toEnum Int
7 = CompassDirection
CompassDirectionSouthWest
    toEnum Int
8 = CompassDirection
CompassDirectionNorthWest
    toEnum Int
9 = CompassDirection
CompassDirectionLast
    toEnum Int
k = Int -> CompassDirection
AnotherCompassDirection Int
k

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

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

foreign import ccall "vips_compass_direction_get_type" c_vips_compass_direction_get_type :: 
    IO GType

instance B.Types.TypedObject CompassDirection where
    glibType :: IO GType
glibType = IO GType
c_vips_compass_direction_get_type

instance B.Types.BoxedEnum CompassDirection

-- Enum CombineMode
-- | See @/vips_draw_image()/@ and so on.
-- 
-- Operations like @/vips_draw_image()/@ need to be told how to combine images
-- from two sources.
-- 
-- See also: @/vips_join()/@.
data CombineMode = 
      CombineModeSet
    -- ^ set pixels to the new value
    | CombineModeAdd
    -- ^ add pixels
    | CombineModeLast
    -- ^ /No description available in the introspection data./
    | AnotherCombineMode Int
    -- ^ Catch-all for unknown values
    deriving (Int -> CombineMode -> ShowS
[CombineMode] -> ShowS
CombineMode -> String
(Int -> CombineMode -> ShowS)
-> (CombineMode -> String)
-> ([CombineMode] -> ShowS)
-> Show CombineMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CombineMode -> ShowS
showsPrec :: Int -> CombineMode -> ShowS
$cshow :: CombineMode -> String
show :: CombineMode -> String
$cshowList :: [CombineMode] -> ShowS
showList :: [CombineMode] -> ShowS
Show, CombineMode -> CombineMode -> Bool
(CombineMode -> CombineMode -> Bool)
-> (CombineMode -> CombineMode -> Bool) -> Eq CombineMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CombineMode -> CombineMode -> Bool
== :: CombineMode -> CombineMode -> Bool
$c/= :: CombineMode -> CombineMode -> Bool
/= :: CombineMode -> CombineMode -> Bool
Eq)

instance P.Enum CombineMode where
    fromEnum :: CombineMode -> Int
fromEnum CombineMode
CombineModeSet = Int
0
    fromEnum CombineMode
CombineModeAdd = Int
1
    fromEnum CombineMode
CombineModeLast = Int
2
    fromEnum (AnotherCombineMode Int
k) = Int
k

    toEnum :: Int -> CombineMode
toEnum Int
0 = CombineMode
CombineModeSet
    toEnum Int
1 = CombineMode
CombineModeAdd
    toEnum Int
2 = CombineMode
CombineModeLast
    toEnum Int
k = Int -> CombineMode
AnotherCombineMode Int
k

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

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

foreign import ccall "vips_combine_mode_get_type" c_vips_combine_mode_get_type :: 
    IO GType

instance B.Types.TypedObject CombineMode where
    glibType :: IO GType
glibType = IO GType
c_vips_combine_mode_get_type

instance B.Types.BoxedEnum CombineMode

-- Enum Combine
-- | How to combine values. See @/vips_compass()/@, for example.
data Combine = 
      CombineMax
    -- ^ take the maximum of the possible values
    | CombineSum
    -- ^ sum all the values
    | CombineMin
    -- ^ take the minimum value
    | CombineLast
    -- ^ /No description available in the introspection data./
    | AnotherCombine Int
    -- ^ Catch-all for unknown values
    deriving (Int -> Combine -> ShowS
[Combine] -> ShowS
Combine -> String
(Int -> Combine -> ShowS)
-> (Combine -> String) -> ([Combine] -> ShowS) -> Show Combine
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Combine -> ShowS
showsPrec :: Int -> Combine -> ShowS
$cshow :: Combine -> String
show :: Combine -> String
$cshowList :: [Combine] -> ShowS
showList :: [Combine] -> ShowS
Show, Combine -> Combine -> Bool
(Combine -> Combine -> Bool)
-> (Combine -> Combine -> Bool) -> Eq Combine
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Combine -> Combine -> Bool
== :: Combine -> Combine -> Bool
$c/= :: Combine -> Combine -> Bool
/= :: Combine -> Combine -> Bool
Eq)

instance P.Enum Combine where
    fromEnum :: Combine -> Int
fromEnum Combine
CombineMax = Int
0
    fromEnum Combine
CombineSum = Int
1
    fromEnum Combine
CombineMin = Int
2
    fromEnum Combine
CombineLast = Int
3
    fromEnum (AnotherCombine Int
k) = Int
k

    toEnum :: Int -> Combine
toEnum Int
0 = Combine
CombineMax
    toEnum Int
1 = Combine
CombineSum
    toEnum Int
2 = Combine
CombineMin
    toEnum Int
3 = Combine
CombineLast
    toEnum Int
k = Int -> Combine
AnotherCombine Int
k

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

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

foreign import ccall "vips_combine_get_type" c_vips_combine_get_type :: 
    IO GType

instance B.Types.TypedObject Combine where
    glibType :: IO GType
glibType = IO GType
c_vips_combine_get_type

instance B.Types.BoxedEnum Combine

-- Enum Coding
-- | How pixels are coded.
-- 
-- Normally, pixels are uncoded and can be manipulated as you would expect.
-- However some file formats code pixels for compression, and sometimes it\'s
-- useful to be able to manipulate images in the coded format.
-- 
-- The gaps in the numbering are historical and must be maintained. Allocate
-- new numbers from the end.
data Coding = 
      CodingError
    -- ^ /No description available in the introspection data./
    | CodingNone
    -- ^ pixels are not coded
    | CodingLabq
    -- ^ pixels encode 3 float CIELAB values as 4 uchar
    | CodingRad
    -- ^ pixels encode 3 float RGB as 4 uchar (Radiance coding)
    | CodingLast
    -- ^ /No description available in the introspection data./
    | AnotherCoding Int
    -- ^ Catch-all for unknown values
    deriving (Int -> Coding -> ShowS
[Coding] -> ShowS
Coding -> String
(Int -> Coding -> ShowS)
-> (Coding -> String) -> ([Coding] -> ShowS) -> Show Coding
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Coding -> ShowS
showsPrec :: Int -> Coding -> ShowS
$cshow :: Coding -> String
show :: Coding -> String
$cshowList :: [Coding] -> ShowS
showList :: [Coding] -> ShowS
Show, Coding -> Coding -> Bool
(Coding -> Coding -> Bool)
-> (Coding -> Coding -> Bool) -> Eq Coding
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Coding -> Coding -> Bool
== :: Coding -> Coding -> Bool
$c/= :: Coding -> Coding -> Bool
/= :: Coding -> Coding -> Bool
Eq)

instance P.Enum Coding where
    fromEnum :: Coding -> Int
fromEnum Coding
CodingError = Int
-1
    fromEnum Coding
CodingNone = Int
0
    fromEnum Coding
CodingLabq = Int
2
    fromEnum Coding
CodingRad = Int
6
    fromEnum Coding
CodingLast = Int
7
    fromEnum (AnotherCoding Int
k) = Int
k

    toEnum :: Int -> Coding
toEnum Int
-1 = Coding
CodingError
    toEnum Int
0 = Coding
CodingNone
    toEnum Int
2 = Coding
CodingLabq
    toEnum Int
6 = Coding
CodingRad
    toEnum Int
7 = Coding
CodingLast
    toEnum Int
k = Int -> Coding
AnotherCoding Int
k

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

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

foreign import ccall "vips_coding_get_type" c_vips_coding_get_type :: 
    IO GType

instance B.Types.TypedObject Coding where
    glibType :: IO GType
glibType = IO GType
c_vips_coding_get_type

instance B.Types.BoxedEnum Coding

-- Enum BlendMode
-- | The various Porter-Duff and PDF blend modes. See @/vips_composite()/@,
-- for example.
-- 
-- The Cairo docs have a nice explanation of all the blend modes:
-- 
-- https:\/\/www.cairographics.org\/operators
-- 
-- The non-separable modes are not implemented.
data BlendMode = 
      BlendModeClear
    -- ^ where the second object is drawn, the first is removed
    | BlendModeSource
    -- ^ the second object is drawn as if nothing were below
    | BlendModeOver
    -- ^ the image shows what you would expect if you held two semi-transparent slides on top of each other
    | BlendModeIn
    -- ^ the first object is removed completely, the second is only drawn where the first was
    | BlendModeOut
    -- ^ the second is drawn only where the first isn\'t
    | BlendModeAtop
    -- ^ this leaves the first object mostly intact, but mixes both objects in the overlapping area
    | BlendModeDest
    -- ^ leaves the first object untouched, the second is discarded completely
    | BlendModeDestOver
    -- ^ like OVER, but swaps the arguments
    | BlendModeDestIn
    -- ^ like IN, but swaps the arguments
    | BlendModeDestOut
    -- ^ like OUT, but swaps the arguments
    | BlendModeDestAtop
    -- ^ like ATOP, but swaps the arguments
    | BlendModeXor
    -- ^ something like a difference operator
    | BlendModeAdd
    -- ^ a bit like adding the two images
    | BlendModeSaturate
    -- ^ a bit like the darker of the two
    | BlendModeMultiply
    -- ^ at least as dark as the darker of the two inputs
    | BlendModeScreen
    -- ^ at least as light as the lighter of the inputs
    | BlendModeOverlay
    -- ^ multiplies or screens colors, depending on the lightness
    | BlendModeDarken
    -- ^ the darker of each component
    | BlendModeLighten
    -- ^ the lighter of each component
    | BlendModeColourDodge
    -- ^ brighten first by a factor second
    | BlendModeColourBurn
    -- ^ darken first by a factor of second
    | BlendModeHardLight
    -- ^ multiply or screen, depending on lightness
    | BlendModeSoftLight
    -- ^ darken or lighten, depending on lightness
    | BlendModeDifference
    -- ^ difference of the two
    | BlendModeExclusion
    -- ^ somewhat like DIFFERENCE, but lower-contrast
    | BlendModeLast
    -- ^ /No description available in the introspection data./
    | AnotherBlendMode Int
    -- ^ Catch-all for unknown values
    deriving (Int -> BlendMode -> ShowS
[BlendMode] -> ShowS
BlendMode -> String
(Int -> BlendMode -> ShowS)
-> (BlendMode -> String)
-> ([BlendMode] -> ShowS)
-> Show BlendMode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BlendMode -> ShowS
showsPrec :: Int -> BlendMode -> ShowS
$cshow :: BlendMode -> String
show :: BlendMode -> String
$cshowList :: [BlendMode] -> ShowS
showList :: [BlendMode] -> ShowS
Show, BlendMode -> BlendMode -> Bool
(BlendMode -> BlendMode -> Bool)
-> (BlendMode -> BlendMode -> Bool) -> Eq BlendMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BlendMode -> BlendMode -> Bool
== :: BlendMode -> BlendMode -> Bool
$c/= :: BlendMode -> BlendMode -> Bool
/= :: BlendMode -> BlendMode -> Bool
Eq)

instance P.Enum BlendMode where
    fromEnum :: BlendMode -> Int
fromEnum BlendMode
BlendModeClear = Int
0
    fromEnum BlendMode
BlendModeSource = Int
1
    fromEnum BlendMode
BlendModeOver = Int
2
    fromEnum BlendMode
BlendModeIn = Int
3
    fromEnum BlendMode
BlendModeOut = Int
4
    fromEnum BlendMode
BlendModeAtop = Int
5
    fromEnum BlendMode
BlendModeDest = Int
6
    fromEnum BlendMode
BlendModeDestOver = Int
7
    fromEnum BlendMode
BlendModeDestIn = Int
8
    fromEnum BlendMode
BlendModeDestOut = Int
9
    fromEnum BlendMode
BlendModeDestAtop = Int
10
    fromEnum BlendMode
BlendModeXor = Int
11
    fromEnum BlendMode
BlendModeAdd = Int
12
    fromEnum BlendMode
BlendModeSaturate = Int
13
    fromEnum BlendMode
BlendModeMultiply = Int
14
    fromEnum BlendMode
BlendModeScreen = Int
15
    fromEnum BlendMode
BlendModeOverlay = Int
16
    fromEnum BlendMode
BlendModeDarken = Int
17
    fromEnum BlendMode
BlendModeLighten = Int
18
    fromEnum BlendMode
BlendModeColourDodge = Int
19
    fromEnum BlendMode
BlendModeColourBurn = Int
20
    fromEnum BlendMode
BlendModeHardLight = Int
21
    fromEnum BlendMode
BlendModeSoftLight = Int
22
    fromEnum BlendMode
BlendModeDifference = Int
23
    fromEnum BlendMode
BlendModeExclusion = Int
24
    fromEnum BlendMode
BlendModeLast = Int
25
    fromEnum (AnotherBlendMode Int
k) = Int
k

    toEnum :: Int -> BlendMode
toEnum Int
0 = BlendMode
BlendModeClear
    toEnum Int
1 = BlendMode
BlendModeSource
    toEnum Int
2 = BlendMode
BlendModeOver
    toEnum Int
3 = BlendMode
BlendModeIn
    toEnum Int
4 = BlendMode
BlendModeOut
    toEnum Int
5 = BlendMode
BlendModeAtop
    toEnum Int
6 = BlendMode
BlendModeDest
    toEnum Int
7 = BlendMode
BlendModeDestOver
    toEnum Int
8 = BlendMode
BlendModeDestIn
    toEnum Int
9 = BlendMode
BlendModeDestOut
    toEnum Int
10 = BlendMode
BlendModeDestAtop
    toEnum Int
11 = BlendMode
BlendModeXor
    toEnum Int
12 = BlendMode
BlendModeAdd
    toEnum Int
13 = BlendMode
BlendModeSaturate
    toEnum Int
14 = BlendMode
BlendModeMultiply
    toEnum Int
15 = BlendMode
BlendModeScreen
    toEnum Int
16 = BlendMode
BlendModeOverlay
    toEnum Int
17 = BlendMode
BlendModeDarken
    toEnum Int
18 = BlendMode
BlendModeLighten
    toEnum Int
19 = BlendMode
BlendModeColourDodge
    toEnum Int
20 = BlendMode
BlendModeColourBurn
    toEnum Int
21 = BlendMode
BlendModeHardLight
    toEnum Int
22 = BlendMode
BlendModeSoftLight
    toEnum Int
23 = BlendMode
BlendModeDifference
    toEnum Int
24 = BlendMode
BlendModeExclusion
    toEnum Int
25 = BlendMode
BlendModeLast
    toEnum Int
k = Int -> BlendMode
AnotherBlendMode Int
k

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

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

foreign import ccall "vips_blend_mode_get_type" c_vips_blend_mode_get_type :: 
    IO GType

instance B.Types.TypedObject BlendMode where
    glibType :: IO GType
glibType = IO GType
c_vips_blend_mode_get_type

instance B.Types.BoxedEnum BlendMode

-- Enum BandFormat
-- | The format used for each band element.
-- 
-- Each corresponds to a native C type for the current machine. For example,
-- @/VIPS_FORMAT_USHORT/@ is \<type>unsigned short\<\/type>.
data BandFormat = 
      BandFormatNotset
    -- ^ invalid setting
    | BandFormatUchar
    -- ^ unsigned char format
    | BandFormatChar
    -- ^ char format
    | BandFormatUshort
    -- ^ unsigned short format
    | BandFormatShort
    -- ^ short format
    | BandFormatUint
    -- ^ unsigned int format
    | BandFormatInt
    -- ^ int format
    | BandFormatFloat
    -- ^ float format
    | BandFormatComplex
    -- ^ complex (two floats) format
    | BandFormatDouble
    -- ^ double float format
    | BandFormatDpcomplex
    -- ^ double complex (two double) format
    | BandFormatLast
    -- ^ /No description available in the introspection data./
    | AnotherBandFormat Int
    -- ^ Catch-all for unknown values
    deriving (Int -> BandFormat -> ShowS
[BandFormat] -> ShowS
BandFormat -> String
(Int -> BandFormat -> ShowS)
-> (BandFormat -> String)
-> ([BandFormat] -> ShowS)
-> Show BandFormat
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> BandFormat -> ShowS
showsPrec :: Int -> BandFormat -> ShowS
$cshow :: BandFormat -> String
show :: BandFormat -> String
$cshowList :: [BandFormat] -> ShowS
showList :: [BandFormat] -> ShowS
Show, BandFormat -> BandFormat -> Bool
(BandFormat -> BandFormat -> Bool)
-> (BandFormat -> BandFormat -> Bool) -> Eq BandFormat
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BandFormat -> BandFormat -> Bool
== :: BandFormat -> BandFormat -> Bool
$c/= :: BandFormat -> BandFormat -> Bool
/= :: BandFormat -> BandFormat -> Bool
Eq)

instance P.Enum BandFormat where
    fromEnum :: BandFormat -> Int
fromEnum BandFormat
BandFormatNotset = Int
-1
    fromEnum BandFormat
BandFormatUchar = Int
0
    fromEnum BandFormat
BandFormatChar = Int
1
    fromEnum BandFormat
BandFormatUshort = Int
2
    fromEnum BandFormat
BandFormatShort = Int
3
    fromEnum BandFormat
BandFormatUint = Int
4
    fromEnum BandFormat
BandFormatInt = Int
5
    fromEnum BandFormat
BandFormatFloat = Int
6
    fromEnum BandFormat
BandFormatComplex = Int
7
    fromEnum BandFormat
BandFormatDouble = Int
8
    fromEnum BandFormat
BandFormatDpcomplex = Int
9
    fromEnum BandFormat
BandFormatLast = Int
10
    fromEnum (AnotherBandFormat Int
k) = Int
k

    toEnum :: Int -> BandFormat
toEnum Int
-1 = BandFormat
BandFormatNotset
    toEnum Int
0 = BandFormat
BandFormatUchar
    toEnum Int
1 = BandFormat
BandFormatChar
    toEnum Int
2 = BandFormat
BandFormatUshort
    toEnum Int
3 = BandFormat
BandFormatShort
    toEnum Int
4 = BandFormat
BandFormatUint
    toEnum Int
5 = BandFormat
BandFormatInt
    toEnum Int
6 = BandFormat
BandFormatFloat
    toEnum Int
7 = BandFormat
BandFormatComplex
    toEnum Int
8 = BandFormat
BandFormatDouble
    toEnum Int
9 = BandFormat
BandFormatDpcomplex
    toEnum Int
10 = BandFormat
BandFormatLast
    toEnum Int
k = Int -> BandFormat
AnotherBandFormat Int
k

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

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

foreign import ccall "vips_band_format_get_type" c_vips_band_format_get_type :: 
    IO GType

instance B.Types.TypedObject BandFormat where
    glibType :: IO GType
glibType = IO GType
c_vips_band_format_get_type

instance B.Types.BoxedEnum BandFormat

-- Enum Angle45
-- | See @/vips_rot45()/@ and so on.
-- 
-- Fixed rotate angles.
-- 
-- See also: @/vips_rot45()/@.
data Angle45 = 
      Angle45D0
    -- ^ no rotate
    | Angle45D45
    -- ^ 45 degrees clockwise
    | Angle45D90
    -- ^ 90 degrees clockwise
    | Angle45D135
    -- ^ 135 degrees clockwise
    | Angle45D180
    -- ^ 180 degrees
    | Angle45D225
    -- ^ 135 degrees anti-clockwise
    | Angle45D270
    -- ^ 90 degrees anti-clockwise
    | Angle45D315
    -- ^ 45 degrees anti-clockwise
    | Angle45Last
    -- ^ /No description available in the introspection data./
    | AnotherAngle45 Int
    -- ^ Catch-all for unknown values
    deriving (Int -> Angle45 -> ShowS
[Angle45] -> ShowS
Angle45 -> String
(Int -> Angle45 -> ShowS)
-> (Angle45 -> String) -> ([Angle45] -> ShowS) -> Show Angle45
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Angle45 -> ShowS
showsPrec :: Int -> Angle45 -> ShowS
$cshow :: Angle45 -> String
show :: Angle45 -> String
$cshowList :: [Angle45] -> ShowS
showList :: [Angle45] -> ShowS
Show, Angle45 -> Angle45 -> Bool
(Angle45 -> Angle45 -> Bool)
-> (Angle45 -> Angle45 -> Bool) -> Eq Angle45
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Angle45 -> Angle45 -> Bool
== :: Angle45 -> Angle45 -> Bool
$c/= :: Angle45 -> Angle45 -> Bool
/= :: Angle45 -> Angle45 -> Bool
Eq)

instance P.Enum Angle45 where
    fromEnum :: Angle45 -> Int
fromEnum Angle45
Angle45D0 = Int
0
    fromEnum Angle45
Angle45D45 = Int
1
    fromEnum Angle45
Angle45D90 = Int
2
    fromEnum Angle45
Angle45D135 = Int
3
    fromEnum Angle45
Angle45D180 = Int
4
    fromEnum Angle45
Angle45D225 = Int
5
    fromEnum Angle45
Angle45D270 = Int
6
    fromEnum Angle45
Angle45D315 = Int
7
    fromEnum Angle45
Angle45Last = Int
8
    fromEnum (AnotherAngle45 Int
k) = Int
k

    toEnum :: Int -> Angle45
toEnum Int
0 = Angle45
Angle45D0
    toEnum Int
1 = Angle45
Angle45D45
    toEnum Int
2 = Angle45
Angle45D90
    toEnum Int
3 = Angle45
Angle45D135
    toEnum Int
4 = Angle45
Angle45D180
    toEnum Int
5 = Angle45
Angle45D225
    toEnum Int
6 = Angle45
Angle45D270
    toEnum Int
7 = Angle45
Angle45D315
    toEnum Int
8 = Angle45
Angle45Last
    toEnum Int
k = Int -> Angle45
AnotherAngle45 Int
k

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

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

foreign import ccall "vips_angle45_get_type" c_vips_angle45_get_type :: 
    IO GType

instance B.Types.TypedObject Angle45 where
    glibType :: IO GType
glibType = IO GType
c_vips_angle45_get_type

instance B.Types.BoxedEnum Angle45

-- Enum Angle
-- | See @/vips_rot()/@ and so on.
-- 
-- Fixed rotate angles.
-- 
-- See also: @/vips_rot()/@.
data Angle = 
      AngleD0
    -- ^ no rotate
    | AngleD90
    -- ^ 90 degrees clockwise
    | AngleD180
    -- ^ 180 degree rotate
    | AngleD270
    -- ^ 90 degrees anti-clockwise
    | AngleLast
    -- ^ /No description available in the introspection data./
    | AnotherAngle Int
    -- ^ Catch-all for unknown values
    deriving (Int -> Angle -> ShowS
[Angle] -> ShowS
Angle -> String
(Int -> Angle -> ShowS)
-> (Angle -> String) -> ([Angle] -> ShowS) -> Show Angle
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Angle -> ShowS
showsPrec :: Int -> Angle -> ShowS
$cshow :: Angle -> String
show :: Angle -> String
$cshowList :: [Angle] -> ShowS
showList :: [Angle] -> ShowS
Show, Angle -> Angle -> Bool
(Angle -> Angle -> Bool) -> (Angle -> Angle -> Bool) -> Eq Angle
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Angle -> Angle -> Bool
== :: Angle -> Angle -> Bool
$c/= :: Angle -> Angle -> Bool
/= :: Angle -> Angle -> Bool
Eq)

instance P.Enum Angle where
    fromEnum :: Angle -> Int
fromEnum Angle
AngleD0 = Int
0
    fromEnum Angle
AngleD90 = Int
1
    fromEnum Angle
AngleD180 = Int
2
    fromEnum Angle
AngleD270 = Int
3
    fromEnum Angle
AngleLast = Int
4
    fromEnum (AnotherAngle Int
k) = Int
k

    toEnum :: Int -> Angle
toEnum Int
0 = Angle
AngleD0
    toEnum Int
1 = Angle
AngleD90
    toEnum Int
2 = Angle
AngleD180
    toEnum Int
3 = Angle
AngleD270
    toEnum Int
4 = Angle
AngleLast
    toEnum Int
k = Int -> Angle
AnotherAngle Int
k

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

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

foreign import ccall "vips_angle_get_type" c_vips_angle_get_type :: 
    IO GType

instance B.Types.TypedObject Angle where
    glibType :: IO GType
glibType = IO GType
c_vips_angle_get_type

instance B.Types.BoxedEnum Angle

-- Enum Align
-- | See @/vips_join()/@ and so on.
-- 
-- Operations like @/vips_join()/@ need to be told whether to align images on the
-- low or high coordinate edge, or centre.
-- 
-- See also: @/vips_join()/@.
data Align = 
      AlignLow
    -- ^ align low coordinate edge
    | AlignCentre
    -- ^ align centre
    | AlignHigh
    -- ^ align high coordinate edge
    | AlignLast
    -- ^ /No description available in the introspection data./
    | AnotherAlign Int
    -- ^ Catch-all for unknown values
    deriving (Int -> Align -> ShowS
[Align] -> ShowS
Align -> String
(Int -> Align -> ShowS)
-> (Align -> String) -> ([Align] -> ShowS) -> Show Align
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Align -> ShowS
showsPrec :: Int -> Align -> ShowS
$cshow :: Align -> String
show :: Align -> String
$cshowList :: [Align] -> ShowS
showList :: [Align] -> ShowS
Show, Align -> Align -> Bool
(Align -> Align -> Bool) -> (Align -> Align -> Bool) -> Eq Align
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Align -> Align -> Bool
== :: Align -> Align -> Bool
$c/= :: Align -> Align -> Bool
/= :: Align -> Align -> Bool
Eq)

instance P.Enum Align where
    fromEnum :: Align -> Int
fromEnum Align
AlignLow = Int
0
    fromEnum Align
AlignCentre = Int
1
    fromEnum Align
AlignHigh = Int
2
    fromEnum Align
AlignLast = Int
3
    fromEnum (AnotherAlign Int
k) = Int
k

    toEnum :: Int -> Align
toEnum Int
0 = Align
AlignLow
    toEnum Int
1 = Align
AlignCentre
    toEnum Int
2 = Align
AlignHigh
    toEnum Int
3 = Align
AlignLast
    toEnum Int
k = Int -> Align
AnotherAlign Int
k

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

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

foreign import ccall "vips_align_get_type" c_vips_align_get_type :: 
    IO GType

instance B.Types.TypedObject Align where
    glibType :: IO GType
glibType = IO GType
c_vips_align_get_type

instance B.Types.BoxedEnum Align

-- Enum Access
-- | The type of access an operation has to supply. See @/vips_tilecache()/@
-- and t'GI.Vips.Objects.Foreign.Foreign'.
-- 
-- /@vIPSACCESSRANDOM@/ means requests can come in any order.
-- 
-- /@vIPSACCESSSEQUENTIAL@/ means requests will be top-to-bottom, but with some
-- amount of buffering behind the read point for small non-local accesses.
data Access = 
      AccessRandom
    -- ^ can read anywhere
    | AccessSequential
    -- ^ top-to-bottom reading only, but with a small buffer
    | AccessSequentialUnbuffered
    -- ^ /No description available in the introspection data./
    | AccessLast
    -- ^ /No description available in the introspection data./
    | AnotherAccess Int
    -- ^ Catch-all for unknown values
    deriving (Int -> Access -> ShowS
[Access] -> ShowS
Access -> String
(Int -> Access -> ShowS)
-> (Access -> String) -> ([Access] -> ShowS) -> Show Access
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Access -> ShowS
showsPrec :: Int -> Access -> ShowS
$cshow :: Access -> String
show :: Access -> String
$cshowList :: [Access] -> ShowS
showList :: [Access] -> ShowS
Show, Access -> Access -> Bool
(Access -> Access -> Bool)
-> (Access -> Access -> Bool) -> Eq Access
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Access -> Access -> Bool
== :: Access -> Access -> Bool
$c/= :: Access -> Access -> Bool
/= :: Access -> Access -> Bool
Eq)

instance P.Enum Access where
    fromEnum :: Access -> Int
fromEnum Access
AccessRandom = Int
0
    fromEnum Access
AccessSequential = Int
1
    fromEnum Access
AccessSequentialUnbuffered = Int
2
    fromEnum Access
AccessLast = Int
3
    fromEnum (AnotherAccess Int
k) = Int
k

    toEnum :: Int -> Access
toEnum Int
0 = Access
AccessRandom
    toEnum Int
1 = Access
AccessSequential
    toEnum Int
2 = Access
AccessSequentialUnbuffered
    toEnum Int
3 = Access
AccessLast
    toEnum Int
k = Int -> Access
AnotherAccess Int
k

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

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

foreign import ccall "vips_access_get_type" c_vips_access_get_type :: 
    IO GType

instance B.Types.TypedObject Access where
    glibType :: IO GType
glibType = IO GType
c_vips_access_get_type

instance B.Types.BoxedEnum Access