gi-gst-1.0.18: GI/Gst/Flags.hs

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

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

module GI.Gst.Flags
    ( 

 -- * Flags
-- ** AllocatorFlags #flag:AllocatorFlags#

    AllocatorFlags(..)                      ,


-- ** BinFlags #flag:BinFlags#

    BinFlags(..)                            ,


-- ** BufferCopyFlags #flag:BufferCopyFlags#

    BufferCopyFlags(..)                     ,


-- ** BufferFlags #flag:BufferFlags#

    BufferFlags(..)                         ,


-- ** BufferPoolAcquireFlags #flag:BufferPoolAcquireFlags#

    BufferPoolAcquireFlags(..)              ,


-- ** BusFlags #flag:BusFlags#

    BusFlags(..)                            ,


-- ** CapsFlags #flag:CapsFlags#

    CapsFlags(..)                           ,


-- ** ClockFlags #flag:ClockFlags#

    ClockFlags(..)                          ,


-- ** DebugColorFlags #flag:DebugColorFlags#

    DebugColorFlags(..)                     ,


-- ** DebugGraphDetails #flag:DebugGraphDetails#

    DebugGraphDetails(..)                   ,


-- ** ElementFlags #flag:ElementFlags#

    ElementFlags(..)                        ,


-- ** EventTypeFlags #flag:EventTypeFlags#

    EventTypeFlags(..)                      ,


-- ** LockFlags #flag:LockFlags#

    LockFlags(..)                           ,


-- ** MapFlags #flag:MapFlags#

    MapFlags(..)                            ,


-- ** MemoryFlags #flag:MemoryFlags#

    MemoryFlags(..)                         ,


-- ** MessageType #flag:MessageType#

    MessageType(..)                         ,


-- ** MetaFlags #flag:MetaFlags#

    MetaFlags(..)                           ,


-- ** MiniObjectFlags #flag:MiniObjectFlags#

    MiniObjectFlags(..)                     ,


-- ** ObjectFlags #flag:ObjectFlags#

    ObjectFlags(..)                         ,


-- ** PadFlags #flag:PadFlags#

    PadFlags(..)                            ,


-- ** PadLinkCheck #flag:PadLinkCheck#

    PadLinkCheck(..)                        ,


-- ** PadProbeType #flag:PadProbeType#

    PadProbeType(..)                        ,


-- ** PadTemplateFlags #flag:PadTemplateFlags#

    PadTemplateFlags(..)                    ,


-- ** ParseFlags #flag:ParseFlags#

    ParseFlags(..)                          ,


-- ** PipelineFlags #flag:PipelineFlags#

    PipelineFlags(..)                       ,


-- ** PluginDependencyFlags #flag:PluginDependencyFlags#

    PluginDependencyFlags(..)               ,


-- ** PluginFlags #flag:PluginFlags#

    PluginFlags(..)                         ,


-- ** QueryTypeFlags #flag:QueryTypeFlags#

    QueryTypeFlags(..)                      ,


-- ** SchedulingFlags #flag:SchedulingFlags#

    SchedulingFlags(..)                     ,


-- ** SeekFlags #flag:SeekFlags#

    SeekFlags(..)                           ,


-- ** SegmentFlags #flag:SegmentFlags#

    SegmentFlags(..)                        ,


-- ** StackTraceFlags #flag:StackTraceFlags#

    StackTraceFlags(..)                     ,


-- ** StreamFlags #flag:StreamFlags#

    StreamFlags(..)                         ,


-- ** StreamType #flag:StreamType#

    StreamType(..)                          ,


-- ** TracerValueFlags #flag:TracerValueFlags#

    TracerValueFlags(..)                    ,




    ) where

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

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


-- Flags TracerValueFlags
{- |
Flag that describe the value. These flags help applications processing the
logs to understand the values.
-}
data TracerValueFlags = 
      TracerValueFlagsNone
    {- ^
    no flags
    -}
    | TracerValueFlagsOptional
    {- ^
    the value is optional. When using this flag
      one need to have an additional boolean arg before this value in the
      var-args list passed to  @/gst_tracer_record_log()/@.
    -}
    | TracerValueFlagsAggregated
    {- ^
    the value is a combined figure, since the
      start of tracing. Examples are averages or timestamps.
    -}
    | AnotherTracerValueFlags Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum TracerValueFlags where
    fromEnum TracerValueFlagsNone = 0
    fromEnum TracerValueFlagsOptional = 1
    fromEnum TracerValueFlagsAggregated = 2
    fromEnum (AnotherTracerValueFlags k) = k

    toEnum 0 = TracerValueFlagsNone
    toEnum 1 = TracerValueFlagsOptional
    toEnum 2 = TracerValueFlagsAggregated
    toEnum k = AnotherTracerValueFlags k

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

foreign import ccall "gst_tracer_value_flags_get_type" c_gst_tracer_value_flags_get_type :: 
    IO GType

instance BoxedFlags TracerValueFlags where
    boxedFlagsType _ = c_gst_tracer_value_flags_get_type

instance IsGFlag TracerValueFlags

-- Flags StreamType
{- |
'GI.Gst.Flags.StreamType' describes a high level classification set for
flows of data in 'GI.Gst.Objects.Stream.Stream' objects.

Note that this is a flag, and therefore users should not assume it
will be a single value. Do not use the equality operator for checking
whether a stream is of a certain type.

/Since: 1.10/
-}
data StreamType = 
      StreamTypeUnknown
    {- ^
    The stream is of unknown (unclassified) type.
    -}
    | StreamTypeAudio
    {- ^
    The stream is of audio data
    -}
    | StreamTypeVideo
    {- ^
    The stream carries video data
    -}
    | StreamTypeContainer
    {- ^
    The stream is a muxed container type
    -}
    | StreamTypeText
    {- ^
    The stream contains subtitle \/ subpicture data.
    -}
    | AnotherStreamType Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum StreamType where
    fromEnum StreamTypeUnknown = 1
    fromEnum StreamTypeAudio = 2
    fromEnum StreamTypeVideo = 4
    fromEnum StreamTypeContainer = 8
    fromEnum StreamTypeText = 16
    fromEnum (AnotherStreamType k) = k

    toEnum 1 = StreamTypeUnknown
    toEnum 2 = StreamTypeAudio
    toEnum 4 = StreamTypeVideo
    toEnum 8 = StreamTypeContainer
    toEnum 16 = StreamTypeText
    toEnum k = AnotherStreamType k

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

foreign import ccall "gst_stream_type_get_type" c_gst_stream_type_get_type :: 
    IO GType

instance BoxedFlags StreamType where
    boxedFlagsType _ = c_gst_stream_type_get_type

instance IsGFlag StreamType

