{-# LANGUAGE PatternSynonyms, ScopedTypeVariables, ViewPatterns #-}


-- | 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.Gst.Constants
    ( 
    pattern VERSION_NANO                    ,
    pattern VERSION_MINOR                   ,
    pattern VERSION_MICRO                   ,
    pattern VERSION_MAJOR                   ,
    pattern VALUE_UNORDERED                 ,
    pattern VALUE_LESS_THAN                 ,
    pattern VALUE_GREATER_THAN              ,
    pattern VALUE_EQUAL                     ,
    pattern USECOND                         ,
    pattern URI_NO_PORT                     ,
    pattern TOC_REPEAT_COUNT_INFINITE       ,
    pattern TAG_VIDEO_CODEC                 ,
    pattern TAG_VERSION                     ,
    pattern TAG_USER_RATING                 ,
    pattern TAG_TRACK_PEAK                  ,
    pattern TAG_TRACK_NUMBER                ,
    pattern TAG_TRACK_GAIN                  ,
    pattern TAG_TRACK_COUNT                 ,
    pattern TAG_TITLE_SORTNAME              ,
    pattern TAG_TITLE                       ,
    pattern TAG_SUBTITLE_CODEC              ,
    pattern TAG_SHOW_SORTNAME               ,
    pattern TAG_SHOW_SEASON_NUMBER          ,
    pattern TAG_SHOW_NAME                   ,
    pattern TAG_SHOW_EPISODE_NUMBER         ,
    pattern TAG_SERIAL                      ,
    pattern TAG_REFERENCE_LEVEL             ,
    pattern TAG_PUBLISHER                   ,
    pattern TAG_PRIVATE_DATA                ,
    pattern TAG_PREVIEW_IMAGE               ,
    pattern TAG_PERFORMER                   ,
    pattern TAG_ORGANIZATION                ,
    pattern TAG_NOMINAL_BITRATE             ,
    pattern TAG_MINIMUM_BITRATE             ,
    pattern TAG_MIDI_BASE_NOTE              ,
    pattern TAG_MAXIMUM_BITRATE             ,
    pattern TAG_LYRICS                      ,
    pattern TAG_LOCATION                    ,
    pattern TAG_LICENSE_URI                 ,
    pattern TAG_LICENSE                     ,
    pattern TAG_LANGUAGE_NAME               ,
    pattern TAG_LANGUAGE_CODE               ,
    pattern TAG_KEYWORDS                    ,
    pattern TAG_ISRC                        ,
    pattern TAG_INTERPRETED_BY              ,
    pattern TAG_IMAGE_ORIENTATION           ,
    pattern TAG_IMAGE                       ,
    pattern TAG_HOMEPAGE                    ,
    pattern TAG_GROUPING                    ,
    pattern TAG_GEO_LOCATION_SUBLOCATION    ,
    pattern TAG_GEO_LOCATION_NAME           ,
    pattern TAG_GEO_LOCATION_MOVEMENT_SPEED ,
    pattern TAG_GEO_LOCATION_MOVEMENT_DIRECTION,
    pattern TAG_GEO_LOCATION_LONGITUDE      ,
    pattern TAG_GEO_LOCATION_LATITUDE       ,
    pattern TAG_GEO_LOCATION_HORIZONTAL_ERROR,
    pattern TAG_GEO_LOCATION_ELEVATION      ,
    pattern TAG_GEO_LOCATION_COUNTRY        ,
    pattern TAG_GEO_LOCATION_CITY           ,
    pattern TAG_GEO_LOCATION_CAPTURE_DIRECTION,
    pattern TAG_GENRE                       ,
    pattern TAG_EXTENDED_COMMENT            ,
    pattern TAG_ENCODER_VERSION             ,
    pattern TAG_ENCODER                     ,
    pattern TAG_ENCODED_BY                  ,
    pattern TAG_DURATION                    ,
    pattern TAG_DEVICE_MODEL                ,
    pattern TAG_DEVICE_MANUFACTURER         ,
    pattern TAG_DESCRIPTION                 ,
    pattern TAG_DATE_TIME                   ,
    pattern TAG_DATE                        ,
    pattern TAG_COPYRIGHT_URI               ,
    pattern TAG_COPYRIGHT                   ,
    pattern TAG_CONTAINER_FORMAT            ,
    pattern TAG_CONTACT                     ,
    pattern TAG_CONDUCTOR                   ,
    pattern TAG_COMPOSER_SORTNAME           ,
    pattern TAG_COMPOSER                    ,
    pattern TAG_COMMENT                     ,
    pattern TAG_CODEC                       ,
    pattern TAG_BITRATE                     ,
    pattern TAG_BEATS_PER_MINUTE            ,
    pattern TAG_AUDIO_CODEC                 ,
    pattern TAG_ATTACHMENT                  ,
    pattern TAG_ARTIST_SORTNAME             ,
    pattern TAG_ARTIST                      ,
    pattern TAG_APPLICATION_NAME            ,
    pattern TAG_APPLICATION_DATA            ,
    pattern TAG_ALBUM_VOLUME_NUMBER         ,
    pattern TAG_ALBUM_VOLUME_COUNT          ,
    pattern TAG_ALBUM_SORTNAME              ,
    pattern TAG_ALBUM_PEAK                  ,
    pattern TAG_ALBUM_GAIN                  ,
    pattern TAG_ALBUM_ARTIST_SORTNAME       ,
    pattern TAG_ALBUM_ARTIST                ,
    pattern TAG_ALBUM                       ,
    pattern SEQNUM_INVALID                  ,
    pattern SEGMENT_INSTANT_FLAGS           ,
    pattern SECOND                          ,
    pattern QUERY_TYPE_BOTH                 ,
    pattern QUERY_NUM_SHIFT                 ,
    pattern PROTECTION_UNSPECIFIED_SYSTEM_ID,
    pattern PROTECTION_SYSTEM_ID_CAPS_FIELD ,
    pattern PARAM_USER_SHIFT                ,
    pattern PARAM_MUTABLE_READY             ,
    pattern PARAM_MUTABLE_PLAYING           ,
    pattern PARAM_MUTABLE_PAUSED            ,
    pattern PARAM_DOC_SHOW_DEFAULT          ,
    pattern PARAM_CONTROLLABLE              ,
    pattern PARAM_CONDITIONALLY_AVAILABLE   ,
    pattern NSECOND                         ,
    pattern MSECOND                         ,
    pattern META_TAG_MEMORY_STR             ,
    pattern MAP_READWRITE                   ,
    pattern LOCK_FLAG_READWRITE             ,
    pattern LICENSE_UNKNOWN                 ,
    pattern GROUP_ID_INVALID                ,
    pattern FORMAT_PERCENT_SCALE            ,
    pattern FORMAT_PERCENT_MAX              ,
    pattern FLAG_SET_MASK_EXACT             ,
    pattern EVENT_TYPE_BOTH                 ,
    pattern EVENT_NUM_SHIFT                 ,
    pattern ELEMENT_METADATA_LONGNAME       ,
    pattern ELEMENT_METADATA_KLASS          ,
    pattern ELEMENT_METADATA_ICON_NAME      ,
    pattern ELEMENT_METADATA_DOC_URI        ,
    pattern ELEMENT_METADATA_DESCRIPTION    ,
    pattern ELEMENT_METADATA_AUTHOR         ,
    pattern ELEMENT_FACTORY_TYPE_VIDEO_ENCODER,
    pattern ELEMENT_FACTORY_TYPE_SRC        ,
    pattern ELEMENT_FACTORY_TYPE_SINK       ,
    pattern ELEMENT_FACTORY_TYPE_PAYLOADER  ,
    pattern ELEMENT_FACTORY_TYPE_PARSER     ,
    pattern ELEMENT_FACTORY_TYPE_MUXER      ,
    pattern ELEMENT_FACTORY_TYPE_MEDIA_VIDEO,
    pattern ELEMENT_FACTORY_TYPE_MEDIA_SUBTITLE,
    pattern ELEMENT_FACTORY_TYPE_MEDIA_METADATA,
    pattern ELEMENT_FACTORY_TYPE_MEDIA_IMAGE,
    pattern ELEMENT_FACTORY_TYPE_MEDIA_AUDIO,
    pattern ELEMENT_FACTORY_TYPE_MEDIA_ANY  ,
    pattern ELEMENT_FACTORY_TYPE_MAX_ELEMENTS,
    pattern ELEMENT_FACTORY_TYPE_HARDWARE   ,
    pattern ELEMENT_FACTORY_TYPE_FORMATTER  ,
    pattern ELEMENT_FACTORY_TYPE_ENCRYPTOR  ,
    pattern ELEMENT_FACTORY_TYPE_ENCODER    ,
    pattern ELEMENT_FACTORY_TYPE_DEPAYLOADER,
    pattern ELEMENT_FACTORY_TYPE_DEMUXER    ,
    pattern ELEMENT_FACTORY_TYPE_DECRYPTOR  ,
    pattern ELEMENT_FACTORY_TYPE_DECODER    ,
    pattern ELEMENT_FACTORY_TYPE_DECODABLE  ,
    pattern ELEMENT_FACTORY_TYPE_AUDIO_ENCODER,
    pattern ELEMENT_FACTORY_TYPE_AUDIOVIDEO_SINKS,
    pattern ELEMENT_FACTORY_TYPE_ANY        ,
    pattern ELEMENT_FACTORY_KLASS_SRC       ,
    pattern ELEMENT_FACTORY_KLASS_SINK      ,
    pattern ELEMENT_FACTORY_KLASS_PAYLOADER ,
    pattern ELEMENT_FACTORY_KLASS_PARSER    ,
    pattern ELEMENT_FACTORY_KLASS_MUXER     ,
    pattern ELEMENT_FACTORY_KLASS_MEDIA_VIDEO,
    pattern ELEMENT_FACTORY_KLASS_MEDIA_SUBTITLE,
    pattern ELEMENT_FACTORY_KLASS_MEDIA_METADATA,
    pattern ELEMENT_FACTORY_KLASS_MEDIA_IMAGE,
    pattern ELEMENT_FACTORY_KLASS_MEDIA_AUDIO,
    pattern ELEMENT_FACTORY_KLASS_HARDWARE  ,
    pattern ELEMENT_FACTORY_KLASS_FORMATTER ,
    pattern ELEMENT_FACTORY_KLASS_ENCRYPTOR ,
    pattern ELEMENT_FACTORY_KLASS_ENCODER   ,
    pattern ELEMENT_FACTORY_KLASS_DEPAYLOADER,
    pattern ELEMENT_FACTORY_KLASS_DEMUXER   ,
    pattern ELEMENT_FACTORY_KLASS_DECRYPTOR ,
    pattern ELEMENT_FACTORY_KLASS_DECODER   ,
    pattern DEBUG_FORMAT_MASK               ,
    pattern DEBUG_FG_MASK                   ,
    pattern DEBUG_BG_MASK                   ,
    pattern CLOCK_TIME_NONE                 ,
    pattern CAPS_FEATURE_MEMORY_SYSTEM_MEMORY,
    pattern CAN_INLINE                      ,
    pattern BUFFER_OFFSET_NONE              ,
    pattern BUFFER_COPY_METADATA            ,
    pattern BUFFER_COPY_ALL                 ,
    pattern ALLOCATOR_SYSMEM                ,

    ) 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

import {-# SOURCE #-} qualified GI.Gst.Flags as Gst.Flags

-- | The nano version of GStreamer at compile time:
-- Actual releases have 0, GIT versions have 1, prerelease versions have 2-...
pattern $mVERSION_NANO :: forall {r}. Int32 -> ((# #) -> r) -> ((# #) -> r) -> r
$bVERSION_NANO :: Int32
VERSION_NANO = 0 :: Int32

-- | The minor version of GStreamer at compile time:
pattern $mVERSION_MINOR :: forall {r}. Int32 -> ((# #) -> r) -> ((# #) -> r) -> r
$bVERSION_MINOR :: Int32
VERSION_MINOR = 20 :: Int32

-- | The micro version of GStreamer at compile time:
pattern $mVERSION_MICRO :: forall {r}. Int32 -> ((# #) -> r) -> ((# #) -> r) -> r
$bVERSION_MICRO :: Int32
VERSION_MICRO = 3 :: Int32

-- | The major version of GStreamer at compile time:
pattern $mVERSION_MAJOR :: forall {r}. Int32 -> ((# #) -> r) -> ((# #) -> r) -> r
$bVERSION_MAJOR :: Int32
VERSION_MAJOR = 1 :: Int32

-- | Indicates that the comparison function ('GI.Gst.Functions.valueCompare') can not
-- determine a order for the two provided values.
pattern $mVALUE_UNORDERED :: forall {r}. Int32 -> ((# #) -> r) -> ((# #) -> r) -> r
$bVALUE_UNORDERED :: Int32
VALUE_UNORDERED = 2 :: Int32

-- | Indicates that the first value provided to a comparison function
-- ('GI.Gst.Functions.valueCompare') is lesser than the second one.
pattern $mVALUE_LESS_THAN :: forall {r}. Int32 -> ((# #) -> r) -> ((# #) -> r) -> r
$bVALUE_LESS_THAN :: Int32
VALUE_LESS_THAN = -1 :: Int32

-- | Indicates that the first value provided to a comparison function
-- ('GI.Gst.Functions.valueCompare') is greater than the second one.
pattern $mVALUE_GREATER_THAN :: forall {r}. Int32 -> ((# #) -> r) -> ((# #) -> r) -> r
$bVALUE_GREATER_THAN :: Int32
VALUE_GREATER_THAN = 1 :: Int32

-- | Indicates that the first value provided to a comparison function
-- ('GI.Gst.Functions.valueCompare') is equal to the second one.
pattern $mVALUE_EQUAL :: forall {r}. Int32 -> ((# #) -> r) -> ((# #) -> r) -> r
$bVALUE_EQUAL :: Int32
VALUE_EQUAL = 0 :: Int32

-- | Constant that defines one GStreamer microsecond.
pattern $mUSECOND :: forall {r}. Int64 -> ((# #) -> r) -> ((# #) -> r) -> r
$bUSECOND :: Int64
USECOND = 1000 :: Int64

-- | Value for t'GI.Gst.Structs.Uri.Uri'.port to indicate no port number.
pattern $mURI_NO_PORT :: forall {r}. Int32 -> ((# #) -> r) -> ((# #) -> r) -> r
$bURI_NO_PORT :: Int32
URI_NO_PORT = 0 :: Int32

-- | Special value for the repeat_count set in 'GI.Gst.Structs.TocEntry.tocEntrySetLoop' or
-- returned by 'GI.Gst.Structs.TocEntry.tocEntrySetLoop' to indicate infinite looping.
-- 
-- /Since: 1.4/
pattern $mTOC_REPEAT_COUNT_INFINITE :: forall {r}. Int32 -> ((# #) -> r) -> ((# #) -> r) -> r
$bTOC_REPEAT_COUNT_INFINITE :: Int32
TOC_REPEAT_COUNT_INFINITE = -1 :: Int32

-- | codec the video data is stored in (string)
pattern $mTAG_VIDEO_CODEC :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_VIDEO_CODEC :: Text
TAG_VIDEO_CODEC = "video-codec" :: T.Text

-- | version of this data (string)
pattern $mTAG_VERSION :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_VERSION :: Text
TAG_VERSION = "version" :: T.Text

-- | Rating attributed by a person (likely the application user).
-- The higher the value, the more the user likes this media
-- (unsigned int from 0 to 100)
pattern $mTAG_USER_RATING :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_USER_RATING :: Text
TAG_USER_RATING = "user-rating" :: T.Text

-- | peak of the track (double)
pattern $mTAG_TRACK_PEAK :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_TRACK_PEAK :: Text
TAG_TRACK_PEAK = "replaygain-track-peak" :: T.Text

-- | track number inside a collection (unsigned integer)
pattern $mTAG_TRACK_NUMBER :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_TRACK_NUMBER :: Text
TAG_TRACK_NUMBER = "track-number" :: T.Text

-- | track gain in db (double)
pattern $mTAG_TRACK_GAIN :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_TRACK_GAIN :: Text
TAG_TRACK_GAIN = "replaygain-track-gain" :: T.Text

-- | count of tracks inside collection this track belongs to (unsigned integer)
pattern $mTAG_TRACK_COUNT :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_TRACK_COUNT :: Text
TAG_TRACK_COUNT = "track-count" :: T.Text

-- | commonly used title, as used for sorting (string)
-- 
-- The title as it should be sorted, e.g. \'Doll House, The\'
pattern $mTAG_TITLE_SORTNAME :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_TITLE_SORTNAME :: Text
TAG_TITLE_SORTNAME = "title-sortname" :: T.Text

-- | commonly used title (string)
-- 
-- The title as it should be displayed, e.g. \'The Doll House\'
pattern $mTAG_TITLE :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_TITLE :: Text
TAG_TITLE = "title" :: T.Text

-- | codec\/format the subtitle data is stored in (string)
pattern $mTAG_SUBTITLE_CODEC :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_SUBTITLE_CODEC :: Text
TAG_SUBTITLE_CODEC = "subtitle-codec" :: T.Text

-- | Name of the show, used for sorting (string)
pattern $mTAG_SHOW_SORTNAME :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_SHOW_SORTNAME :: Text
TAG_SHOW_SORTNAME = "show-sortname" :: T.Text

-- | Number of the season of a show\/series (unsigned integer)
pattern $mTAG_SHOW_SEASON_NUMBER :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_SHOW_SEASON_NUMBER :: Text
TAG_SHOW_SEASON_NUMBER = "show-season-number" :: T.Text

-- | Name of the show, used for displaying (string)
pattern $mTAG_SHOW_NAME :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_SHOW_NAME :: Text
TAG_SHOW_NAME = "show-name" :: T.Text

-- | Number of the episode within a season\/show (unsigned integer)
pattern $mTAG_SHOW_EPISODE_NUMBER :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_SHOW_EPISODE_NUMBER :: Text
TAG_SHOW_EPISODE_NUMBER = "show-episode-number" :: T.Text

-- | serial number of track (unsigned integer)
pattern $mTAG_SERIAL :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_SERIAL :: Text
TAG_SERIAL = "serial" :: T.Text

-- | reference level of track and album gain values (double)
pattern $mTAG_REFERENCE_LEVEL :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_REFERENCE_LEVEL :: Text
TAG_REFERENCE_LEVEL = "replaygain-reference-level" :: T.Text

-- | Name of the label or publisher (string)
-- 
-- /Since: 1.2/
pattern $mTAG_PUBLISHER :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_PUBLISHER :: Text
TAG_PUBLISHER = "publisher" :: T.Text

-- | Any private data that may be contained in tags (sample).
-- 
-- It is represented by t'GI.Gst.Structs.Sample.Sample' in which t'GI.Gst.Structs.Buffer.Buffer' contains the
-- binary data and the sample\'s info t'GI.Gst.Structs.Structure.Structure' may contain any
-- extra information that identifies the origin or meaning of the data.
-- 
-- Private frames in ID3v2 tags (\'PRIV\' frames) will be represented
-- using this tag, in which case the GstStructure will be named
-- \"ID3PrivateFrame\" and contain a field named \"owner\" of type string
-- which contains the owner-identification string from the tag.
-- 
-- /Since: 1.8/
pattern $mTAG_PRIVATE_DATA :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_PRIVATE_DATA :: Text
TAG_PRIVATE_DATA = "private-data" :: T.Text

-- | image that is meant for preview purposes, e.g. small icon-sized version
-- (sample) (sample taglist should specify the content type)
pattern $mTAG_PREVIEW_IMAGE :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_PREVIEW_IMAGE :: Text
TAG_PREVIEW_IMAGE = "preview-image" :: T.Text

-- | person(s) performing (string)
pattern $mTAG_PERFORMER :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_PERFORMER :: Text
TAG_PERFORMER = "performer" :: T.Text

-- | organization (string)
pattern $mTAG_ORGANIZATION :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_ORGANIZATION :: Text
TAG_ORGANIZATION = "organization" :: T.Text

-- | nominal bitrate in bits\/s (unsigned integer). The actual bitrate might be
-- different from this target bitrate.
pattern $mTAG_NOMINAL_BITRATE :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_NOMINAL_BITRATE :: Text
TAG_NOMINAL_BITRATE = "nominal-bitrate" :: T.Text

-- | minimum bitrate in bits\/s (unsigned integer)
pattern $mTAG_MINIMUM_BITRATE :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_MINIMUM_BITRATE :: Text
TAG_MINIMUM_BITRATE = "minimum-bitrate" :: T.Text

-- | <http://en.wikipedia.org/wiki/Note#Note_designation_in_accordance_with_octave_name Midi note number>
-- of the audio track. This is useful for sample instruments and in particular
-- for multi-samples.
-- 
-- /Since: 1.4/
pattern $mTAG_MIDI_BASE_NOTE :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_MIDI_BASE_NOTE :: Text
TAG_MIDI_BASE_NOTE = "midi-base-note" :: T.Text

-- | maximum bitrate in bits\/s (unsigned integer)
pattern $mTAG_MAXIMUM_BITRATE :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_MAXIMUM_BITRATE :: Text
TAG_MAXIMUM_BITRATE = "maximum-bitrate" :: T.Text

-- | The lyrics of the media (string)
pattern $mTAG_LYRICS :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_LYRICS :: Text
TAG_LYRICS = "lyrics" :: T.Text

-- | Origin of media as a URI (location, where the original of the file or stream
-- is hosted) (string)
pattern $mTAG_LOCATION :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_LOCATION :: Text
TAG_LOCATION = "location" :: T.Text

-- | URI to location where license details can be found (string)
pattern $mTAG_LICENSE_URI :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_LICENSE_URI :: Text
TAG_LICENSE_URI = "license-uri" :: T.Text

-- | license of data (string)
pattern $mTAG_LICENSE :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_LICENSE :: Text
TAG_LICENSE = "license" :: T.Text

-- | Name of the language the content is in (string)
-- 
-- Free-form name of the language the content is in, if a language code
-- is not available. This tag should not be set in addition to a language
-- code. It is undefined what language or locale the language name is in.
pattern $mTAG_LANGUAGE_NAME :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_LANGUAGE_NAME :: Text
TAG_LANGUAGE_NAME = "language-name" :: T.Text

-- | ISO-639-2 or ISO-639-1 code for the language the content is in (string)
-- 
-- There is utility API in libgsttag in gst-plugins-base to obtain a translated
-- language name from the language code: @gst_tag_get_language_name()@
pattern $mTAG_LANGUAGE_CODE :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_LANGUAGE_CODE :: Text
TAG_LANGUAGE_CODE = "language-code" :: T.Text

-- | comma separated keywords describing the content (string).
pattern $mTAG_KEYWORDS :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_KEYWORDS :: Text
TAG_KEYWORDS = "keywords" :: T.Text

-- | International Standard Recording Code - see http:\/\/www.ifpi.org\/isrc\/ (string)
pattern $mTAG_ISRC :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_ISRC :: Text
TAG_ISRC = "isrc" :: T.Text

-- | Information about the people behind a remix and similar
-- interpretations of another existing piece (string)
-- 
-- /Since: 1.2/
pattern $mTAG_INTERPRETED_BY :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_INTERPRETED_BY :: Text
TAG_INTERPRETED_BY = "interpreted-by" :: T.Text

-- | Represents the \'Orientation\' tag from EXIF. Defines how the image
-- should be rotated and mirrored for display. (string)
-- 
-- This tag has a predefined set of allowed values:
--   \"rotate-0\"
--   \"rotate-90\"
--   \"rotate-180\"
--   \"rotate-270\"
--   \"flip-rotate-0\"
--   \"flip-rotate-90\"
--   \"flip-rotate-180\"
--   \"flip-rotate-270\"
-- 
-- The naming is adopted according to a possible transformation to perform
-- on the image to fix its orientation, obviously equivalent operations will
-- yield the same result.
-- 
-- Rotations indicated by the values are in clockwise direction and
-- \'flip\' means an horizontal mirroring.
pattern $mTAG_IMAGE_ORIENTATION :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_IMAGE_ORIENTATION :: Text
TAG_IMAGE_ORIENTATION = "image-orientation" :: T.Text

-- | image (sample) (sample taglist should specify the content type and preferably
-- also set \"image-type\" field as @GstTagImageType@)
pattern $mTAG_IMAGE :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_IMAGE :: Text
TAG_IMAGE = "image" :: T.Text

-- | Homepage for this media (i.e. artist or movie homepage) (string)
pattern $mTAG_HOMEPAGE :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_HOMEPAGE :: Text
TAG_HOMEPAGE = "homepage" :: T.Text

-- | Groups together media that are related and spans multiple tracks. An
-- example are multiple pieces of a concerto. (string)
pattern $mTAG_GROUPING :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_GROUPING :: Text
TAG_GROUPING = "grouping" :: T.Text

-- | A location \'smaller\' than GST_TAG_GEO_LOCATION_CITY that specifies better
-- where the media has been produced. (e.g. the neighborhood) (string).
-- 
-- This tag has been added as this is how it is handled\/named in XMP\'s
-- Iptc4xmpcore schema.
pattern $mTAG_GEO_LOCATION_SUBLOCATION :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_GEO_LOCATION_SUBLOCATION :: Text
TAG_GEO_LOCATION_SUBLOCATION = "geo-location-sublocation" :: T.Text

-- | human readable descriptive location of where the media has been recorded or
-- produced. (string).
pattern $mTAG_GEO_LOCATION_NAME :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_GEO_LOCATION_NAME :: Text
TAG_GEO_LOCATION_NAME = "geo-location-name" :: T.Text

-- | Speed of the capturing device when performing the capture.
-- Represented in m\/s. (double)
-- 
-- See also 'GI.Gst.Constants.TAG_GEO_LOCATION_MOVEMENT_DIRECTION'
pattern $mTAG_GEO_LOCATION_MOVEMENT_SPEED :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_GEO_LOCATION_MOVEMENT_SPEED :: Text
TAG_GEO_LOCATION_MOVEMENT_SPEED = "geo-location-movement-speed" :: T.Text

-- | Indicates the movement direction of the device performing the capture
-- of a media. It is represented as degrees in floating point representation,
-- 0 means the geographic north, and increases clockwise (double from 0 to 360)
-- 
-- See also 'GI.Gst.Constants.TAG_GEO_LOCATION_CAPTURE_DIRECTION'
pattern $mTAG_GEO_LOCATION_MOVEMENT_DIRECTION :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_GEO_LOCATION_MOVEMENT_DIRECTION :: Text
TAG_GEO_LOCATION_MOVEMENT_DIRECTION = "geo-location-movement-direction" :: T.Text

-- | geo longitude location of where the media has been recorded or produced in
-- degrees according to WGS84 (zero at the prime meridian in Greenwich\/UK,
-- negative values for western longitudes). (double).
pattern $mTAG_GEO_LOCATION_LONGITUDE :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_GEO_LOCATION_LONGITUDE :: Text
TAG_GEO_LOCATION_LONGITUDE = "geo-location-longitude" :: T.Text

-- | geo latitude location of where the media has been recorded or produced in
-- degrees according to WGS84 (zero at the equator, negative values for southern
-- latitudes) (double).
pattern $mTAG_GEO_LOCATION_LATITUDE :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_GEO_LOCATION_LATITUDE :: Text
TAG_GEO_LOCATION_LATITUDE = "geo-location-latitude" :: T.Text

-- | Represents the expected error on the horizontal positioning in
-- meters (double).
pattern $mTAG_GEO_LOCATION_HORIZONTAL_ERROR :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_GEO_LOCATION_HORIZONTAL_ERROR :: Text
TAG_GEO_LOCATION_HORIZONTAL_ERROR = "geo-location-horizontal-error" :: T.Text

-- | geo elevation of where the media has been recorded or produced in meters
-- according to WGS84 (zero is average sea level) (double).
pattern $mTAG_GEO_LOCATION_ELEVATION :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_GEO_LOCATION_ELEVATION :: Text
TAG_GEO_LOCATION_ELEVATION = "geo-location-elevation" :: T.Text

-- | The country (english name) where the media has been produced (string).
pattern $mTAG_GEO_LOCATION_COUNTRY :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_GEO_LOCATION_COUNTRY :: Text
TAG_GEO_LOCATION_COUNTRY = "geo-location-country" :: T.Text

-- | The city (english name) where the media has been produced (string).
pattern $mTAG_GEO_LOCATION_CITY :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_GEO_LOCATION_CITY :: Text
TAG_GEO_LOCATION_CITY = "geo-location-city" :: T.Text

-- | Indicates the direction the device is pointing to when capturing
-- a media. It is represented as degrees in floating point representation,
-- 0 means the geographic north, and increases clockwise (double from 0 to 360)
-- 
-- See also 'GI.Gst.Constants.TAG_GEO_LOCATION_MOVEMENT_DIRECTION'
pattern $mTAG_GEO_LOCATION_CAPTURE_DIRECTION :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_GEO_LOCATION_CAPTURE_DIRECTION :: Text
TAG_GEO_LOCATION_CAPTURE_DIRECTION = "geo-location-capture-direction" :: T.Text

-- | genre this data belongs to (string)
pattern $mTAG_GENRE :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_GENRE :: Text
TAG_GENRE = "genre" :: T.Text

-- | key\/value text commenting the data (string)
-- 
-- Must be in the form of \'key=comment\' or
-- \'key[lc]=comment\' where \'lc\' is an ISO-639
-- language code.
-- 
-- This tag is used for unknown Vorbis comment tags,
-- unknown APE tags and certain ID3v2 comment fields.
pattern $mTAG_EXTENDED_COMMENT :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_EXTENDED_COMMENT :: Text
TAG_EXTENDED_COMMENT = "extended-comment" :: T.Text

-- | version of the encoder used to encode this stream (unsigned integer)
pattern $mTAG_ENCODER_VERSION :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_ENCODER_VERSION :: Text
TAG_ENCODER_VERSION = "encoder-version" :: T.Text

-- | encoder used to encode this stream (string)
pattern $mTAG_ENCODER :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_ENCODER :: Text
TAG_ENCODER = "encoder" :: T.Text

-- | name of the person or organisation that encoded the file. May contain a
-- copyright message if the person or organisation also holds the copyright
-- (string)
-- 
-- Note: do not use this field to describe the encoding application. Use
-- 'GI.Gst.Constants.TAG_APPLICATION_NAME' or 'GI.Gst.Constants.TAG_COMMENT' for that.
pattern $mTAG_ENCODED_BY :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_ENCODED_BY :: Text
TAG_ENCODED_BY = "encoded-by" :: T.Text

-- | length in GStreamer time units (nanoseconds) (unsigned 64-bit integer)
pattern $mTAG_DURATION :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_DURATION :: Text
TAG_DURATION = "duration" :: T.Text

-- | Model of the device used to create the media (string)
pattern $mTAG_DEVICE_MODEL :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_DEVICE_MODEL :: Text
TAG_DEVICE_MODEL = "device-model" :: T.Text

-- | Manufacturer of the device used to create the media (string)
pattern $mTAG_DEVICE_MANUFACTURER :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_DEVICE_MANUFACTURER :: Text
TAG_DEVICE_MANUFACTURER = "device-manufacturer" :: T.Text

-- | short text describing the content of the data (string)
pattern $mTAG_DESCRIPTION :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_DESCRIPTION :: Text
TAG_DESCRIPTION = "description" :: T.Text

-- | date and time the data was created (t'GI.Gst.Structs.DateTime.DateTime' structure)
pattern $mTAG_DATE_TIME :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_DATE_TIME :: Text
TAG_DATE_TIME = "datetime" :: T.Text

-- | date the data was created (t'GI.GLib.Structs.Date.Date' structure)
pattern $mTAG_DATE :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_DATE :: Text
TAG_DATE = "date" :: T.Text

-- | URI to location where copyright details can be found (string)
pattern $mTAG_COPYRIGHT_URI :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_COPYRIGHT_URI :: Text
TAG_COPYRIGHT_URI = "copyright-uri" :: T.Text

-- | copyright notice of the data (string)
pattern $mTAG_COPYRIGHT :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_COPYRIGHT :: Text
TAG_COPYRIGHT = "copyright" :: T.Text

-- | container format the data is stored in (string)
pattern $mTAG_CONTAINER_FORMAT :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_CONTAINER_FORMAT :: Text
TAG_CONTAINER_FORMAT = "container-format" :: T.Text

-- | contact information (string)
pattern $mTAG_CONTACT :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_CONTACT :: Text
TAG_CONTACT = "contact" :: T.Text

-- | conductor\/performer refinement (string)
-- 
-- /Since: 1.8/
pattern $mTAG_CONDUCTOR :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_CONDUCTOR :: Text
TAG_CONDUCTOR = "conductor" :: T.Text

-- | The composer\'s name, used for sorting (string)
pattern $mTAG_COMPOSER_SORTNAME :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_COMPOSER_SORTNAME :: Text
TAG_COMPOSER_SORTNAME = "composer-sortname" :: T.Text

-- | person(s) who composed the recording (string)
pattern $mTAG_COMPOSER :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_COMPOSER :: Text
TAG_COMPOSER = "composer" :: T.Text

-- | free text commenting the data (string)
pattern $mTAG_COMMENT :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_COMMENT :: Text
TAG_COMMENT = "comment" :: T.Text

-- | codec the data is stored in (string)
pattern $mTAG_CODEC :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_CODEC :: Text
TAG_CODEC = "codec" :: T.Text

-- | exact or average bitrate in bits\/s (unsigned integer)
pattern $mTAG_BITRATE :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_BITRATE :: Text
TAG_BITRATE = "bitrate" :: T.Text

-- | number of beats per minute in audio (double)
pattern $mTAG_BEATS_PER_MINUTE :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_BEATS_PER_MINUTE :: Text
TAG_BEATS_PER_MINUTE = "beats-per-minute" :: T.Text

-- | codec the audio data is stored in (string)
pattern $mTAG_AUDIO_CODEC :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_AUDIO_CODEC :: Text
TAG_AUDIO_CODEC = "audio-codec" :: T.Text

-- | generic file attachment (sample) (sample taglist should specify the content
-- type and if possible set \"filename\" to the file name of the
-- attachment)
pattern $mTAG_ATTACHMENT :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_ATTACHMENT :: Text
TAG_ATTACHMENT = "attachment" :: T.Text

-- | person(s) responsible for the recording, as used for sorting (string)
-- 
-- The artist name as it should be sorted, e.g. \'Hendrix, Jimi\' or
-- \'Guitar Heroes, The\'
pattern $mTAG_ARTIST_SORTNAME :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_ARTIST_SORTNAME :: Text
TAG_ARTIST_SORTNAME = "artist-sortname" :: T.Text

-- | person(s) responsible for the recording (string)
-- 
-- The artist name as it should be displayed, e.g. \'Jimi Hendrix\' or
-- \'The Guitar Heroes\'
pattern $mTAG_ARTIST :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_ARTIST :: Text
TAG_ARTIST = "artist" :: T.Text

-- | Name of the application used to create the media (string)
pattern $mTAG_APPLICATION_NAME :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_APPLICATION_NAME :: Text
TAG_APPLICATION_NAME = "application-name" :: T.Text

-- | Arbitrary application data (sample)
-- 
-- Some formats allow applications to add their own arbitrary data
-- into files. This data is application dependent.
pattern $mTAG_APPLICATION_DATA :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_APPLICATION_DATA :: Text
TAG_APPLICATION_DATA = "application-data" :: T.Text

-- | disc number inside a collection (unsigned integer)
pattern $mTAG_ALBUM_VOLUME_NUMBER :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_ALBUM_VOLUME_NUMBER :: Text
TAG_ALBUM_VOLUME_NUMBER = "album-disc-number" :: T.Text

-- | count of discs inside collection this disc belongs to (unsigned integer)
pattern $mTAG_ALBUM_VOLUME_COUNT :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_ALBUM_VOLUME_COUNT :: Text
TAG_ALBUM_VOLUME_COUNT = "album-disc-count" :: T.Text

-- | album containing this data, as used for sorting (string)
-- 
-- The album name as it should be sorted, e.g. \'Jazz Guitar, The\'
pattern $mTAG_ALBUM_SORTNAME :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_ALBUM_SORTNAME :: Text
TAG_ALBUM_SORTNAME = "album-sortname" :: T.Text

-- | peak of the album (double)
pattern $mTAG_ALBUM_PEAK :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_ALBUM_PEAK :: Text
TAG_ALBUM_PEAK = "replaygain-album-peak" :: T.Text

-- | album gain in db (double)
pattern $mTAG_ALBUM_GAIN :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_ALBUM_GAIN :: Text
TAG_ALBUM_GAIN = "replaygain-album-gain" :: T.Text

-- | The artist of the entire album, as it should be sorted.
pattern $mTAG_ALBUM_ARTIST_SORTNAME :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_ALBUM_ARTIST_SORTNAME :: Text
TAG_ALBUM_ARTIST_SORTNAME = "album-artist-sortname" :: T.Text

-- | The artist of the entire album, as it should be displayed.
pattern $mTAG_ALBUM_ARTIST :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_ALBUM_ARTIST :: Text
TAG_ALBUM_ARTIST = "album-artist" :: T.Text

-- | album containing this data (string)
-- 
-- The album name as it should be displayed, e.g. \'The Jazz Guitar\'
pattern $mTAG_ALBUM :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bTAG_ALBUM :: Text
TAG_ALBUM = "album" :: T.Text

-- | A value which is guaranteed to never be returned by
-- 'GI.Gst.Functions.utilSeqnumNext'.
-- 
-- Can be used as a default value in variables used to store seqnum.
-- 
-- /Since: 1.14/
pattern $mSEQNUM_INVALID :: forall {r}. Int32 -> ((# #) -> r) -> ((# #) -> r) -> r
$bSEQNUM_INVALID :: Int32
SEQNUM_INVALID = 0 :: Int32

-- | /No description available in the introspection data./
pattern $mSEGMENT_INSTANT_FLAGS :: forall {r}. Int32 -> ((# #) -> r) -> ((# #) -> r) -> r
$bSEGMENT_INSTANT_FLAGS :: Int32
SEGMENT_INSTANT_FLAGS = 912 :: Int32

-- | Constant that defines one GStreamer second.
pattern $mSECOND :: forall {r}. Int64 -> ((# #) -> r) -> ((# #) -> r) -> r
$bSECOND :: Int64
SECOND = 1000000000 :: Int64

-- | The same thing as @/GST_QUERY_TYPE_UPSTREAM/@ | @/GST_QUERY_TYPE_DOWNSTREAM/@.
pattern $mQUERY_TYPE_BOTH :: forall {r}. [QueryTypeFlags] -> ((# #) -> r) -> ((# #) -> r) -> r
$bQUERY_TYPE_BOTH :: [QueryTypeFlags]
QUERY_TYPE_BOTH <- (gflagsToWord -> (3 :: Word64)) :: [Gst.Flags.QueryTypeFlags] where
    QUERY_TYPE_BOTH = Word64 -> [QueryTypeFlags]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags (Word64
3 :: Word64) :: [Gst.Flags.QueryTypeFlags]

-- | /No description available in the introspection data./
pattern $mQUERY_NUM_SHIFT :: forall {r}. Int32 -> ((# #) -> r) -> ((# #) -> r) -> r
$bQUERY_NUM_SHIFT :: Int32
QUERY_NUM_SHIFT = 8 :: Int32

-- | The protection system value of the unspecified UUID.
-- In some cases the system protection ID is not present in the contents or in their
-- metadata, as encrypted WebM.
-- This define is used to set the value of the \"system_id\" field in GstProtectionEvent,
-- with this value, the application will use an external information to choose which
-- protection system to use.
-- 
-- Example: The matroskademux uses this value in the case of encrypted WebM,
-- the application will choose the appropriate protection system based on the information
-- received through EME API.
-- 
-- /Since: 1.16/
pattern $mPROTECTION_UNSPECIFIED_SYSTEM_ID :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bPROTECTION_UNSPECIFIED_SYSTEM_ID :: Text
PROTECTION_UNSPECIFIED_SYSTEM_ID = "unspecified-system-id" :: T.Text

-- | The field name in a GstCaps that is used to signal the UUID of the protection
-- system.
-- 
-- /Since: 1.6/
pattern $mPROTECTION_SYSTEM_ID_CAPS_FIELD :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bPROTECTION_SYSTEM_ID_CAPS_FIELD :: Text
PROTECTION_SYSTEM_ID_CAPS_FIELD = "protection-system" :: T.Text

-- | Bits based on GST_PARAM_USER_SHIFT can be used by 3rd party applications.
pattern $mPARAM_USER_SHIFT :: forall {r}. Int32 -> ((# #) -> r) -> ((# #) -> r) -> r
$bPARAM_USER_SHIFT :: Int32
PARAM_USER_SHIFT = 65536 :: Int32

-- | Use this flag on GObject properties of GstElements to indicate that
-- they can be changed when the element is in the READY or lower state.
pattern $mPARAM_MUTABLE_READY :: forall {r}. Int32 -> ((# #) -> r) -> ((# #) -> r) -> r
$bPARAM_MUTABLE_READY :: Int32
PARAM_MUTABLE_READY = 1024 :: Int32

-- | Use this flag on GObject properties of GstElements to indicate that
-- they can be changed when the element is in the PLAYING or lower state.
-- This flag implies GST_PARAM_MUTABLE_PAUSED.
pattern $mPARAM_MUTABLE_PLAYING :: forall {r}. Int32 -> ((# #) -> r) -> ((# #) -> r) -> r
$bPARAM_MUTABLE_PLAYING :: Int32
PARAM_MUTABLE_PLAYING = 4096 :: Int32

-- | Use this flag on GObject properties of GstElements to indicate that
-- they can be changed when the element is in the PAUSED or lower state.
-- This flag implies GST_PARAM_MUTABLE_READY.
pattern $mPARAM_MUTABLE_PAUSED :: forall {r}. Int32 -> ((# #) -> r) -> ((# #) -> r) -> r
$bPARAM_MUTABLE_PAUSED :: Int32
PARAM_MUTABLE_PAUSED = 2048 :: Int32

-- | Use this flag on GObject properties of GstObject to indicate that
-- during @gst-inspect@ and friends, the default value should be used
-- as default instead of the current value.
-- 
-- /Since: 1.18/
pattern $mPARAM_DOC_SHOW_DEFAULT :: forall {r}. Int32 -> ((# #) -> r) -> ((# #) -> r) -> r
$bPARAM_DOC_SHOW_DEFAULT :: Int32
PARAM_DOC_SHOW_DEFAULT = 8192 :: Int32

-- | Use this flag on GObject properties to signal they can make sense to be.
-- controlled over time. This hint is used by the GstController.
pattern $mPARAM_CONTROLLABLE :: forall {r}. Int32 -> ((# #) -> r) -> ((# #) -> r) -> r
$bPARAM_CONTROLLABLE :: Int32
PARAM_CONTROLLABLE = 512 :: Int32

-- | Use this flag on GObject properties of GstObject to indicate that
-- they might not be available depending on environment such as OS, device, etc,
-- so such properties will be installed conditionally only if the GstObject is
-- able to support it.
-- 
-- /Since: 1.18/
pattern $mPARAM_CONDITIONALLY_AVAILABLE :: forall {r}. Int32 -> ((# #) -> r) -> ((# #) -> r) -> r
$bPARAM_CONDITIONALLY_AVAILABLE :: Int32
PARAM_CONDITIONALLY_AVAILABLE = 16384 :: Int32

-- | Constant that defines one GStreamer nanosecond
pattern $mNSECOND :: forall {r}. Int64 -> ((# #) -> r) -> ((# #) -> r) -> r
$bNSECOND :: Int64
NSECOND = 1 :: Int64

-- | Constant that defines one GStreamer millisecond.
pattern $mMSECOND :: forall {r}. Int64 -> ((# #) -> r) -> ((# #) -> r) -> r
$bMSECOND :: Int64
MSECOND = 1000000 :: Int64

-- | This metadata stays relevant as long as memory layout is unchanged.
-- 
-- /Since: 1.2/
pattern $mMETA_TAG_MEMORY_STR :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bMETA_TAG_MEMORY_STR :: Text
META_TAG_MEMORY_STR = "memory" :: T.Text

-- | GstMapFlags value alias for GST_MAP_READ | GST_MAP_WRITE
pattern $mMAP_READWRITE :: forall {r}. [MapFlags] -> ((# #) -> r) -> ((# #) -> r) -> r
$bMAP_READWRITE :: [MapFlags]
MAP_READWRITE <- (gflagsToWord -> (3 :: Word64)) :: [Gst.Flags.MapFlags] where
    MAP_READWRITE = Word64 -> [MapFlags]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags (Word64
3 :: Word64) :: [Gst.Flags.MapFlags]

-- | GstLockFlags value alias for GST_LOCK_FLAG_READ | GST_LOCK_FLAG_WRITE
pattern $mLOCK_FLAG_READWRITE :: forall {r}. [LockFlags] -> ((# #) -> r) -> ((# #) -> r) -> r
$bLOCK_FLAG_READWRITE :: [LockFlags]
LOCK_FLAG_READWRITE <- (gflagsToWord -> (3 :: Word64)) :: [Gst.Flags.LockFlags] where
    LOCK_FLAG_READWRITE = Word64 -> [LockFlags]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags (Word64
3 :: Word64) :: [Gst.Flags.LockFlags]

-- | To be used in GST_PLUGIN_DEFINE if unsure about the licence.
pattern $mLICENSE_UNKNOWN :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bLICENSE_UNKNOWN :: Text
LICENSE_UNKNOWN = "unknown" :: T.Text

-- | A value which is guaranteed to never be returned by
-- 'GI.Gst.Functions.utilGroupIdNext'.
-- 
-- Can be used as a default value in variables used to store group_id.
-- 
-- /Since: 1.14/
pattern $mGROUP_ID_INVALID :: forall {r}. Int32 -> ((# #) -> r) -> ((# #) -> r) -> r
$bGROUP_ID_INVALID :: Int32
GROUP_ID_INVALID = 0 :: Int32

-- | The value used to scale down the reported PERCENT format value to
-- its real value.
pattern $mFORMAT_PERCENT_SCALE :: forall {r}. Int64 -> ((# #) -> r) -> ((# #) -> r) -> r
$bFORMAT_PERCENT_SCALE :: Int64
FORMAT_PERCENT_SCALE = 10000 :: Int64

-- | The PERCENT format is between 0 and this value
pattern $mFORMAT_PERCENT_MAX :: forall {r}. Int64 -> ((# #) -> r) -> ((# #) -> r) -> r
$bFORMAT_PERCENT_MAX :: Int64
FORMAT_PERCENT_MAX = 1000000 :: Int64

-- | A mask value with all bits set, for use as a
-- GstFlagSet mask where all flag bits must match
-- exactly
-- 
-- /Since: 1.6/
pattern $mFLAG_SET_MASK_EXACT :: forall {r}. Word32 -> ((# #) -> r) -> ((# #) -> r) -> r
$bFLAG_SET_MASK_EXACT :: Word32
FLAG_SET_MASK_EXACT = 4294967295 :: Word32

-- | The same thing as @/GST_EVENT_TYPE_UPSTREAM/@ | @/GST_EVENT_TYPE_DOWNSTREAM/@.
pattern $mEVENT_TYPE_BOTH :: forall {r}. [EventTypeFlags] -> ((# #) -> r) -> ((# #) -> r) -> r
$bEVENT_TYPE_BOTH :: [EventTypeFlags]
EVENT_TYPE_BOTH <- (gflagsToWord -> (3 :: Word64)) :: [Gst.Flags.EventTypeFlags] where
    EVENT_TYPE_BOTH = Word64 -> [EventTypeFlags]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags (Word64
3 :: Word64) :: [Gst.Flags.EventTypeFlags]

-- | /No description available in the introspection data./
pattern $mEVENT_NUM_SHIFT :: forall {r}. Int32 -> ((# #) -> r) -> ((# #) -> r) -> r
$bEVENT_NUM_SHIFT :: Int32
EVENT_NUM_SHIFT = 8 :: Int32

-- | The long English name of the element. E.g. \"File Sink\"
pattern $mELEMENT_METADATA_LONGNAME :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bELEMENT_METADATA_LONGNAME :: Text
ELEMENT_METADATA_LONGNAME = "long-name" :: T.Text

-- | String describing the type of element, as an unordered list
-- separated with slashes (\'\/\'). See draft-klass.txt of the design docs
-- for more details and common types. E.g: \"Sink\/File\"
pattern $mELEMENT_METADATA_KLASS :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bELEMENT_METADATA_KLASS :: Text
ELEMENT_METADATA_KLASS = "klass" :: T.Text

-- | Elements that bridge to certain other products can include an icon of that
-- used product. Application can show the icon in menus\/selectors to help
-- identifying specific elements.
pattern $mELEMENT_METADATA_ICON_NAME :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bELEMENT_METADATA_ICON_NAME :: Text
ELEMENT_METADATA_ICON_NAME = "icon-name" :: T.Text

-- | Set uri pointing to user documentation. Applications can use this to show
-- help for e.g. effects to users.
pattern $mELEMENT_METADATA_DOC_URI :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bELEMENT_METADATA_DOC_URI :: Text
ELEMENT_METADATA_DOC_URI = "doc-uri" :: T.Text

-- | Sentence describing the purpose of the element.
-- E.g: \"Write stream to a file\"
pattern $mELEMENT_METADATA_DESCRIPTION :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bELEMENT_METADATA_DESCRIPTION :: Text
ELEMENT_METADATA_DESCRIPTION = "description" :: T.Text

-- | Name and contact details of the author(s). Use \\n to separate
-- multiple author details.
-- E.g: \"Joe Bloggs &lt;joe.blogs at foo.com&gt;\"
pattern $mELEMENT_METADATA_AUTHOR :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bELEMENT_METADATA_AUTHOR :: Text
ELEMENT_METADATA_AUTHOR = "author" :: T.Text

-- | All encoders handling video or image media types
pattern $mELEMENT_FACTORY_TYPE_VIDEO_ENCODER :: forall {r}. Word64 -> ((# #) -> r) -> ((# #) -> r) -> r
$bELEMENT_FACTORY_TYPE_VIDEO_ENCODER :: Word64
ELEMENT_FACTORY_TYPE_VIDEO_ENCODER = 2814749767106562 :: Word64

-- | /No description available in the introspection data./
pattern $mELEMENT_FACTORY_TYPE_SRC :: forall {r}. Word64 -> ((# #) -> r) -> ((# #) -> r) -> r
$bELEMENT_FACTORY_TYPE_SRC :: Word64
ELEMENT_FACTORY_TYPE_SRC = 8 :: Word64

-- | /No description available in the introspection data./
pattern $mELEMENT_FACTORY_TYPE_SINK :: forall {r}. Word64 -> ((# #) -> r) -> ((# #) -> r) -> r
$bELEMENT_FACTORY_TYPE_SINK :: Word64
ELEMENT_FACTORY_TYPE_SINK = 4 :: Word64

-- | /No description available in the introspection data./
pattern $mELEMENT_FACTORY_TYPE_PAYLOADER :: forall {r}. Word64 -> ((# #) -> r) -> ((# #) -> r) -> r
$bELEMENT_FACTORY_TYPE_PAYLOADER :: Word64
ELEMENT_FACTORY_TYPE_PAYLOADER = 128 :: Word64

-- | /No description available in the introspection data./
pattern $mELEMENT_FACTORY_TYPE_PARSER :: forall {r}. Word64 -> ((# #) -> r) -> ((# #) -> r) -> r
$bELEMENT_FACTORY_TYPE_PARSER :: Word64
ELEMENT_FACTORY_TYPE_PARSER = 64 :: Word64

-- | /No description available in the introspection data./
pattern $mELEMENT_FACTORY_TYPE_MUXER :: forall {r}. Word64 -> ((# #) -> r) -> ((# #) -> r) -> r
$bELEMENT_FACTORY_TYPE_MUXER :: Word64
ELEMENT_FACTORY_TYPE_MUXER = 16 :: Word64

-- | /No description available in the introspection data./
pattern $mELEMENT_FACTORY_TYPE_MEDIA_VIDEO :: forall {r}. Word64 -> ((# #) -> r) -> ((# #) -> r) -> r
$bELEMENT_FACTORY_TYPE_MEDIA_VIDEO :: Word64
ELEMENT_FACTORY_TYPE_MEDIA_VIDEO = 562949953421312 :: Word64

-- | /No description available in the introspection data./
pattern $mELEMENT_FACTORY_TYPE_MEDIA_SUBTITLE :: forall {r}. Word64 -> ((# #) -> r) -> ((# #) -> r) -> r
$bELEMENT_FACTORY_TYPE_MEDIA_SUBTITLE :: Word64
ELEMENT_FACTORY_TYPE_MEDIA_SUBTITLE = 4503599627370496 :: Word64

-- | /No description available in the introspection data./
pattern $mELEMENT_FACTORY_TYPE_MEDIA_METADATA :: forall {r}. Word64 -> ((# #) -> r) -> ((# #) -> r) -> r
$bELEMENT_FACTORY_TYPE_MEDIA_METADATA :: Word64
ELEMENT_FACTORY_TYPE_MEDIA_METADATA = 9007199254740992 :: Word64

-- | /No description available in the introspection data./
pattern $mELEMENT_FACTORY_TYPE_MEDIA_IMAGE :: forall {r}. Word64 -> ((# #) -> r) -> ((# #) -> r) -> r
$bELEMENT_FACTORY_TYPE_MEDIA_IMAGE :: Word64
ELEMENT_FACTORY_TYPE_MEDIA_IMAGE = 2251799813685248 :: Word64

-- | /No description available in the introspection data./
pattern $mELEMENT_FACTORY_TYPE_MEDIA_AUDIO :: forall {r}. Word64 -> ((# #) -> r) -> ((# #) -> r) -> r
$bELEMENT_FACTORY_TYPE_MEDIA_AUDIO :: Word64
ELEMENT_FACTORY_TYPE_MEDIA_AUDIO = 1125899906842624 :: Word64

-- | Elements matching any of the defined GST_ELEMENT_FACTORY_TYPE_MEDIA types
-- 
-- Note: Do not use this if you wish to not filter against any of the defined
-- media types. If you wish to do this, simply don\'t specify any
-- GST_ELEMENT_FACTORY_TYPE_MEDIA flag.
pattern $mELEMENT_FACTORY_TYPE_MEDIA_ANY :: forall {r}. Word64 -> ((# #) -> r) -> ((# #) -> r) -> r
$bELEMENT_FACTORY_TYPE_MEDIA_ANY :: Word64
ELEMENT_FACTORY_TYPE_MEDIA_ANY = 18446462598732840960 :: Word64

-- | /No description available in the introspection data./
pattern $mELEMENT_FACTORY_TYPE_MAX_ELEMENTS :: forall {r}. Word64 -> ((# #) -> r) -> ((# #) -> r) -> r
$bELEMENT_FACTORY_TYPE_MAX_ELEMENTS :: Word64
ELEMENT_FACTORY_TYPE_MAX_ELEMENTS = 281474976710656 :: Word64

-- | /No description available in the introspection data./
pattern $mELEMENT_FACTORY_TYPE_HARDWARE :: forall {r}. Word64 -> ((# #) -> r) -> ((# #) -> r) -> r
$bELEMENT_FACTORY_TYPE_HARDWARE :: Word64
ELEMENT_FACTORY_TYPE_HARDWARE = 4096 :: Word64

-- | /No description available in the introspection data./
pattern $mELEMENT_FACTORY_TYPE_FORMATTER :: forall {r}. Word64 -> ((# #) -> r) -> ((# #) -> r) -> r
$bELEMENT_FACTORY_TYPE_FORMATTER :: Word64
ELEMENT_FACTORY_TYPE_FORMATTER = 512 :: Word64

-- | /No description available in the introspection data./
pattern $mELEMENT_FACTORY_TYPE_ENCRYPTOR :: forall {r}. Word64 -> ((# #) -> r) -> ((# #) -> r) -> r
$bELEMENT_FACTORY_TYPE_ENCRYPTOR :: Word64
ELEMENT_FACTORY_TYPE_ENCRYPTOR = 2048 :: Word64

-- | /No description available in the introspection data./
pattern $mELEMENT_FACTORY_TYPE_ENCODER :: forall {r}. Word64 -> ((# #) -> r) -> ((# #) -> r) -> r
$bELEMENT_FACTORY_TYPE_ENCODER :: Word64
ELEMENT_FACTORY_TYPE_ENCODER = 2 :: Word64

-- | /No description available in the introspection data./
pattern $mELEMENT_FACTORY_TYPE_DEPAYLOADER :: forall {r}. Word64 -> ((# #) -> r) -> ((# #) -> r) -> r
$bELEMENT_FACTORY_TYPE_DEPAYLOADER :: Word64
ELEMENT_FACTORY_TYPE_DEPAYLOADER = 256 :: Word64

-- | /No description available in the introspection data./
pattern $mELEMENT_FACTORY_TYPE_DEMUXER :: forall {r}. Word64 -> ((# #) -> r) -> ((# #) -> r) -> r
$bELEMENT_FACTORY_TYPE_DEMUXER :: Word64
ELEMENT_FACTORY_TYPE_DEMUXER = 32 :: Word64

-- | /No description available in the introspection data./
pattern $mELEMENT_FACTORY_TYPE_DECRYPTOR :: forall {r}. Word64 -> ((# #) -> r) -> ((# #) -> r) -> r
$bELEMENT_FACTORY_TYPE_DECRYPTOR :: Word64
ELEMENT_FACTORY_TYPE_DECRYPTOR = 1024 :: Word64

-- | /No description available in the introspection data./
pattern $mELEMENT_FACTORY_TYPE_DECODER :: forall {r}. Word64 -> ((# #) -> r) -> ((# #) -> r) -> r
$bELEMENT_FACTORY_TYPE_DECODER :: Word64
ELEMENT_FACTORY_TYPE_DECODER = 1 :: Word64

-- | All elements used to \'decode\' streams (decoders, demuxers, parsers, depayloaders)
pattern $mELEMENT_FACTORY_TYPE_DECODABLE :: forall {r}. Word64 -> ((# #) -> r) -> ((# #) -> r) -> r
$bELEMENT_FACTORY_TYPE_DECODABLE :: Word64
ELEMENT_FACTORY_TYPE_DECODABLE = 1377 :: Word64

-- | All encoders handling audio media types
pattern $mELEMENT_FACTORY_TYPE_AUDIO_ENCODER :: forall {r}. Word64 -> ((# #) -> r) -> ((# #) -> r) -> r
$bELEMENT_FACTORY_TYPE_AUDIO_ENCODER :: Word64
ELEMENT_FACTORY_TYPE_AUDIO_ENCODER = 1125899906842626 :: Word64

-- | All sinks handling audio, video or image media types
pattern $mELEMENT_FACTORY_TYPE_AUDIOVIDEO_SINKS :: forall {r}. Word64 -> ((# #) -> r) -> ((# #) -> r) -> r
$bELEMENT_FACTORY_TYPE_AUDIOVIDEO_SINKS :: Word64
ELEMENT_FACTORY_TYPE_AUDIOVIDEO_SINKS = 3940649673949188 :: Word64

-- | Elements of any of the defined GST_ELEMENT_FACTORY_LIST types
pattern $mELEMENT_FACTORY_TYPE_ANY :: forall {r}. Word64 -> ((# #) -> r) -> ((# #) -> r) -> r
$bELEMENT_FACTORY_TYPE_ANY :: Word64
ELEMENT_FACTORY_TYPE_ANY = 562949953421311 :: Word64

-- | /No description available in the introspection data./
pattern $mELEMENT_FACTORY_KLASS_SRC :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bELEMENT_FACTORY_KLASS_SRC :: Text
ELEMENT_FACTORY_KLASS_SRC = "Source" :: T.Text

-- | /No description available in the introspection data./
pattern $mELEMENT_FACTORY_KLASS_SINK :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bELEMENT_FACTORY_KLASS_SINK :: Text
ELEMENT_FACTORY_KLASS_SINK = "Sink" :: T.Text

-- | /No description available in the introspection data./
pattern $mELEMENT_FACTORY_KLASS_PAYLOADER :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bELEMENT_FACTORY_KLASS_PAYLOADER :: Text
ELEMENT_FACTORY_KLASS_PAYLOADER = "Payloader" :: T.Text

-- | /No description available in the introspection data./
pattern $mELEMENT_FACTORY_KLASS_PARSER :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bELEMENT_FACTORY_KLASS_PARSER :: Text
ELEMENT_FACTORY_KLASS_PARSER = "Parser" :: T.Text

-- | /No description available in the introspection data./
pattern $mELEMENT_FACTORY_KLASS_MUXER :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bELEMENT_FACTORY_KLASS_MUXER :: Text
ELEMENT_FACTORY_KLASS_MUXER = "Muxer" :: T.Text

-- | /No description available in the introspection data./
pattern $mELEMENT_FACTORY_KLASS_MEDIA_VIDEO :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bELEMENT_FACTORY_KLASS_MEDIA_VIDEO :: Text
ELEMENT_FACTORY_KLASS_MEDIA_VIDEO = "Video" :: T.Text

-- | /No description available in the introspection data./
pattern $mELEMENT_FACTORY_KLASS_MEDIA_SUBTITLE :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bELEMENT_FACTORY_KLASS_MEDIA_SUBTITLE :: Text
ELEMENT_FACTORY_KLASS_MEDIA_SUBTITLE = "Subtitle" :: T.Text

-- | /No description available in the introspection data./
pattern $mELEMENT_FACTORY_KLASS_MEDIA_METADATA :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bELEMENT_FACTORY_KLASS_MEDIA_METADATA :: Text
ELEMENT_FACTORY_KLASS_MEDIA_METADATA = "Metadata" :: T.Text

-- | /No description available in the introspection data./
pattern $mELEMENT_FACTORY_KLASS_MEDIA_IMAGE :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bELEMENT_FACTORY_KLASS_MEDIA_IMAGE :: Text
ELEMENT_FACTORY_KLASS_MEDIA_IMAGE = "Image" :: T.Text

-- | /No description available in the introspection data./
pattern $mELEMENT_FACTORY_KLASS_MEDIA_AUDIO :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bELEMENT_FACTORY_KLASS_MEDIA_AUDIO :: Text
ELEMENT_FACTORY_KLASS_MEDIA_AUDIO = "Audio" :: T.Text

-- | Elements interacting with hardware devices should specify this classifier in
-- their metadata. You may need to put the element in \"READY\" state to test if
-- the hardware is present in the system.
-- 
-- /Since: 1.16/
pattern $mELEMENT_FACTORY_KLASS_HARDWARE :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bELEMENT_FACTORY_KLASS_HARDWARE :: Text
ELEMENT_FACTORY_KLASS_HARDWARE = "Hardware" :: T.Text

-- | /No description available in the introspection data./
pattern $mELEMENT_FACTORY_KLASS_FORMATTER :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bELEMENT_FACTORY_KLASS_FORMATTER :: Text
ELEMENT_FACTORY_KLASS_FORMATTER = "Formatter" :: T.Text

-- | /No description available in the introspection data./
pattern $mELEMENT_FACTORY_KLASS_ENCRYPTOR :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bELEMENT_FACTORY_KLASS_ENCRYPTOR :: Text
ELEMENT_FACTORY_KLASS_ENCRYPTOR = "Encryptor" :: T.Text

-- | /No description available in the introspection data./
pattern $mELEMENT_FACTORY_KLASS_ENCODER :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bELEMENT_FACTORY_KLASS_ENCODER :: Text
ELEMENT_FACTORY_KLASS_ENCODER = "Encoder" :: T.Text

-- | /No description available in the introspection data./
pattern $mELEMENT_FACTORY_KLASS_DEPAYLOADER :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bELEMENT_FACTORY_KLASS_DEPAYLOADER :: Text
ELEMENT_FACTORY_KLASS_DEPAYLOADER = "Depayloader" :: T.Text

-- | /No description available in the introspection data./
pattern $mELEMENT_FACTORY_KLASS_DEMUXER :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bELEMENT_FACTORY_KLASS_DEMUXER :: Text
ELEMENT_FACTORY_KLASS_DEMUXER = "Demuxer" :: T.Text

-- | /No description available in the introspection data./
pattern $mELEMENT_FACTORY_KLASS_DECRYPTOR :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bELEMENT_FACTORY_KLASS_DECRYPTOR :: Text
ELEMENT_FACTORY_KLASS_DECRYPTOR = "Decryptor" :: T.Text

-- | /No description available in the introspection data./
pattern $mELEMENT_FACTORY_KLASS_DECODER :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bELEMENT_FACTORY_KLASS_DECODER :: Text
ELEMENT_FACTORY_KLASS_DECODER = "Decoder" :: T.Text

-- | /No description available in the introspection data./
pattern $mDEBUG_FORMAT_MASK :: forall {r}. Int32 -> ((# #) -> r) -> ((# #) -> r) -> r
$bDEBUG_FORMAT_MASK :: Int32
DEBUG_FORMAT_MASK = 65280 :: Int32

-- | /No description available in the introspection data./
pattern $mDEBUG_FG_MASK :: forall {r}. Int32 -> ((# #) -> r) -> ((# #) -> r) -> r
$bDEBUG_FG_MASK :: Int32
DEBUG_FG_MASK = 15 :: Int32

-- | /No description available in the introspection data./
pattern $mDEBUG_BG_MASK :: forall {r}. Int32 -> ((# #) -> r) -> ((# #) -> r) -> r
$bDEBUG_BG_MASK :: Int32
DEBUG_BG_MASK = 240 :: Int32

-- | Constant to define an undefined clock time.
pattern $mCLOCK_TIME_NONE :: forall {r}. Word64 -> ((# #) -> r) -> ((# #) -> r) -> r
$bCLOCK_TIME_NONE :: Word64
CLOCK_TIME_NONE = 18446744073709551615 :: Word64

-- | /No description available in the introspection data./
pattern $mCAPS_FEATURE_MEMORY_SYSTEM_MEMORY :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bCAPS_FEATURE_MEMORY_SYSTEM_MEMORY :: Text
CAPS_FEATURE_MEMORY_SYSTEM_MEMORY = "memory:SystemMemory" :: T.Text

-- | /No description available in the introspection data./
pattern $mCAN_INLINE :: forall {r}. Int32 -> ((# #) -> r) -> ((# #) -> r) -> r
$bCAN_INLINE :: Int32
CAN_INLINE = 1 :: Int32

-- | Constant for no-offset return results.
pattern $mBUFFER_OFFSET_NONE :: forall {r}. Word64 -> ((# #) -> r) -> ((# #) -> r) -> r
$bBUFFER_OFFSET_NONE :: Word64
BUFFER_OFFSET_NONE = 18446744073709551615 :: Word64

-- | Combination of all possible metadata fields that can be copied with
-- 'GI.Gst.Structs.Buffer.bufferCopyInto'.
pattern $mBUFFER_COPY_METADATA :: forall {r}. [BufferCopyFlags] -> ((# #) -> r) -> ((# #) -> r) -> r
$bBUFFER_COPY_METADATA :: [BufferCopyFlags]
BUFFER_COPY_METADATA <- (gflagsToWord -> (7 :: Word64)) :: [Gst.Flags.BufferCopyFlags] where
    BUFFER_COPY_METADATA = Word64 -> [BufferCopyFlags]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags (Word64
7 :: Word64) :: [Gst.Flags.BufferCopyFlags]

-- | Combination of all possible fields that can be copied with
-- 'GI.Gst.Structs.Buffer.bufferCopyInto'.
pattern $mBUFFER_COPY_ALL :: forall {r}. [BufferCopyFlags] -> ((# #) -> r) -> ((# #) -> r) -> r
$bBUFFER_COPY_ALL :: [BufferCopyFlags]
BUFFER_COPY_ALL <- (gflagsToWord -> (15 :: Word64)) :: [Gst.Flags.BufferCopyFlags] where
    BUFFER_COPY_ALL = Word64 -> [BufferCopyFlags]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags (Word64
15 :: Word64) :: [Gst.Flags.BufferCopyFlags]

-- | The allocator name for the default system memory allocator
pattern $mALLOCATOR_SYSMEM :: forall {r}. Text -> ((# #) -> r) -> ((# #) -> r) -> r
$bALLOCATOR_SYSMEM :: Text
ALLOCATOR_SYSMEM = "SystemMemory" :: T.Text