-- Flags StreamFlags
{- |
/No description available in the introspection data./

/Since: 1.2/
-}
data StreamFlags = 
      StreamFlagsNone
    {- ^
    This stream has no special attributes
    -}
    | StreamFlagsSparse
    {- ^
    This stream is a sparse stream (e.g. a subtitle
       stream), data may flow only in irregular intervals with large gaps in
       between.
    -}
    | StreamFlagsSelect
    {- ^
    This stream should be selected by default. This
       flag may be used by demuxers to signal that a stream should be selected
       by default in a playback scenario.
    -}
    | StreamFlagsUnselect
    {- ^
    This stream should not be selected by default.
       This flag may be used by demuxers to signal that a stream should not
       be selected by default in a playback scenario, but only if explicitly
       selected by the user (e.g. an audio track for the hard of hearing or
       a director\'s commentary track).
    -}
    | AnotherStreamFlags Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum StreamFlags where
    fromEnum StreamFlagsNone = 0
    fromEnum StreamFlagsSparse = 1
    fromEnum StreamFlagsSelect = 2
    fromEnum StreamFlagsUnselect = 4
    fromEnum (AnotherStreamFlags k) = k

    toEnum 0 = StreamFlagsNone
    toEnum 1 = StreamFlagsSparse
    toEnum 2 = StreamFlagsSelect
    toEnum 4 = StreamFlagsUnselect
    toEnum k = AnotherStreamFlags k

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

foreign import ccall "gst_stream_flags_get_type" c_gst_stream_flags_get_type :: 
    IO GType

instance BoxedFlags StreamFlags where
    boxedFlagsType _ = c_gst_stream_flags_get_type

instance IsGFlag StreamFlags

-- Flags StackTraceFlags
{- |
/No description available in the introspection data./

/Since: 1.12/
-}
data StackTraceFlags = 
      StackTraceFlagsFull
    {- ^
    Try to retrieve as much information as
                                possible when getting the stack trace
    -}
    | AnotherStackTraceFlags Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum StackTraceFlags where
    fromEnum StackTraceFlagsFull = 1
    fromEnum (AnotherStackTraceFlags k) = k

    toEnum 1 = StackTraceFlagsFull
    toEnum k = AnotherStackTraceFlags k

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

foreign import ccall "gst_stack_trace_flags_get_type" c_gst_stack_trace_flags_get_type :: 
    IO GType

instance BoxedFlags StackTraceFlags where
    boxedFlagsType _ = c_gst_stack_trace_flags_get_type

instance IsGFlag StackTraceFlags

-- Flags SegmentFlags
{- |
Flags for the GstSegment structure. Currently mapped to the corresponding
values of the seek flags.
-}
data SegmentFlags = 
      SegmentFlagsNone
    {- ^
    no flags
    -}
    | SegmentFlagsReset
    {- ^
    reset the pipeline running_time to the segment
                             running_time
    -}
    | SegmentFlagsTrickmode
    {- ^
    perform skip playback (Since 1.6)
    -}
    | SegmentFlagsSkip
    {- ^
    Deprecated backward compatibility flag, replaced
                            by /@gSTSEGMENTFLAGTRICKMODE@/
    -}
    | SegmentFlagsSegment
    {- ^
    send SEGMENT_DONE instead of EOS
    -}
    | SegmentFlagsTrickmodeKeyUnits
    {- ^
    Decode only keyframes, where
                                           possible (Since 1.6)
    -}
    | SegmentFlagsTrickmodeNoAudio
    {- ^
    Do not decode any audio, where
                                           possible (Since 1.6)
    -}
    | AnotherSegmentFlags Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum SegmentFlags where
    fromEnum SegmentFlagsNone = 0
    fromEnum SegmentFlagsReset = 1
    fromEnum SegmentFlagsTrickmode = 16
    fromEnum SegmentFlagsSkip = 16
    fromEnum SegmentFlagsSegment = 8
    fromEnum SegmentFlagsTrickmodeKeyUnits = 128
    fromEnum SegmentFlagsTrickmodeNoAudio = 256
    fromEnum (AnotherSegmentFlags k) = k

    toEnum 0 = SegmentFlagsNone
    toEnum 1 = SegmentFlagsReset
    toEnum 16 = SegmentFlagsTrickmode
    toEnum 16 = SegmentFlagsSkip
    toEnum 8 = SegmentFlagsSegment
    toEnum 128 = SegmentFlagsTrickmodeKeyUnits
    toEnum 256 = SegmentFlagsTrickmodeNoAudio
    toEnum k = AnotherSegmentFlags k

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

foreign import ccall "gst_segment_flags_get_type" c_gst_segment_flags_get_type :: 
    IO GType

instance BoxedFlags SegmentFlags where
    boxedFlagsType _ = c_gst_segment_flags_get_type

instance IsGFlag SegmentFlags

-- Flags SeekFlags
{- |
Flags to be used with 'GI.Gst.Objects.Element.elementSeek' or 'GI.Gst.Structs.Event.eventNewSeek'. All flags
can be used together.

A non flushing seek might take some time to perform as the currently
playing data in the pipeline will not be cleared.

An accurate seek might be slower for formats that don\'t have any indexes
or timestamp markers in the stream. Specifying this flag might require a
complete scan of the file in those cases.

When performing a segment seek: after the playback of the segment completes,
no EOS will be emitted by the element that performed the seek, but a
'GI.Gst.Flags.MessageTypeSegmentDone' message will be posted on the bus by the element.
When this message is posted, it is possible to send a new seek event to
continue playback. With this seek method it is possible to perform seamless
looping or simple linear editing.

When doing fast forward (rate > 1.0) or fast reverse (rate \< -1.0) trickmode
playback, the 'GI.Gst.Flags.SeekFlagsTrickmode' flag can be used to instruct decoders
and demuxers to adjust the playback rate by skipping frames. This can improve
performance and decrease CPU usage because not all frames need to be decoded.

Beyond that, the 'GI.Gst.Flags.SeekFlagsTrickmodeKeyUnits' flag can be used to
request that decoders skip all frames except key units, and
'GI.Gst.Flags.SeekFlagsTrickmodeNoAudio' flags can be used to request that audio
decoders do no decoding at all, and simple output silence.

The 'GI.Gst.Flags.SeekFlagsSnapBefore' flag can be used to snap to the previous
relevant location, and the 'GI.Gst.Flags.SeekFlagsSnapAfter' flag can be used to
select the next relevant location. If 'GI.Gst.Flags.SeekFlagsKeyUnit' is specified,
the relevant location is a keyframe. If both flags are specified, the nearest
of these locations will be selected. If none are specified, the implementation is
free to select whichever it wants.

The before and after here are in running time, so when playing backwards,
the next location refers to the one that will played in next, and not the
one that is located after in the actual source stream.

Also see part-seeking.txt in the GStreamer design documentation for more
details on the meaning of these flags and the behaviour expected of
elements that handle them.
-}
data SeekFlags = 
      SeekFlagsNone
    {- ^
    no flag
    -}
    | SeekFlagsFlush
    {- ^
    flush pipeline
    -}
    | SeekFlagsAccurate
    {- ^
    accurate position is requested, this might
                        be considerably slower for some formats.
    -}
    | SeekFlagsKeyUnit
    {- ^
    seek to the nearest keyframe. This might be
                        faster but less accurate.
    -}
    | SeekFlagsSegment
    {- ^
    perform a segment seek.
    -}
    | SeekFlagsTrickmode
    {- ^
    when doing fast forward or fast reverse playback, allow
                        elements to skip frames instead of generating all
                        frames. (Since 1.6)
    -}
    | SeekFlagsSkip
    {- ^
    Deprecated backward compatibility flag, replaced
                        by 'GI.Gst.Flags.SeekFlagsTrickmode'
    -}
    | SeekFlagsSnapBefore
    {- ^
    go to a location before the requested position,
                        if 'GI.Gst.Flags.SeekFlagsKeyUnit' this means the keyframe at or before
                        the requested position the one at or before the seek target.
    -}
    | SeekFlagsSnapAfter
    {- ^
    go to a location after the requested position,
                        if 'GI.Gst.Flags.SeekFlagsKeyUnit' this means the keyframe at of after the
                        requested position.
    -}
    | SeekFlagsSnapNearest
    {- ^
    go to a position near the requested position,
                        if 'GI.Gst.Flags.SeekFlagsKeyUnit' this means the keyframe closest
                        to the requested position, if both keyframes are at an equal
                        distance, behaves like 'GI.Gst.Flags.SeekFlagsSnapBefore'.
    -}
    | SeekFlagsTrickmodeKeyUnits
    {- ^
    when doing fast forward or fast reverse
                        playback, request that elements only decode keyframes
                        and skip all other content, for formats that have
                        keyframes. (Since 1.6)
    -}
    | SeekFlagsTrickmodeNoAudio
    {- ^
    when doing fast forward or fast reverse
                        playback, request that audio decoder elements skip
                        decoding and output only gap events or silence. (Since 1.6)
    -}
    | AnotherSeekFlags Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum SeekFlags where
    fromEnum SeekFlagsNone = 0
    fromEnum SeekFlagsFlush = 1
    fromEnum SeekFlagsAccurate = 2
    fromEnum SeekFlagsKeyUnit = 4
    fromEnum SeekFlagsSegment = 8
    fromEnum SeekFlagsTrickmode = 16
    fromEnum SeekFlagsSkip = 16
    fromEnum SeekFlagsSnapBefore = 32
    fromEnum SeekFlagsSnapAfter = 64
    fromEnum SeekFlagsSnapNearest = 96
    fromEnum SeekFlagsTrickmodeKeyUnits = 128
    fromEnum SeekFlagsTrickmodeNoAudio = 256
    fromEnum (AnotherSeekFlags k) = k

    toEnum 0 = SeekFlagsNone
    toEnum 1 = SeekFlagsFlush
    toEnum 2 = SeekFlagsAccurate
    toEnum 4 = SeekFlagsKeyUnit
    toEnum 8 = SeekFlagsSegment
    toEnum 16 = SeekFlagsTrickmode
    toEnum 16 = SeekFlagsSkip
    toEnum 32 = SeekFlagsSnapBefore
    toEnum 64 = SeekFlagsSnapAfter
    toEnum 96 = SeekFlagsSnapNearest
    toEnum 128 = SeekFlagsTrickmodeKeyUnits
    toEnum 256 = SeekFlagsTrickmodeNoAudio
    toEnum k = AnotherSeekFlags k

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

foreign import ccall "gst_seek_flags_get_type" c_gst_seek_flags_get_type :: 
    IO GType

instance BoxedFlags SeekFlags where
    boxedFlagsType _ = c_gst_seek_flags_get_type

instance IsGFlag SeekFlags

-- Flags SchedulingFlags
{- |
The different scheduling flags.
-}
data SchedulingFlags = 
      SchedulingFlagsSeekable
    {- ^
    if seeking is possible
    -}
    | SchedulingFlagsSequential
    {- ^
    if sequential access is recommended
    -}
    | SchedulingFlagsBandwidthLimited
    {- ^
    if bandwidth is limited and buffering possible (since 1.2)
    -}
    | AnotherSchedulingFlags Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum SchedulingFlags where
    fromEnum SchedulingFlagsSeekable = 1
    fromEnum SchedulingFlagsSequential = 2
    fromEnum SchedulingFlagsBandwidthLimited = 4
    fromEnum (AnotherSchedulingFlags k) = k

    toEnum 1 = SchedulingFlagsSeekable
    toEnum 2 = SchedulingFlagsSequential
    toEnum 4 = SchedulingFlagsBandwidthLimited
    toEnum k = AnotherSchedulingFlags k

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

foreign import ccall "gst_scheduling_flags_get_type" c_gst_scheduling_flags_get_type :: 
    IO GType

instance BoxedFlags SchedulingFlags where
    boxedFlagsType _ = c_gst_scheduling_flags_get_type

instance IsGFlag SchedulingFlags

-- Flags QueryTypeFlags
{- |
'GI.Gst.Flags.QueryTypeFlags' indicate the aspects of the different 'GI.Gst.Enums.QueryType'
values. You can get the type flags of a 'GI.Gst.Enums.QueryType' with the
'GI.Gst.Functions.queryTypeGetFlags' function.
-}
data QueryTypeFlags = 
      QueryTypeFlagsUpstream
    {- ^
    Set if the query can travel upstream.
    -}
    | QueryTypeFlagsDownstream
    {- ^
    Set if the query can travel downstream.
    -}
    | QueryTypeFlagsSerialized
    {- ^
    Set if the query should be serialized with data
                                  flow.
    -}
    | AnotherQueryTypeFlags Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum QueryTypeFlags where
    fromEnum QueryTypeFlagsUpstream = 1
    fromEnum QueryTypeFlagsDownstream = 2
    fromEnum QueryTypeFlagsSerialized = 4
    fromEnum (AnotherQueryTypeFlags k) = k

    toEnum 1 = QueryTypeFlagsUpstream
    toEnum 2 = QueryTypeFlagsDownstream
    toEnum 4 = QueryTypeFlagsSerialized
    toEnum k = AnotherQueryTypeFlags k

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

foreign import ccall "gst_query_type_flags_get_type" c_gst_query_type_flags_get_type :: 
    IO GType

instance BoxedFlags QueryTypeFlags where
    boxedFlagsType _ = c_gst_query_type_flags_get_type

instance IsGFlag QueryTypeFlags

-- Flags PluginFlags
{- |
The plugin loading state
-}
data PluginFlags = 
      PluginFlagsCached
    {- ^
    Temporarily loaded plugins
    -}
    | PluginFlagsBlacklisted
    {- ^
    The plugin won\'t be scanned (again)
    -}
    | AnotherPluginFlags Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum PluginFlags where
    fromEnum PluginFlagsCached = 16
    fromEnum PluginFlagsBlacklisted = 32
    fromEnum (AnotherPluginFlags k) = k

    toEnum 16 = PluginFlagsCached
    toEnum 32 = PluginFlagsBlacklisted
    toEnum k = AnotherPluginFlags k

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

foreign import ccall "gst_plugin_flags_get_type" c_gst_plugin_flags_get_type :: 
    IO GType

instance BoxedFlags PluginFlags where
    boxedFlagsType _ = c_gst_plugin_flags_get_type

instance IsGFlag PluginFlags

-- Flags PluginDependencyFlags
{- |
Flags used in connection with 'GI.Gst.Objects.Plugin.pluginAddDependency'.
-}
data PluginDependencyFlags = 
      PluginDependencyFlagsNone
    {- ^
    no special flags
    -}
    | PluginDependencyFlagsRecurse
    {- ^
    recurse into subdirectories
    -}
    | PluginDependencyFlagsPathsAreDefaultOnly
    {- ^
    use paths
            argument only if none of the environment variables is set
    -}
    | PluginDependencyFlagsFileNameIsSuffix
    {- ^
    interpret
            filename argument as filter suffix and check all matching files in
            the directory
    -}
    | PluginDependencyFlagsFileNameIsPrefix
    {- ^
    interpret
            filename argument as filter prefix and check all matching files in
            the directory. Since 1.8.
    -}
    | PluginDependencyFlagsPathsAreRelativeToExe
    {- ^
    interpret
      non-absolute paths as relative to the main executable directory. Since
      1.14.
    -}
    | AnotherPluginDependencyFlags Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum PluginDependencyFlags where
    fromEnum PluginDependencyFlagsNone = 0
    fromEnum PluginDependencyFlagsRecurse = 1
    fromEnum PluginDependencyFlagsPathsAreDefaultOnly = 2
    fromEnum PluginDependencyFlagsFileNameIsSuffix = 4
    fromEnum PluginDependencyFlagsFileNameIsPrefix = 8
    fromEnum PluginDependencyFlagsPathsAreRelativeToExe = 16
    fromEnum (AnotherPluginDependencyFlags k) = k

    toEnum 0 = PluginDependencyFlagsNone
    toEnum 1 = PluginDependencyFlagsRecurse
    toEnum 2 = PluginDependencyFlagsPathsAreDefaultOnly
    toEnum 4 = PluginDependencyFlagsFileNameIsSuffix
    toEnum 8 = PluginDependencyFlagsFileNameIsPrefix
    toEnum 16 = PluginDependencyFlagsPathsAreRelativeToExe
    toEnum k = AnotherPluginDependencyFlags k

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

foreign import ccall "gst_plugin_dependency_flags_get_type" c_gst_plugin_dependency_flags_get_type :: 
    IO GType

instance BoxedFlags PluginDependencyFlags where
    boxedFlagsType _ = c_gst_plugin_dependency_flags_get_type

instance IsGFlag PluginDependencyFlags

-- Flags PipelineFlags
{- |
Pipeline flags
-}
data PipelineFlags = 
      PipelineFlagsFixedClock
    {- ^
    this pipeline works with a fixed clock
    -}
    | PipelineFlagsLast
    {- ^
    offset to define more flags
    -}
    | AnotherPipelineFlags Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum PipelineFlags where
    fromEnum PipelineFlagsFixedClock = 524288
    fromEnum PipelineFlagsLast = 8388608
    fromEnum (AnotherPipelineFlags k) = k

    toEnum 524288 = PipelineFlagsFixedClock
    toEnum 8388608 = PipelineFlagsLast
    toEnum k = AnotherPipelineFlags k

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

foreign import ccall "gst_pipeline_flags_get_type" c_gst_pipeline_flags_get_type :: 
    IO GType

instance BoxedFlags PipelineFlags where
    boxedFlagsType _ = c_gst_pipeline_flags_get_type

instance IsGFlag PipelineFlags

-- Flags ParseFlags
{- |
Parsing options.
-}
data ParseFlags = 
      ParseFlagsNone
    {- ^
    Do not use any special parsing options.
    -}
    | ParseFlagsFatalErrors
    {- ^
    Always return 'Nothing' when an error occurs
        (default behaviour is to return partially constructed bins or elements
         in some cases)
    -}
    | ParseFlagsNoSingleElementBins
    {- ^
    If a bin only has a single element,
        just return the element.
    -}
    | ParseFlagsPlaceInBin
    {- ^
    If more than one toplevel element is described
        by the pipeline description string, put them in a 'GI.Gst.Objects.Bin.Bin' instead of a
        'GI.Gst.Objects.Pipeline.Pipeline'. (Since 1.10)
    -}
    | AnotherParseFlags Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum ParseFlags where
    fromEnum ParseFlagsNone = 0
    fromEnum ParseFlagsFatalErrors = 1
    fromEnum ParseFlagsNoSingleElementBins = 2
    fromEnum ParseFlagsPlaceInBin = 4
    fromEnum (AnotherParseFlags k) = k

    toEnum 0 = ParseFlagsNone
    toEnum 1 = ParseFlagsFatalErrors
    toEnum 2 = ParseFlagsNoSingleElementBins
    toEnum 4 = ParseFlagsPlaceInBin
    toEnum k = AnotherParseFlags k

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

foreign import ccall "gst_parse_flags_get_type" c_gst_parse_flags_get_type :: 
    IO GType

instance BoxedFlags ParseFlags where
    boxedFlagsType _ = c_gst_parse_flags_get_type

instance IsGFlag ParseFlags

-- Flags PadTemplateFlags
{- |
Flags for the padtemplate
-}
data PadTemplateFlags = 
      PadTemplateFlagsLast
    {- ^
    first flag that can be used by subclasses.
    -}
    | AnotherPadTemplateFlags Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum PadTemplateFlags where
    fromEnum PadTemplateFlagsLast = 256
    fromEnum (AnotherPadTemplateFlags k) = k

    toEnum 256 = PadTemplateFlagsLast
    toEnum k = AnotherPadTemplateFlags k

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

foreign import ccall "gst_pad_template_flags_get_type" c_gst_pad_template_flags_get_type :: 
    IO GType

instance BoxedFlags PadTemplateFlags where
    boxedFlagsType _ = c_gst_pad_template_flags_get_type

instance IsGFlag PadTemplateFlags

-- Flags PadProbeType
{- |
The different probing types that can occur. When either one of
/@gSTPADPROBETYPEIDLE@/ or /@gSTPADPROBETYPEBLOCK@/ is used, the probe will be a
blocking probe.
-}
data PadProbeType = 
      PadProbeTypeInvalid
    {- ^
    invalid probe type
    -}
    | PadProbeTypeIdle
    {- ^
    probe idle pads and block while the callback is called
    -}
    | PadProbeTypeBlock
    {- ^
    probe and block pads
    -}
    | PadProbeTypeBuffer
    {- ^
    probe buffers
    -}
    | PadProbeTypeBufferList
    {- ^
    probe buffer lists
    -}
    | PadProbeTypeEventDownstream
    {- ^
    probe downstream events
    -}
    | PadProbeTypeEventUpstream
    {- ^
    probe upstream events
    -}
    | PadProbeTypeEventFlush
    {- ^
    probe flush events. This probe has to be
        explicitly enabled and is not included in the
        \@/@gSTPADPROBETYPEEVENTDOWNSTREAM@/ or
        \@/@gSTPADPROBETYPEEVENTUPSTREAM@/ probe types.
    -}
    | PadProbeTypeQueryDownstream
    {- ^
    probe downstream queries
    -}
    | PadProbeTypeQueryUpstream
    {- ^
    probe upstream queries
    -}
    | PadProbeTypePush
    {- ^
    probe push
    -}
    | PadProbeTypePull
    {- ^
    probe pull
    -}
    | PadProbeTypeBlocking
    {- ^
    probe and block at the next opportunity, at data flow or when idle
    -}
    | PadProbeTypeDataDownstream
    {- ^
    probe downstream data (buffers, buffer lists, and events)
    -}
    | PadProbeTypeDataUpstream
    {- ^
    probe upstream data (events)
    -}
    | PadProbeTypeDataBoth
    {- ^
    probe upstream and downstream data (buffers, buffer lists, and events)
    -}
    | PadProbeTypeBlockDownstream
    {- ^
    probe and block downstream data (buffers, buffer lists, and events)
    -}
    | PadProbeTypeBlockUpstream
    {- ^
    probe and block upstream data (events)
    -}
    | PadProbeTypeEventBoth
    {- ^
    probe upstream and downstream events
    -}
    | PadProbeTypeQueryBoth
    {- ^
    probe upstream and downstream queries
    -}
    | PadProbeTypeAllBoth
    {- ^
    probe upstream events and queries and downstream buffers, buffer lists, events and queries
    -}
    | PadProbeTypeScheduling
    {- ^
    probe push and pull
    -}
    | AnotherPadProbeType Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum PadProbeType where
    fromEnum PadProbeTypeInvalid = 0
    fromEnum PadProbeTypeIdle = 1
    fromEnum PadProbeTypeBlock = 2
    fromEnum PadProbeTypeBuffer = 16
    fromEnum PadProbeTypeBufferList = 32
    fromEnum PadProbeTypeEventDownstream = 64
    fromEnum PadProbeTypeEventUpstream = 128
    fromEnum PadProbeTypeEventFlush = 256
    fromEnum PadProbeTypeQueryDownstream = 512
    fromEnum PadProbeTypeQueryUpstream = 1024
    fromEnum PadProbeTypePush = 4096
    fromEnum PadProbeTypePull = 8192
    fromEnum PadProbeTypeBlocking = 3
    fromEnum PadProbeTypeDataDownstream = 112
    fromEnum PadProbeTypeDataUpstream = 128
    fromEnum PadProbeTypeDataBoth = 240
    fromEnum PadProbeTypeBlockDownstream = 114
    fromEnum PadProbeTypeBlockUpstream = 130
    fromEnum PadProbeTypeEventBoth = 192
    fromEnum PadProbeTypeQueryBoth = 1536
    fromEnum PadProbeTypeAllBoth = 1776
    fromEnum PadProbeTypeScheduling = 12288
    fromEnum (AnotherPadProbeType k) = k

    toEnum 0 = PadProbeTypeInvalid
    toEnum 1 = PadProbeTypeIdle
    toEnum 2 = PadProbeTypeBlock
    toEnum 16 = PadProbeTypeBuffer
    toEnum 32 = PadProbeTypeBufferList
    toEnum 64 = PadProbeTypeEventDownstream
    toEnum 128 = PadProbeTypeEventUpstream
    toEnum 256 = PadProbeTypeEventFlush
    toEnum 512 = PadProbeTypeQueryDownstream
    toEnum 1024 = PadProbeTypeQueryUpstream
    toEnum 4096 = PadProbeTypePush
    toEnum 8192 = PadProbeTypePull
    toEnum 3 = PadProbeTypeBlocking
    toEnum 112 = PadProbeTypeDataDownstream
    toEnum 128 = PadProbeTypeDataUpstream
    toEnum 240 = PadProbeTypeDataBoth
    toEnum 114 = PadProbeTypeBlockDownstream
    toEnum 130 = PadProbeTypeBlockUpstream
    toEnum 192 = PadProbeTypeEventBoth
    toEnum 1536 = PadProbeTypeQueryBoth
    toEnum 1776 = PadProbeTypeAllBoth
    toEnum 12288 = PadProbeTypeScheduling
    toEnum k = AnotherPadProbeType k

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

foreign import ccall "gst_pad_probe_type_get_type" c_gst_pad_probe_type_get_type :: 
    IO GType

instance BoxedFlags PadProbeType where
    boxedFlagsType _ = c_gst_pad_probe_type_get_type

instance IsGFlag PadProbeType

-- Flags PadLinkCheck
{- |
The amount of checking to be done when linking pads. /@gSTPADLINKCHECKCAPS@/
and /@gSTPADLINKCHECKTEMPLATECAPS@/ are mutually exclusive. If both are
specified, expensive but safe /@gSTPADLINKCHECKCAPS@/ are performed.

> Only disable some of the checks if you are 100% certain you know the link
> will not fail because of hierarchy\/caps compatibility failures. If uncertain,
> use the default checks ('GI.Gst.Flags.PadLinkCheckDefault') or the regular methods
> for linking the pads.
-}
data PadLinkCheck = 
      PadLinkCheckNothing
    {- ^
    Don\'t check hierarchy or caps compatibility.
    -}
    | PadLinkCheckHierarchy
    {- ^
    Check the pads have same parents\/grandparents.
      Could be omitted if it is already known that the two elements that own the
      pads are in the same bin.
    -}
    | PadLinkCheckTemplateCaps
    {- ^
    Check if the pads are compatible by using
      their template caps. This is much faster than /@gSTPADLINKCHECKCAPS@/, but
      would be unsafe e.g. if one pad has @/GST_CAPS_ANY/@.
    -}
    | PadLinkCheckCaps
    {- ^
    Check if the pads are compatible by comparing the
      caps returned by 'GI.Gst.Objects.Pad.padQueryCaps'.
    -}
    | PadLinkCheckNoReconfigure
    {- ^
    Disables pushing a reconfigure event when pads are
      linked.
    -}
    | PadLinkCheckDefault
    {- ^
    The default checks done when linking
      pads (i.e. the ones used by 'GI.Gst.Objects.Pad.padLink').
    -}
    | AnotherPadLinkCheck Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum PadLinkCheck where
    fromEnum PadLinkCheckNothing = 0
    fromEnum PadLinkCheckHierarchy = 1
    fromEnum PadLinkCheckTemplateCaps = 2
    fromEnum PadLinkCheckCaps = 4
    fromEnum PadLinkCheckNoReconfigure = 8
    fromEnum PadLinkCheckDefault = 5
    fromEnum (AnotherPadLinkCheck k) = k

    toEnum 0 = PadLinkCheckNothing
    toEnum 1 = PadLinkCheckHierarchy
    toEnum 2 = PadLinkCheckTemplateCaps
    toEnum 4 = PadLinkCheckCaps
    toEnum 8 = PadLinkCheckNoReconfigure
    toEnum 5 = PadLinkCheckDefault
    toEnum k = AnotherPadLinkCheck k

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

foreign import ccall "gst_pad_link_check_get_type" c_gst_pad_link_check_get_type :: 
    IO GType

instance BoxedFlags PadLinkCheck where
    boxedFlagsType _ = c_gst_pad_link_check_get_type

instance IsGFlag PadLinkCheck

-- Flags PadFlags
{- |
Pad state flags
-}
data PadFlags = 
      PadFlagsBlocked
    {- ^
    is dataflow on a pad blocked
    -}
    | PadFlagsFlushing
    {- ^
    is pad flushing
    -}
    | PadFlagsEos
    {- ^
    is pad in EOS state
    -}
    | PadFlagsBlocking
    {- ^
    is pad currently blocking on a buffer or event
    -}
    | PadFlagsNeedParent
    {- ^
    ensure that there is a parent object before calling
                          into the pad callbacks.
    -}
    | PadFlagsNeedReconfigure
    {- ^
    the pad should be reconfigured\/renegotiated.
                               The flag has to be unset manually after
                               reconfiguration happened.
    -}
    | PadFlagsPendingEvents
    {- ^
    the pad has pending events
    -}
    | PadFlagsFixedCaps
    {- ^
    the pad is using fixed caps. This means that
        once the caps are set on the pad, the default caps query function
        will only return those caps.
    -}
    | PadFlagsProxyCaps
    {- ^
    the default event and query handler will forward
                         all events and queries to the internally linked pads
                         instead of discarding them.
    -}
    | PadFlagsProxyAllocation
    {- ^
    the default query handler will forward
                         allocation queries to the internally linked pads
                         instead of discarding them.
    -}
    | PadFlagsProxyScheduling
    {- ^
    the default query handler will forward
                         scheduling queries to the internally linked pads
                         instead of discarding them.
    -}
    | PadFlagsAcceptIntersect
    {- ^
    the default accept-caps handler will check
                         it the caps intersect the query-caps result instead
                         of checking for a subset. This is interesting for
                         parsers that can accept incompletely specified caps.
    -}
    | PadFlagsAcceptTemplate
    {- ^
    the default accept-caps handler will use
                         the template pad caps instead of query caps to
                         compare with the accept caps. Use this in combination
                         with 'GI.Gst.Flags.PadFlagsAcceptIntersect'. (Since 1.6)
    -}
    | PadFlagsLast
    {- ^
    offset to define more flags
    -}
    | AnotherPadFlags Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum PadFlags where
    fromEnum PadFlagsBlocked = 16
    fromEnum PadFlagsFlushing = 32
    fromEnum PadFlagsEos = 64
    fromEnum PadFlagsBlocking = 128
    fromEnum PadFlagsNeedParent = 256
    fromEnum PadFlagsNeedReconfigure = 512
    fromEnum PadFlagsPendingEvents = 1024
    fromEnum PadFlagsFixedCaps = 2048
    fromEnum PadFlagsProxyCaps = 4096
    fromEnum PadFlagsProxyAllocation = 8192
    fromEnum PadFlagsProxyScheduling = 16384
    fromEnum PadFlagsAcceptIntersect = 32768
    fromEnum PadFlagsAcceptTemplate = 65536
    fromEnum PadFlagsLast = 1048576
    fromEnum (AnotherPadFlags k) = k

    toEnum 16 = PadFlagsBlocked
    toEnum 32 = PadFlagsFlushing
    toEnum 64 = PadFlagsEos
    toEnum 128 = PadFlagsBlocking
    toEnum 256 = PadFlagsNeedParent
    toEnum 512 = PadFlagsNeedReconfigure
    toEnum 1024 = PadFlagsPendingEvents
    toEnum 2048 = PadFlagsFixedCaps
    toEnum 4096 = PadFlagsProxyCaps
    toEnum 8192 = PadFlagsProxyAllocation
    toEnum 16384 = PadFlagsProxyScheduling
    toEnum 32768 = PadFlagsAcceptIntersect
    toEnum 65536 = PadFlagsAcceptTemplate
    toEnum 1048576 = PadFlagsLast
    toEnum k = AnotherPadFlags k

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

foreign import ccall "gst_pad_flags_get_type" c_gst_pad_flags_get_type :: 
    IO GType

instance BoxedFlags PadFlags where
    boxedFlagsType _ = c_gst_pad_flags_get_type

instance IsGFlag PadFlags

-- Flags ObjectFlags
{- |
The standard flags that an gstobject may have.
-}
data ObjectFlags = 
      ObjectFlagsMayBeLeaked
    {- ^
    the object is expected to stay alive even
    after 'GI.Gst.Functions.deinit' has been called and so should be ignored by leak
    detection tools. (Since 1.10)
    -}
    | ObjectFlagsLast
    {- ^
    subclasses can add additional flags starting from this flag
    -}
    | AnotherObjectFlags Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum ObjectFlags where
    fromEnum ObjectFlagsMayBeLeaked = 1
    fromEnum ObjectFlagsLast = 16
    fromEnum (AnotherObjectFlags k) = k

    toEnum 1 = ObjectFlagsMayBeLeaked
    toEnum 16 = ObjectFlagsLast
    toEnum k = AnotherObjectFlags k

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

foreign import ccall "gst_object_flags_get_type" c_gst_object_flags_get_type :: 
    IO GType

instance BoxedFlags ObjectFlags where
    boxedFlagsType _ = c_gst_object_flags_get_type

instance IsGFlag ObjectFlags

-- Flags MiniObjectFlags
{- |
Flags for the mini object
-}
data MiniObjectFlags = 
      MiniObjectFlagsLockable
    {- ^
    the object can be locked and unlocked with
    'GI.Gst.Structs.MiniObject.miniObjectLock' and 'GI.Gst.Structs.MiniObject.miniObjectUnlock'.
    -}
    | MiniObjectFlagsLockReadonly
    {- ^
    the object is permanently locked in
    READONLY mode. Only read locks can be performed on the object.
    -}
    | MiniObjectFlagsMayBeLeaked
    {- ^
    the object is expected to stay alive
    even after 'GI.Gst.Functions.deinit' has been called and so should be ignored by leak
    detection tools. (Since 1.10)
    -}
    | MiniObjectFlagsLast
    {- ^
    first flag that can be used by subclasses.
    -}
    | AnotherMiniObjectFlags Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum MiniObjectFlags where
    fromEnum MiniObjectFlagsLockable = 1
    fromEnum MiniObjectFlagsLockReadonly = 2
    fromEnum MiniObjectFlagsMayBeLeaked = 4
    fromEnum MiniObjectFlagsLast = 16
    fromEnum (AnotherMiniObjectFlags k) = k

    toEnum 1 = MiniObjectFlagsLockable
    toEnum 2 = MiniObjectFlagsLockReadonly
    toEnum 4 = MiniObjectFlagsMayBeLeaked
    toEnum 16 = MiniObjectFlagsLast
    toEnum k = AnotherMiniObjectFlags k

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

foreign import ccall "gst_mini_object_flags_get_type" c_gst_mini_object_flags_get_type :: 
    IO GType

instance BoxedFlags MiniObjectFlags where
    boxedFlagsType _ = c_gst_mini_object_flags_get_type

instance IsGFlag MiniObjectFlags

-- Flags MetaFlags
{- |
Extra metadata flags.
-}
data MetaFlags = 
      MetaFlagsNone
    {- ^
    no flags
    -}
    | MetaFlagsReadonly
    {- ^
    metadata should not be modified
    -}
    | MetaFlagsPooled
    {- ^
    metadata is managed by a bufferpool
    -}
    | MetaFlagsLocked
    {- ^
    metadata should not be removed
    -}
    | MetaFlagsLast
    {- ^
    additional flags can be added starting from this flag.
    -}
    | AnotherMetaFlags Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum MetaFlags where
    fromEnum MetaFlagsNone = 0
    fromEnum MetaFlagsReadonly = 1
    fromEnum MetaFlagsPooled = 2
    fromEnum MetaFlagsLocked = 4
    fromEnum MetaFlagsLast = 65536
    fromEnum (AnotherMetaFlags k) = k

    toEnum 0 = MetaFlagsNone
    toEnum 1 = MetaFlagsReadonly
    toEnum 2 = MetaFlagsPooled
    toEnum 4 = MetaFlagsLocked
    toEnum 65536 = MetaFlagsLast
    toEnum k = AnotherMetaFlags k

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

foreign import ccall "gst_meta_flags_get_type" c_gst_meta_flags_get_type :: 
    IO GType

instance BoxedFlags MetaFlags where
    boxedFlagsType _ = c_gst_meta_flags_get_type

instance IsGFlag MetaFlags

-- Flags MessageType
{- |
The different message types that are available.
-}
data MessageType = 
      MessageTypeUnknown
    {- ^
    an undefined message
    -}
    | MessageTypeEos
    {- ^
    end-of-stream reached in a pipeline. The application will
    only receive this message in the PLAYING state and every time it sets a
    pipeline to PLAYING that is in the EOS state. The application can perform a
    flushing seek in the pipeline, which will undo the EOS state again.
    -}
    | MessageTypeError
    {- ^
    an error occurred. When the application receives an error
    message it should stop playback of the pipeline and not assume that more
    data will be played.
    -}
    | MessageTypeWarning
    {- ^
    a warning occurred.
    -}
    | MessageTypeInfo
    {- ^
    an info message occurred
    -}
    | MessageTypeTag
    {- ^
    a tag was found.
    -}
    | MessageTypeBuffering
    {- ^
    the pipeline is buffering. When the application
    receives a buffering message in the PLAYING state for a non-live pipeline it
    must PAUSE the pipeline until the buffering completes, when the percentage
    field in the message is 100%. For live pipelines, no action must be
    performed and the buffering percentage can be used to inform the user about
    the progress.
    -}
    | MessageTypeStateChanged
    {- ^
    a state change happened
    -}
    | MessageTypeStateDirty
    {- ^
    an element changed state in a streaming thread.
    This message is deprecated.
    -}
    | MessageTypeStepDone
    {- ^
    a stepping operation finished.
    -}
    | MessageTypeClockProvide
    {- ^
    an element notifies its capability of providing
                                a clock. This message is used internally and
                                never forwarded to the application.
    -}
    | MessageTypeClockLost
    {- ^
    The current clock as selected by the pipeline became
                             unusable. The pipeline will select a new clock on
                             the next PLAYING state change. The application
                             should set the pipeline to PAUSED and back to
                             PLAYING when this message is received.
    -}
    | MessageTypeNewClock
    {- ^
    a new clock was selected in the pipeline.
    -}
    | MessageTypeStructureChange
    {- ^
    the structure of the pipeline changed. This
    message is used internally and never forwarded to the application.
    -}
    | MessageTypeStreamStatus
    {- ^
    status about a stream, emitted when it starts,
                                stops, errors, etc..
    -}
    | MessageTypeApplication
    {- ^
    message posted by the application, possibly
                              via an application-specific element.
    -}
    | MessageTypeElement
    {- ^
    element-specific message, see the specific element\'s
                          documentation
    -}
    | MessageTypeSegmentStart
    {- ^
    pipeline started playback of a segment. This
    message is used internally and never forwarded to the application.
    -}
    | MessageTypeSegmentDone
    {- ^
    pipeline completed playback of a segment. This
    message is forwarded to the application after all elements that posted
    /@gSTMESSAGESEGMENTSTART@/ posted a GST_MESSAGE_SEGMENT_DONE message.
    -}
    | MessageTypeDurationChanged
    {- ^
    The duration of a pipeline changed. The
    application can get the new duration with a duration query.
    -}
    | MessageTypeLatency
    {- ^
    Posted by elements when their latency changes. The
    application should recalculate and distribute a new latency.
    -}
    | MessageTypeAsyncStart
    {- ^
    Posted by elements when they start an ASYNC
    'GI.Gst.Enums.StateChange'. This message is not forwarded to the application but is used
    internally.
    -}
    | MessageTypeAsyncDone
    {- ^
    Posted by elements when they complete an ASYNC
    'GI.Gst.Enums.StateChange'. The application will only receive this message from the toplevel
    pipeline.
    -}
    | MessageTypeRequestState
    {- ^
    Posted by elements when they want the pipeline to
    change state. This message is a suggestion to the application which can
    decide to perform the state change on (part of) the pipeline.
    -}
    | MessageTypeStepStart
    {- ^
    A stepping operation was started.
    -}
    | MessageTypeQos
    {- ^
    A buffer was dropped or an element changed its processing
    strategy for Quality of Service reasons.
    -}
    | MessageTypeProgress
    {- ^
    A progress message.
    -}
    | MessageTypeToc
    {- ^
    A new table of contents (TOC) was found or previously found TOC
    was updated.
    -}
    | MessageTypeResetTime
    {- ^
    Message to request resetting the pipeline\'s
        running time from the pipeline. This is an internal message which
        applications will likely never receive.
    -}
    | MessageTypeStreamStart
    {- ^
    Message indicating start of a new stream. Useful
        e.g. when using playbin in gapless playback mode, to get notified when
        the next title actually starts playing (which will be some time after
        the URI for the next title has been set).
    -}
    | MessageTypeNeedContext
    {- ^
    Message indicating that an element wants a specific context (Since 1.2)
    -}
    | MessageTypeHaveContext
    {- ^
    Message indicating that an element created a context (Since 1.2)
    -}
    | MessageTypeExtended
    {- ^
    Message is an extended message type (see below).
        These extended message IDs can\'t be used directly with mask-based API
        like 'GI.Gst.Objects.Bus.busPoll' or 'GI.Gst.Objects.Bus.busTimedPopFiltered', but you can still
        filter for GST_MESSAGE_EXTENDED and then check the result for the
        specific type. (Since 1.4)
    -}
    | MessageTypeDeviceAdded
    {- ^
    Message indicating a 'GI.Gst.Objects.Device.Device' was added to
        a 'GI.Gst.Objects.DeviceProvider.DeviceProvider' (Since 1.4)
    -}
    | MessageTypeDeviceRemoved
    {- ^
    Message indicating a 'GI.Gst.Objects.Device.Device' was removed
        from a 'GI.Gst.Objects.DeviceProvider.DeviceProvider' (Since 1.4)
    -}
    | MessageTypePropertyNotify
    {- ^
    Message indicating a 'GI.GObject.Objects.Object.Object' property has
        changed (Since 1.10)
    -}
    | MessageTypeStreamCollection
    {- ^
    Message indicating a new 'GI.Gst.Objects.StreamCollection.StreamCollection'
        is available (Since 1.10)
    -}
    | MessageTypeStreamsSelected
    {- ^
    Message indicating the active selection of
        @/GstStreams/@ has changed (Since 1.10)
    -}
    | MessageTypeRedirect
    {- ^
    Message indicating to request the application to
        try to play the given URL(s). Useful if for example a HTTP 302\/303
        response is received with a non-HTTP URL inside. (Since 1.10)
    -}
    | MessageTypeDeviceChanged
    {- ^
    Message indicating a 'GI.Gst.Objects.Device.Device' was changed
        a 'GI.Gst.Objects.DeviceProvider.DeviceProvider' (Since 1.16)
    -}
    | MessageTypeAny
    {- ^
    mask for all of the above messages.
    -}
    | AnotherMessageType Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum MessageType where
    fromEnum MessageTypeUnknown = 0
    fromEnum MessageTypeEos = 1
    fromEnum MessageTypeError = 2
    fromEnum MessageTypeWarning = 4
    fromEnum MessageTypeInfo = 8
    fromEnum MessageTypeTag = 16
    fromEnum MessageTypeBuffering = 32
    fromEnum MessageTypeStateChanged = 64
    fromEnum MessageTypeStateDirty = 128
    fromEnum MessageTypeStepDone = 256
    fromEnum MessageTypeClockProvide = 512
    fromEnum MessageTypeClockLost = 1024
    fromEnum MessageTypeNewClock = 2048
    fromEnum MessageTypeStructureChange = 4096
    fromEnum MessageTypeStreamStatus = 8192
    fromEnum MessageTypeApplication = 16384
    fromEnum MessageTypeElement = 32768
    fromEnum MessageTypeSegmentStart = 65536
    fromEnum MessageTypeSegmentDone = 131072
    fromEnum MessageTypeDurationChanged = 262144
    fromEnum MessageTypeLatency = 524288
    fromEnum MessageTypeAsyncStart = 1048576
    fromEnum MessageTypeAsyncDone = 2097152
    fromEnum MessageTypeRequestState = 4194304
    fromEnum MessageTypeStepStart = 8388608
    fromEnum MessageTypeQos = 16777216
    fromEnum MessageTypeProgress = 33554432
    fromEnum MessageTypeToc = 67108864
    fromEnum MessageTypeResetTime = 134217728
    fromEnum MessageTypeStreamStart = 268435456
    fromEnum MessageTypeNeedContext = 536870912
    fromEnum MessageTypeHaveContext = 1073741824
    fromEnum MessageTypeExtended = 2147483648
    fromEnum MessageTypeDeviceAdded = 2147483649
    fromEnum MessageTypeDeviceRemoved = 2147483650
    fromEnum MessageTypePropertyNotify = 2147483651
    fromEnum MessageTypeStreamCollection = 2147483652
    fromEnum MessageTypeStreamsSelected = 2147483653
    fromEnum MessageTypeRedirect = 2147483654
    fromEnum MessageTypeDeviceChanged = 2147483654
    fromEnum MessageTypeAny = 4294967295
    fromEnum (AnotherMessageType k) = k

    toEnum 0 = MessageTypeUnknown
    toEnum 1 = MessageTypeEos
    toEnum 2 = MessageTypeError
    toEnum 4 = MessageTypeWarning
    toEnum 8 = MessageTypeInfo
    toEnum 16 = MessageTypeTag
    toEnum 32 = MessageTypeBuffering
    toEnum 64 = MessageTypeStateChanged
    toEnum 128 = MessageTypeStateDirty
    toEnum 256 = MessageTypeStepDone
    toEnum 512 = MessageTypeClockProvide
    toEnum 1024 = MessageTypeClockLost
    toEnum 2048 = MessageTypeNewClock
    toEnum 4096 = MessageTypeStructureChange
    toEnum 8192 = MessageTypeStreamStatus
    toEnum 16384 = MessageTypeApplication
    toEnum 32768 = MessageTypeElement
    toEnum 65536 = MessageTypeSegmentStart
    toEnum 131072 = MessageTypeSegmentDone
    toEnum 262144 = MessageTypeDurationChanged
    toEnum 524288 = MessageTypeLatency
    toEnum 1048576 = MessageTypeAsyncStart
    toEnum 2097152 = MessageTypeAsyncDone
    toEnum 4194304 = MessageTypeRequestState
    toEnum 8388608 = MessageTypeStepStart
    toEnum 16777216 = MessageTypeQos
    toEnum 33554432 = MessageTypeProgress
    toEnum 67108864 = MessageTypeToc
    toEnum 134217728 = MessageTypeResetTime
    toEnum 268435456 = MessageTypeStreamStart
    toEnum 536870912 = MessageTypeNeedContext
    toEnum 1073741824 = MessageTypeHaveContext
    toEnum 2147483648 = MessageTypeExtended
    toEnum 2147483649 = MessageTypeDeviceAdded
    toEnum 2147483650 = MessageTypeDeviceRemoved
    toEnum 2147483651 = MessageTypePropertyNotify
    toEnum 2147483652 = MessageTypeStreamCollection
    toEnum 2147483653 = MessageTypeStreamsSelected
    toEnum 2147483654 = MessageTypeRedirect
    toEnum 2147483654 = MessageTypeDeviceChanged
    toEnum 4294967295 = MessageTypeAny
    toEnum k = AnotherMessageType k

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

foreign import ccall "gst_message_type_get_type" c_gst_message_type_get_type :: 
    IO GType

instance BoxedFlags MessageType where
    boxedFlagsType _ = c_gst_message_type_get_type

instance IsGFlag MessageType

-- Flags MemoryFlags
{- |
Flags for wrapped memory.
-}
data MemoryFlags = 
      MemoryFlagsReadonly
    {- ^
    memory is readonly. It is not allowed to map the
    memory with @/GST_MAP_WRITE/@.
    -}
    | MemoryFlagsNoShare
    {- ^
    memory must not be shared. Copies will have to be
    made when this memory needs to be shared between buffers.
    -}
    | MemoryFlagsZeroPrefixed
    {- ^
    the memory prefix is filled with 0 bytes
    -}
    | MemoryFlagsZeroPadded
    {- ^
    the memory padding is filled with 0 bytes
    -}
    | MemoryFlagsPhysicallyContiguous
    {- ^
    the memory is physically contiguous. (Since 1.2)
    -}
    | MemoryFlagsNotMappable
    {- ^
    the memory can\'t be mapped via 'GI.Gst.Structs.Memory.memoryMap' without any preconditions. (Since 1.2)
    -}
    | MemoryFlagsLast
    {- ^
    first flag that can be used for custom purposes
    -}
    | AnotherMemoryFlags Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum MemoryFlags where
    fromEnum MemoryFlagsReadonly = 2
    fromEnum MemoryFlagsNoShare = 16
    fromEnum MemoryFlagsZeroPrefixed = 32
    fromEnum MemoryFlagsZeroPadded = 64
    fromEnum MemoryFlagsPhysicallyContiguous = 128
    fromEnum MemoryFlagsNotMappable = 256
    fromEnum MemoryFlagsLast = 1048576
    fromEnum (AnotherMemoryFlags k) = k

    toEnum 2 = MemoryFlagsReadonly
    toEnum 16 = MemoryFlagsNoShare
    toEnum 32 = MemoryFlagsZeroPrefixed
    toEnum 64 = MemoryFlagsZeroPadded
    toEnum 128 = MemoryFlagsPhysicallyContiguous
    toEnum 256 = MemoryFlagsNotMappable
    toEnum 1048576 = MemoryFlagsLast
    toEnum k = AnotherMemoryFlags k

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

foreign import ccall "gst_memory_flags_get_type" c_gst_memory_flags_get_type :: 
    IO GType

instance BoxedFlags MemoryFlags where
    boxedFlagsType _ = c_gst_memory_flags_get_type

instance IsGFlag MemoryFlags

-- Flags MapFlags
{- |
Flags used when mapping memory
-}
data MapFlags = 
      MapFlagsRead
    {- ^
    map for read access
    -}
    | MapFlagsWrite
    {- ^
    map for write access
    -}
    | MapFlagsFlagLast
    {- ^
    first flag that can be used for custom purposes
    -}
    | AnotherMapFlags Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum MapFlags where
    fromEnum MapFlagsRead = 1
    fromEnum MapFlagsWrite = 2
    fromEnum MapFlagsFlagLast = 65536
    fromEnum (AnotherMapFlags k) = k

    toEnum 1 = MapFlagsRead
    toEnum 2 = MapFlagsWrite
    toEnum 65536 = MapFlagsFlagLast
    toEnum k = AnotherMapFlags k

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

foreign import ccall "gst_map_flags_get_type" c_gst_map_flags_get_type :: 
    IO GType

instance BoxedFlags MapFlags where
    boxedFlagsType _ = c_gst_map_flags_get_type

instance IsGFlag MapFlags

-- Flags LockFlags
{- |
Flags used when locking miniobjects
-}
data LockFlags = 
      LockFlagsRead
    {- ^
    lock for read access
    -}
    | LockFlagsWrite
    {- ^
    lock for write access
    -}
    | LockFlagsExclusive
    {- ^
    lock for exclusive access
    -}
    | LockFlagsLast
    {- ^
    first flag that can be used for custom purposes
    -}
    | AnotherLockFlags Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum LockFlags where
    fromEnum LockFlagsRead = 1
    fromEnum LockFlagsWrite = 2
    fromEnum LockFlagsExclusive = 4
    fromEnum LockFlagsLast = 256
    fromEnum (AnotherLockFlags k) = k

    toEnum 1 = LockFlagsRead
    toEnum 2 = LockFlagsWrite
    toEnum 4 = LockFlagsExclusive
    toEnum 256 = LockFlagsLast
    toEnum k = AnotherLockFlags k

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

foreign import ccall "gst_lock_flags_get_type" c_gst_lock_flags_get_type :: 
    IO GType

instance BoxedFlags LockFlags where
    boxedFlagsType _ = c_gst_lock_flags_get_type

instance IsGFlag LockFlags

-- Flags EventTypeFlags
{- |
'GI.Gst.Flags.EventTypeFlags' indicate the aspects of the different 'GI.Gst.Enums.EventType'
values. You can get the type flags of a 'GI.Gst.Enums.EventType' with the
'GI.Gst.Functions.eventTypeGetFlags' function.
-}
data EventTypeFlags = 
      EventTypeFlagsUpstream
    {- ^
    Set if the event can travel upstream.
    -}
    | EventTypeFlagsDownstream
    {- ^
    Set if the event can travel downstream.
    -}
    | EventTypeFlagsSerialized
    {- ^
    Set if the event should be serialized with data
                                  flow.
    -}
    | EventTypeFlagsSticky
    {- ^
    Set if the event is sticky on the pads.
    -}
    | EventTypeFlagsStickyMulti
    {- ^
    Multiple sticky events can be on a pad, each
                                  identified by the event name.
    -}
    | AnotherEventTypeFlags Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum EventTypeFlags where
    fromEnum EventTypeFlagsUpstream = 1
    fromEnum EventTypeFlagsDownstream = 2
    fromEnum EventTypeFlagsSerialized = 4
    fromEnum EventTypeFlagsSticky = 8
    fromEnum EventTypeFlagsStickyMulti = 16
    fromEnum (AnotherEventTypeFlags k) = k

    toEnum 1 = EventTypeFlagsUpstream
    toEnum 2 = EventTypeFlagsDownstream
    toEnum 4 = EventTypeFlagsSerialized
    toEnum 8 = EventTypeFlagsSticky
    toEnum 16 = EventTypeFlagsStickyMulti
    toEnum k = AnotherEventTypeFlags k

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

foreign import ccall "gst_event_type_flags_get_type" c_gst_event_type_flags_get_type :: 
    IO GType

instance BoxedFlags EventTypeFlags where
    boxedFlagsType _ = c_gst_event_type_flags_get_type

instance IsGFlag EventTypeFlags

-- Flags ElementFlags
{- |
The standard flags that an element may have.
-}
data ElementFlags = 
      ElementFlagsLockedState
    {- ^
    ignore state changes from parent
    -}
    | ElementFlagsSink
    {- ^
    the element is a sink
    -}
    | ElementFlagsSource
    {- ^
    the element is a source.
    -}
    | ElementFlagsProvideClock
    {- ^
    the element can provide a clock
    -}
    | ElementFlagsRequireClock
    {- ^
    the element requires a clock
    -}
    | ElementFlagsIndexable
    {- ^
    the element can use an index
    -}
    | ElementFlagsLast
    {- ^
    offset to define more flags
    -}
    | AnotherElementFlags Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum ElementFlags where
    fromEnum ElementFlagsLockedState = 16
    fromEnum ElementFlagsSink = 32
    fromEnum ElementFlagsSource = 64
    fromEnum ElementFlagsProvideClock = 128
    fromEnum ElementFlagsRequireClock = 256
    fromEnum ElementFlagsIndexable = 512
    fromEnum ElementFlagsLast = 16384
    fromEnum (AnotherElementFlags k) = k

    toEnum 16 = ElementFlagsLockedState
    toEnum 32 = ElementFlagsSink
    toEnum 64 = ElementFlagsSource
    toEnum 128 = ElementFlagsProvideClock
    toEnum 256 = ElementFlagsRequireClock
    toEnum 512 = ElementFlagsIndexable
    toEnum 16384 = ElementFlagsLast
    toEnum k = AnotherElementFlags k

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

foreign import ccall "gst_element_flags_get_type" c_gst_element_flags_get_type :: 
    IO GType

instance BoxedFlags ElementFlags where
    boxedFlagsType _ = c_gst_element_flags_get_type

instance IsGFlag ElementFlags

-- Flags DebugGraphDetails
{- |
Available details for pipeline graphs produced by @/GST_DEBUG_BIN_TO_DOT_FILE()/@
and @/GST_DEBUG_BIN_TO_DOT_FILE_WITH_TS()/@.
-}
data DebugGraphDetails = 
      DebugGraphDetailsMediaType
    {- ^
    show caps-name on edges
    -}
    | DebugGraphDetailsCapsDetails
    {- ^
    show caps-details on edges
    -}
    | DebugGraphDetailsNonDefaultParams
    {- ^
    show modified parameters on
                                              elements
    -}
    | DebugGraphDetailsStates
    {- ^
    show element states
    -}
    | DebugGraphDetailsFullParams
    {- ^
    show full element parameter values even
                                       if they are very long
    -}
    | DebugGraphDetailsAll
    {- ^
    show all the typical details that one might want
    -}
    | DebugGraphDetailsVerbose
    {- ^
    show all details regardless of how large or
                                   verbose they make the resulting output
    -}
    | AnotherDebugGraphDetails Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum DebugGraphDetails where
    fromEnum DebugGraphDetailsMediaType = 1
    fromEnum DebugGraphDetailsCapsDetails = 2
    fromEnum DebugGraphDetailsNonDefaultParams = 4
    fromEnum DebugGraphDetailsStates = 8
    fromEnum DebugGraphDetailsFullParams = 16
    fromEnum DebugGraphDetailsAll = 15
    fromEnum DebugGraphDetailsVerbose = 4294967295
    fromEnum (AnotherDebugGraphDetails k) = k

    toEnum 1 = DebugGraphDetailsMediaType
    toEnum 2 = DebugGraphDetailsCapsDetails
    toEnum 4 = DebugGraphDetailsNonDefaultParams
    toEnum 8 = DebugGraphDetailsStates
    toEnum 16 = DebugGraphDetailsFullParams
    toEnum 15 = DebugGraphDetailsAll
    toEnum 4294967295 = DebugGraphDetailsVerbose
    toEnum k = AnotherDebugGraphDetails k

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

foreign import ccall "gst_debug_graph_details_get_type" c_gst_debug_graph_details_get_type :: 
    IO GType

instance BoxedFlags DebugGraphDetails where
    boxedFlagsType _ = c_gst_debug_graph_details_get_type

instance IsGFlag DebugGraphDetails

-- Flags DebugColorFlags
{- |
These are some terminal style flags you can use when creating your
debugging categories to make them stand out in debugging output.
-}
data DebugColorFlags = 
      DebugColorFlagsFgBlack
    {- ^
    Use black as foreground color.
    -}
    | DebugColorFlagsFgRed
    {- ^
    Use red as foreground color.
    -}
    | DebugColorFlagsFgGreen
    {- ^
    Use green as foreground color.
    -}
    | DebugColorFlagsFgYellow
    {- ^
    Use yellow as foreground color.
    -}
    | DebugColorFlagsFgBlue
    {- ^
    Use blue as foreground color.
    -}
    | DebugColorFlagsFgMagenta
    {- ^
    Use magenta as foreground color.
    -}
    | DebugColorFlagsFgCyan
    {- ^
    Use cyan as foreground color.
    -}
    | DebugColorFlagsFgWhite
    {- ^
    Use white as foreground color.
    -}
    | DebugColorFlagsBgBlack
    {- ^
    Use black as background color.
    -}
    | DebugColorFlagsBgRed
    {- ^
    Use red as background color.
    -}
    | DebugColorFlagsBgGreen
    {- ^
    Use green as background color.
    -}
    | DebugColorFlagsBgYellow
    {- ^
    Use yellow as background color.
    -}
    | DebugColorFlagsBgBlue
    {- ^
    Use blue as background color.
    -}
    | DebugColorFlagsBgMagenta
    {- ^
    Use magenta as background color.
    -}
    | DebugColorFlagsBgCyan
    {- ^
    Use cyan as background color.
    -}
    | DebugColorFlagsBgWhite
    {- ^
    Use white as background color.
    -}
    | DebugColorFlagsBold
    {- ^
    Make the output bold.
    -}
    | DebugColorFlagsUnderline
    {- ^
    Underline the output.
    -}
    | AnotherDebugColorFlags Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum DebugColorFlags where
    fromEnum DebugColorFlagsFgBlack = 0
    fromEnum DebugColorFlagsFgRed = 1
    fromEnum DebugColorFlagsFgGreen = 2
    fromEnum DebugColorFlagsFgYellow = 3
    fromEnum DebugColorFlagsFgBlue = 4
    fromEnum DebugColorFlagsFgMagenta = 5
    fromEnum DebugColorFlagsFgCyan = 6
    fromEnum DebugColorFlagsFgWhite = 7
    fromEnum DebugColorFlagsBgBlack = 0
    fromEnum DebugColorFlagsBgRed = 16
    fromEnum DebugColorFlagsBgGreen = 32
    fromEnum DebugColorFlagsBgYellow = 48
    fromEnum DebugColorFlagsBgBlue = 64
    fromEnum DebugColorFlagsBgMagenta = 80
    fromEnum DebugColorFlagsBgCyan = 96
    fromEnum DebugColorFlagsBgWhite = 112
    fromEnum DebugColorFlagsBold = 256
    fromEnum DebugColorFlagsUnderline = 512
    fromEnum (AnotherDebugColorFlags k) = k

    toEnum 0 = DebugColorFlagsFgBlack
    toEnum 1 = DebugColorFlagsFgRed
    toEnum 2 = DebugColorFlagsFgGreen
    toEnum 3 = DebugColorFlagsFgYellow
    toEnum 4 = DebugColorFlagsFgBlue
    toEnum 5 = DebugColorFlagsFgMagenta
    toEnum 6 = DebugColorFlagsFgCyan
    toEnum 7 = DebugColorFlagsFgWhite
    toEnum 0 = DebugColorFlagsBgBlack
    toEnum 16 = DebugColorFlagsBgRed
    toEnum 32 = DebugColorFlagsBgGreen
    toEnum 48 = DebugColorFlagsBgYellow
    toEnum 64 = DebugColorFlagsBgBlue
    toEnum 80 = DebugColorFlagsBgMagenta
    toEnum 96 = DebugColorFlagsBgCyan
    toEnum 112 = DebugColorFlagsBgWhite
    toEnum 256 = DebugColorFlagsBold
    toEnum 512 = DebugColorFlagsUnderline
    toEnum k = AnotherDebugColorFlags k

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

foreign import ccall "gst_debug_color_flags_get_type" c_gst_debug_color_flags_get_type :: 
    IO GType

instance BoxedFlags DebugColorFlags where
    boxedFlagsType _ = c_gst_debug_color_flags_get_type

instance IsGFlag DebugColorFlags

-- Flags ClockFlags
{- |
The capabilities of this clock
-}
data ClockFlags = 
      ClockFlagsCanDoSingleSync
    {- ^
    clock can do a single sync timeout request
    -}
    | ClockFlagsCanDoSingleAsync
    {- ^
    clock can do a single async timeout request
    -}
    | ClockFlagsCanDoPeriodicSync
    {- ^
    clock can do sync periodic timeout requests
    -}
    | ClockFlagsCanDoPeriodicAsync
    {- ^
    clock can do async periodic timeout callbacks
    -}
    | ClockFlagsCanSetResolution
    {- ^
    clock\'s resolution can be changed
    -}
    | ClockFlagsCanSetMaster
    {- ^
    clock can be slaved to a master clock
    -}
    | ClockFlagsNeedsStartupSync
    {- ^
    clock needs to be synced before it can be used
        (Since 1.6)
    -}
    | ClockFlagsLast
    {- ^
    subclasses can add additional flags starting from this flag
    -}
    | AnotherClockFlags Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum ClockFlags where
    fromEnum ClockFlagsCanDoSingleSync = 16
    fromEnum ClockFlagsCanDoSingleAsync = 32
    fromEnum ClockFlagsCanDoPeriodicSync = 64
    fromEnum ClockFlagsCanDoPeriodicAsync = 128
    fromEnum ClockFlagsCanSetResolution = 256
    fromEnum ClockFlagsCanSetMaster = 512
    fromEnum ClockFlagsNeedsStartupSync = 1024
    fromEnum ClockFlagsLast = 4096
    fromEnum (AnotherClockFlags k) = k

    toEnum 16 = ClockFlagsCanDoSingleSync
    toEnum 32 = ClockFlagsCanDoSingleAsync
    toEnum 64 = ClockFlagsCanDoPeriodicSync
    toEnum 128 = ClockFlagsCanDoPeriodicAsync
    toEnum 256 = ClockFlagsCanSetResolution
    toEnum 512 = ClockFlagsCanSetMaster
    toEnum 1024 = ClockFlagsNeedsStartupSync
    toEnum 4096 = ClockFlagsLast
    toEnum k = AnotherClockFlags k

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

foreign import ccall "gst_clock_flags_get_type" c_gst_clock_flags_get_type :: 
    IO GType

instance BoxedFlags ClockFlags where
    boxedFlagsType _ = c_gst_clock_flags_get_type

instance IsGFlag ClockFlags

-- Flags CapsFlags
{- |
Extra flags for a caps.
-}
data CapsFlags = 
      CapsFlagsAny
    {- ^
    Caps has no specific content, but can contain
       anything.
    -}
    | AnotherCapsFlags Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum CapsFlags where
    fromEnum CapsFlagsAny = 16
    fromEnum (AnotherCapsFlags k) = k

    toEnum 16 = CapsFlagsAny
    toEnum k = AnotherCapsFlags k

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

foreign import ccall "gst_caps_flags_get_type" c_gst_caps_flags_get_type :: 
    IO GType

instance BoxedFlags CapsFlags where
    boxedFlagsType _ = c_gst_caps_flags_get_type

instance IsGFlag CapsFlags

-- Flags BusFlags
{- |
The standard flags that a bus may have.
-}
data BusFlags = 
      BusFlagsFlushing
    {- ^
    The bus is currently dropping all messages
    -}
    | BusFlagsFlagLast
    {- ^
    offset to define more flags
    -}
    | AnotherBusFlags Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum BusFlags where
    fromEnum BusFlagsFlushing = 16
    fromEnum BusFlagsFlagLast = 32
    fromEnum (AnotherBusFlags k) = k

    toEnum 16 = BusFlagsFlushing
    toEnum 32 = BusFlagsFlagLast
    toEnum k = AnotherBusFlags k

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

foreign import ccall "gst_bus_flags_get_type" c_gst_bus_flags_get_type :: 
    IO GType

instance BoxedFlags BusFlags where
    boxedFlagsType _ = c_gst_bus_flags_get_type

instance IsGFlag BusFlags

-- Flags BufferPoolAcquireFlags
{- |
Additional flags to control the allocation of a buffer
-}
data BufferPoolAcquireFlags = 
      BufferPoolAcquireFlagsNone
    {- ^
    no flags
    -}
    | BufferPoolAcquireFlagsKeyUnit
    {- ^
    buffer is keyframe
    -}
    | BufferPoolAcquireFlagsDontwait
    {- ^
    when the bufferpool is empty, acquire_buffer
    will by default block until a buffer is released into the pool again. Setting
    this flag makes acquire_buffer return @/GST_FLOW_EOS/@ instead of blocking.
    -}
    | BufferPoolAcquireFlagsDiscont
    {- ^
    buffer is discont
    -}
    | BufferPoolAcquireFlagsLast
    {- ^
    last flag, subclasses can use private flags
       starting from this value.
    -}
    | AnotherBufferPoolAcquireFlags Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum BufferPoolAcquireFlags where
    fromEnum BufferPoolAcquireFlagsNone = 0
    fromEnum BufferPoolAcquireFlagsKeyUnit = 1
    fromEnum BufferPoolAcquireFlagsDontwait = 2
    fromEnum BufferPoolAcquireFlagsDiscont = 4
    fromEnum BufferPoolAcquireFlagsLast = 65536
    fromEnum (AnotherBufferPoolAcquireFlags k) = k

    toEnum 0 = BufferPoolAcquireFlagsNone
    toEnum 1 = BufferPoolAcquireFlagsKeyUnit
    toEnum 2 = BufferPoolAcquireFlagsDontwait
    toEnum 4 = BufferPoolAcquireFlagsDiscont
    toEnum 65536 = BufferPoolAcquireFlagsLast
    toEnum k = AnotherBufferPoolAcquireFlags k

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

foreign import ccall "gst_buffer_pool_acquire_flags_get_type" c_gst_buffer_pool_acquire_flags_get_type :: 
    IO GType

instance BoxedFlags BufferPoolAcquireFlags where
    boxedFlagsType _ = c_gst_buffer_pool_acquire_flags_get_type

instance IsGFlag BufferPoolAcquireFlags

-- Flags BufferFlags
{- |
A set of buffer flags used to describe properties of a 'GI.Gst.Structs.Buffer.Buffer'.
-}
data BufferFlags = 
      BufferFlagsLive
    {- ^
    the buffer is live data and should be discarded in
                                    the PAUSED state.
    -}
    | BufferFlagsDecodeOnly
    {- ^
    the buffer contains data that should be dropped
                                    because it will be clipped against the segment
                                    boundaries or because it does not contain data
                                    that should be shown to the user.
    -}
    | BufferFlagsDiscont
    {- ^
    the buffer marks a data discontinuity in the stream.
                                    This typically occurs after a seek or a dropped buffer
                                    from a live or network source.
    -}
    | BufferFlagsResync
    {- ^
    the buffer timestamps might have a discontinuity
                                    and this buffer is a good point to resynchronize.
    -}
    | BufferFlagsCorrupted
    {- ^
    the buffer data is corrupted.
    -}
    | BufferFlagsMarker
    {- ^
    the buffer contains a media specific marker. for
                                    video this is typically the end of a frame boundary, for audio
                                    this is usually the start of a talkspurt.
    -}
    | BufferFlagsHeader
    {- ^
    the buffer contains header information that is
                                    needed to decode the following data.
    -}
    | BufferFlagsGap
    {- ^
    the buffer has been created to fill a gap in the
                                    stream and contains media neutral data (elements can
                                    switch to optimized code path that ignores the buffer
                                    content).
    -}
    | BufferFlagsDroppable
    {- ^
    the buffer can be dropped without breaking the
                                    stream, for example to reduce bandwidth.
    -}
    | BufferFlagsDeltaUnit
    {- ^
    this unit cannot be decoded independently.
    -}
    | BufferFlagsTagMemory
    {- ^
    this flag is set when memory of the buffer
                                    is added\/removed
    -}
    | BufferFlagsSyncAfter
    {- ^
    Elements which write to disk or permanent
    				 storage should ensure the data is synced after
    				 writing the contents of this buffer. (Since 1.6)
    -}
    | BufferFlagsNonDroppable
    {- ^
    This buffer is important and should not be dropped.
                                    This can be used to mark important buffers, e.g. to flag
                                    RTP packets carrying keyframes or codec setup data for RTP
                                    Forward Error Correction purposes, or to prevent still video
                                    frames from being dropped by elements due to QoS. (Since 1.14)
    -}
    | BufferFlagsLast
    {- ^
    additional media specific flags can be added starting from
                                    this flag.
    -}
    | AnotherBufferFlags Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum BufferFlags where
    fromEnum BufferFlagsLive = 16
    fromEnum BufferFlagsDecodeOnly = 32
    fromEnum BufferFlagsDiscont = 64
    fromEnum BufferFlagsResync = 128
    fromEnum BufferFlagsCorrupted = 256
    fromEnum BufferFlagsMarker = 512
    fromEnum BufferFlagsHeader = 1024
    fromEnum BufferFlagsGap = 2048
    fromEnum BufferFlagsDroppable = 4096
    fromEnum BufferFlagsDeltaUnit = 8192
    fromEnum BufferFlagsTagMemory = 16384
    fromEnum BufferFlagsSyncAfter = 32768
    fromEnum BufferFlagsNonDroppable = 65536
    fromEnum BufferFlagsLast = 1048576
    fromEnum (AnotherBufferFlags k) = k

    toEnum 16 = BufferFlagsLive
    toEnum 32 = BufferFlagsDecodeOnly
    toEnum 64 = BufferFlagsDiscont
    toEnum 128 = BufferFlagsResync
    toEnum 256 = BufferFlagsCorrupted
    toEnum 512 = BufferFlagsMarker
    toEnum 1024 = BufferFlagsHeader
    toEnum 2048 = BufferFlagsGap
    toEnum 4096 = BufferFlagsDroppable
    toEnum 8192 = BufferFlagsDeltaUnit
    toEnum 16384 = BufferFlagsTagMemory
    toEnum 32768 = BufferFlagsSyncAfter
    toEnum 65536 = BufferFlagsNonDroppable
    toEnum 1048576 = BufferFlagsLast
    toEnum k = AnotherBufferFlags k

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

foreign import ccall "gst_buffer_flags_get_type" c_gst_buffer_flags_get_type :: 
    IO GType

instance BoxedFlags BufferFlags where
    boxedFlagsType _ = c_gst_buffer_flags_get_type

instance IsGFlag BufferFlags

-- Flags BufferCopyFlags
{- |
A set of flags that can be provided to the 'GI.Gst.Structs.Buffer.bufferCopyInto'
function to specify which items should be copied.
-}
data BufferCopyFlags = 
      BufferCopyFlagsNone
    {- ^
    copy nothing
    -}
    | BufferCopyFlagsFlags
    {- ^
    flag indicating that buffer flags should be copied
    -}
    | BufferCopyFlagsTimestamps
    {- ^
    flag indicating that buffer pts, dts,
      duration, offset and offset_end should be copied
    -}
    | BufferCopyFlagsMeta
    {- ^
    flag indicating that buffer meta should be
      copied
    -}
    | BufferCopyFlagsMemory
    {- ^
    flag indicating that buffer memory should be reffed
      and appended to already existing memory. Unless the memory is marked as
      NO_SHARE, no actual copy of the memory is made but it is simply reffed.
      Add /@gSTBUFFERCOPYDEEP@/ to force a real copy.
    -}
    | BufferCopyFlagsMerge
    {- ^
    flag indicating that buffer memory should be
      merged
    -}
    | BufferCopyFlagsDeep
    {- ^
    flag indicating that memory should always be
      copied instead of reffed (Since 1.2)
    -}
    | AnotherBufferCopyFlags Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum BufferCopyFlags where
    fromEnum BufferCopyFlagsNone = 0
    fromEnum BufferCopyFlagsFlags = 1
    fromEnum BufferCopyFlagsTimestamps = 2
    fromEnum BufferCopyFlagsMeta = 4
    fromEnum BufferCopyFlagsMemory = 8
    fromEnum BufferCopyFlagsMerge = 16
    fromEnum BufferCopyFlagsDeep = 32
    fromEnum (AnotherBufferCopyFlags k) = k

    toEnum 0 = BufferCopyFlagsNone
    toEnum 1 = BufferCopyFlagsFlags
    toEnum 2 = BufferCopyFlagsTimestamps
    toEnum 4 = BufferCopyFlagsMeta
    toEnum 8 = BufferCopyFlagsMemory
    toEnum 16 = BufferCopyFlagsMerge
    toEnum 32 = BufferCopyFlagsDeep
    toEnum k = AnotherBufferCopyFlags k

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

foreign import ccall "gst_buffer_copy_flags_get_type" c_gst_buffer_copy_flags_get_type :: 
    IO GType

instance BoxedFlags BufferCopyFlags where
    boxedFlagsType _ = c_gst_buffer_copy_flags_get_type

instance IsGFlag BufferCopyFlags

-- Flags BinFlags
{- |
GstBinFlags are a set of flags specific to bins. Most are set\/used
internally. They can be checked using the GST_OBJECT_FLAG_IS_SET () macro,
and (un)set using GST_OBJECT_FLAG_SET () and GST_OBJECT_FLAG_UNSET ().
-}
data BinFlags = 
      BinFlagsNoResync
    {- ^
    don\'t resync a state change when elements are
                added or linked in the bin (Since 1.0.5)
    -}
    | BinFlagsStreamsAware
    {- ^
    Indicates whether the bin can handle elements
                that add\/remove source pads at any point in time without
                first posting a no-more-pads signal (Since 1.10)
    -}
    | BinFlagsLast
    {- ^
    the last enum in the series of flags for bins.
    Derived classes can use this as first value in a list of flags.
    -}
    | AnotherBinFlags Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum BinFlags where
    fromEnum BinFlagsNoResync = 16384
    fromEnum BinFlagsStreamsAware = 32768
    fromEnum BinFlagsLast = 524288
    fromEnum (AnotherBinFlags k) = k

    toEnum 16384 = BinFlagsNoResync
    toEnum 32768 = BinFlagsStreamsAware
    toEnum 524288 = BinFlagsLast
    toEnum k = AnotherBinFlags k

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

foreign import ccall "gst_bin_flags_get_type" c_gst_bin_flags_get_type :: 
    IO GType

instance BoxedFlags BinFlags where
    boxedFlagsType _ = c_gst_bin_flags_get_type

instance IsGFlag BinFlags

-- Flags AllocatorFlags
{- |
Flags for allocators.
-}
data AllocatorFlags = 
      AllocatorFlagsCustomAlloc
    {- ^
    The allocator has a custom alloc function.
    -}
    | AllocatorFlagsLast
    {- ^
    first flag that can be used for custom purposes
    -}
    | AnotherAllocatorFlags Int
    -- ^ Catch-all for unknown values
    deriving (Show, Eq)

instance P.Enum AllocatorFlags where
    fromEnum AllocatorFlagsCustomAlloc = 16
    fromEnum AllocatorFlagsLast = 1048576
    fromEnum (AnotherAllocatorFlags k) = k

    toEnum 16 = AllocatorFlagsCustomAlloc
    toEnum 1048576 = AllocatorFlagsLast
    toEnum k = AnotherAllocatorFlags k

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

foreign import ccall "gst_allocator_flags_get_type" c_gst_allocator_flags_get_type :: 
    IO GType

instance BoxedFlags AllocatorFlags where
    boxedFlagsType _ = c_gst_allocator_flags_get_type

instance IsGFlag AllocatorFlags