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


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

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

module GI.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 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_CONTROLLABLE              ,
    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_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.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
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 {-# 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 $bVERSION_NANO :: Int32
$mVERSION_NANO :: forall r. Int32 -> (Void# -> r) -> (Void# -> r) -> r
VERSION_NANO = 0 :: Int32

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

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

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

-- | Indicates that the comparison function ('GI.Gst.Functions.valueCompare') can not
-- determine a order for the two provided values.
pattern $bVALUE_UNORDERED :: Int32
$mVALUE_UNORDERED :: forall r. Int32 -> (Void# -> r) -> (Void# -> r) -> r
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 $bVALUE_LESS_THAN :: Int32
$mVALUE_LESS_THAN :: forall r. Int32 -> (Void# -> r) -> (Void# -> r) -> r
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 $bVALUE_GREATER_THAN :: Int32
$mVALUE_GREATER_THAN :: forall r. Int32 -> (Void# -> r) -> (Void# -> r) -> r
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 $bVALUE_EQUAL :: Int32
$mVALUE_EQUAL :: forall r. Int32 -> (Void# -> r) -> (Void# -> r) -> r
VALUE_EQUAL = 0 :: Int32

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

-- | Value for t'GI.Gst.Structs.Uri.Uri'.port to indicate no port number.
pattern $bURI_NO_PORT :: Int32
$mURI_NO_PORT :: forall r. Int32 -> (Void# -> r) -> (Void# -> r) -> r
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 $bTOC_REPEAT_COUNT_INFINITE :: Int32
$mTOC_REPEAT_COUNT_INFINITE :: forall r. Int32 -> (Void# -> r) -> (Void# -> r) -> r
TOC_REPEAT_COUNT_INFINITE = -1 :: Int32

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

-- | version of this data (string)
pattern $bTAG_VERSION :: Text
$mTAG_VERSION :: forall r. Text -> (Void# -> r) -> (Void# -> r) -> r
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 $bTAG_USER_RATING :: Text
$mTAG_USER_RATING :: forall r. Text -> (Void# -> r) -> (Void# -> r) -> r
TAG_USER_RATING = "user-rating" :: T.Text

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

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

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

-- | count of tracks inside collection this track belongs to (unsigned integer)
pattern $bTAG_TRACK_COUNT :: Text
$mTAG_TRACK_COUNT :: forall r. Text -> (Void# -> r) -> (Void# -> r) -> r
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 $bTAG_TITLE_SORTNAME :: Text
$mTAG_TITLE_SORTNAME :: forall r. Text -> (Void# -> r) -> (Void# -> r) -> r
TAG_TITLE_SORTNAME = "title-sortname" :: T.Text

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

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

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

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

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

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

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

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

-- | Name of the label or publisher (string)
-- 
-- /Since: 1.2/
pattern $bTAG_PUBLISHER :: Text
$mTAG_PUBLISHER :: forall r. Text -> (Void# -> r) -> (Void# -> r) -> r
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 $bTAG_PRIVATE_DATA :: Text
$mTAG_PRIVATE_DATA :: forall r. Text -> (Void# -> r) -> (Void# -> r) -> r
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 $bTAG_PREVIEW_IMAGE :: Text
$mTAG_PREVIEW_IMAGE :: forall r. Text -> (Void# -> r) -> (Void# -> r) -> r
TAG_PREVIEW_IMAGE = "preview-image" :: T.Text

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

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

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

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

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

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

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

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

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

-- | license of data (string)
pattern $bTAG_LICENSE :: Text
$mTAG_LICENSE :: forall r. Text -> (Void# -> r) -> (Void# -> r) -> r
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 $bTAG_LANGUAGE_NAME :: Text
$mTAG_LANGUAGE_NAME :: forall r. Text -> (Void# -> r) -> (Void# -> r) -> r
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 $bTAG_LANGUAGE_CODE :: Text
$mTAG_LANGUAGE_CODE :: forall r. Text -> (Void# -> r) -> (Void# -> r) -> r
TAG_LANGUAGE_CODE = "language-code" :: T.Text

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

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

-- | Information about the people behind a remix and similar
-- interpretations of another existing piece (string)
-- 
-- /Since: 1.2/
pattern $bTAG_INTERPRETED_BY :: Text
$mTAG_INTERPRETED_BY :: forall r. Text -> (Void# -> r) -> (Void# -> r) -> r
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 $bTAG_IMAGE_ORIENTATION :: Text
$mTAG_IMAGE_ORIENTATION :: forall r. Text -> (Void# -> r) -> (Void# -> r) -> r
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 $bTAG_IMAGE :: Text
$mTAG_IMAGE :: forall r. Text -> (Void# -> r) -> (Void# -> r) -> r
TAG_IMAGE = "image" :: T.Text

-- | Homepage for this media (i.e. artist or movie homepage) (string)
pattern $bTAG_HOMEPAGE :: Text
$mTAG_HOMEPAGE :: forall r. Text -> (Void# -> r) -> (Void# -> r) -> r
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 $bTAG_GROUPING :: Text
$mTAG_GROUPING :: forall r. Text -> (Void# -> r) -> (Void# -> r) -> r
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 $bTAG_GEO_LOCATION_SUBLOCATION :: Text
$mTAG_GEO_LOCATION_SUBLOCATION :: forall r. Text -> (Void# -> r) -> (Void# -> r) -> r
TAG_GEO_LOCATION_SUBLOCATION = "geo-location-sublocation" :: T.Text

-- | human readable descriptive location of where the media has been recorded or
-- produced. (string).
pattern $bTAG_GEO_LOCATION_NAME :: Text
$mTAG_GEO_LOCATION_NAME :: forall r. Text -> (Void# -> r) -> (Void# -> r) -> r
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 $bTAG_GEO_LOCATION_MOVEMENT_SPEED :: Text
$mTAG_GEO_LOCATION_MOVEMENT_SPEED :: forall r. Text -> (Void# -> r) -> (Void# -> r) -> r
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 $bTAG_GEO_LOCATION_MOVEMENT_DIRECTION :: Text
$mTAG_GEO_LOCATION_MOVEMENT_DIRECTION :: forall r. Text -> (Void# -> r) -> (Void# -> r) -> r
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 $bTAG_GEO_LOCATION_LONGITUDE :: Text
$mTAG_GEO_LOCATION_LONGITUDE :: forall r. Text -> (Void# -> r) -> (Void# -> r) -> r
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 $bTAG_GEO_LOCATION_LATITUDE :: Text
$mTAG_GEO_LOCATION_LATITUDE :: forall r. Text -> (Void# -> r) -> (Void# -> r) -> r
TAG_GEO_LOCATION_LATITUDE = "geo-location-latitude" :: T.Text

-- | Represents the expected error on the horizontal positioning in
-- meters (double).
pattern $bTAG_GEO_LOCATION_HORIZONTAL_ERROR :: Text
$mTAG_GEO_LOCATION_HORIZONTAL_ERROR :: forall r. Text -> (Void# -> r) -> (Void# -> r) -> r
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 $bTAG_GEO_LOCATION_ELEVATION :: Text
$mTAG_GEO_LOCATION_ELEVATION :: forall r. Text -> (Void# -> r) -> (Void# -> r) -> r
TAG_GEO_LOCATION_ELEVATION = "geo-location-elevation" :: T.Text

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

-- | The city (english name) where the media has been produced (string).
pattern $bTAG_GEO_LOCATION_CITY :: Text
$mTAG_GEO_LOCATION_CITY :: forall r. Text -> (Void# -> r) -> (Void# -> r) -> r
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 $bTAG_GEO_LOCATION_CAPTURE_DIRECTION :: Text
$mTAG_GEO_LOCATION_CAPTURE_DIRECTION :: forall r. Text -> (Void# -> r) -> (Void# -> r) -> r
TAG_GEO_LOCATION_CAPTURE_DIRECTION = "geo-location-capture-direction" :: T.Text

-- | genre this data belongs to (string)
pattern $bTAG_GENRE :: Text
$mTAG_GENRE :: forall r. Text -> (Void# -> r) -> (Void# -> r) -> r
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 $bTAG_EXTENDED_COMMENT :: Text
$mTAG_EXTENDED_COMMENT :: forall r. Text -> (Void# -> r) -> (Void# -> r) -> r
TAG_EXTENDED_COMMENT = "extended-comment" :: T.Text

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

-- | encoder used to encode this stream (string)
pattern $bTAG_ENCODER :: Text
$mTAG_ENCODER :: forall r. Text -> (Void# -> r) -> (Void# -> r) -> r
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 $bTAG_ENCODED_BY :: Text
$mTAG_ENCODED_BY :: forall r. Text -> (Void# -> r) -> (Void# -> r) -> r
TAG_ENCODED_BY = "encoded-by" :: T.Text

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-- | codec the audio data is stored in (string)
pattern $bTAG_AUDIO_CODEC :: Text
$mTAG_AUDIO_CODEC :: forall r. Text -> (Void# -> r) -> (Void# -> r) -> r
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 $bTAG_ATTACHMENT :: Text
$mTAG_ATTACHMENT :: forall r. Text -> (Void# -> r) -> (Void# -> r) -> r
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 $bTAG_ARTIST_SORTNAME :: Text
$mTAG_ARTIST_SORTNAME :: forall r. Text -> (Void# -> r) -> (Void# -> r) -> r
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 $bTAG_ARTIST :: Text
$mTAG_ARTIST :: forall r. Text -> (Void# -> r) -> (Void# -> r) -> r
TAG_ARTIST = "artist" :: T.Text

-- | Name of the application used to create the media (string)
pattern $bTAG_APPLICATION_NAME :: Text
$mTAG_APPLICATION_NAME :: forall r. Text -> (Void# -> r) -> (Void# -> r) -> r
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 $bTAG_APPLICATION_DATA :: Text
$mTAG_APPLICATION_DATA :: forall r. Text -> (Void# -> r) -> (Void# -> r) -> r
TAG_APPLICATION_DATA = "application-data" :: T.Text

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

-- | count of discs inside collection this disc belongs to (unsigned integer)
pattern $bTAG_ALBUM_VOLUME_COUNT :: Text
$mTAG_ALBUM_VOLUME_COUNT :: forall r. Text -> (Void# -> r) -> (Void# -> r) -> r
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 $bTAG_ALBUM_SORTNAME :: Text
$mTAG_ALBUM_SORTNAME :: forall r. Text -> (Void# -> r) -> (Void# -> r) -> r
TAG_ALBUM_SORTNAME = "album-sortname" :: T.Text

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

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

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

-- | The artist of the entire album, as it should be displayed.
pattern $bTAG_ALBUM_ARTIST :: Text
$mTAG_ALBUM_ARTIST :: forall r. Text -> (Void# -> r) -> (Void# -> r) -> r
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 $bTAG_ALBUM :: Text
$mTAG_ALBUM :: forall r. Text -> (Void# -> r) -> (Void# -> r) -> r
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 $bSEQNUM_INVALID :: Int32
$mSEQNUM_INVALID :: forall r. Int32 -> (Void# -> r) -> (Void# -> r) -> r
SEQNUM_INVALID = 0 :: Int32

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

-- | The same thing as @/GST_QUERY_TYPE_UPSTREAM/@ | @/GST_QUERY_TYPE_DOWNSTREAM/@.
pattern $bQUERY_TYPE_BOTH :: [QueryTypeFlags]
$mQUERY_TYPE_BOTH :: forall r. [QueryTypeFlags] -> (Void# -> r) -> (Void# -> r) -> r
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 $bQUERY_NUM_SHIFT :: Int32
$mQUERY_NUM_SHIFT :: forall r. Int32 -> (Void# -> r) -> (Void# -> r) -> r
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 $bPROTECTION_UNSPECIFIED_SYSTEM_ID :: Text
$mPROTECTION_UNSPECIFIED_SYSTEM_ID :: forall r. Text -> (Void# -> r) -> (Void# -> r) -> r
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 $bPROTECTION_SYSTEM_ID_CAPS_FIELD :: Text
$mPROTECTION_SYSTEM_ID_CAPS_FIELD :: forall r. Text -> (Void# -> r) -> (Void# -> r) -> r
PROTECTION_SYSTEM_ID_CAPS_FIELD = "protection-system" :: T.Text

-- | Bits based on GST_PARAM_USER_SHIFT can be used by 3rd party applications.
pattern $bPARAM_USER_SHIFT :: Int32
$mPARAM_USER_SHIFT :: forall r. Int32 -> (Void# -> r) -> (Void# -> r) -> r
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 $bPARAM_MUTABLE_READY :: Int32
$mPARAM_MUTABLE_READY :: forall r. Int32 -> (Void# -> r) -> (Void# -> r) -> r
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 $bPARAM_MUTABLE_PLAYING :: Int32
$mPARAM_MUTABLE_PLAYING :: forall r. Int32 -> (Void# -> r) -> (Void# -> r) -> r
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 $bPARAM_MUTABLE_PAUSED :: Int32
$mPARAM_MUTABLE_PAUSED :: forall r. Int32 -> (Void# -> r) -> (Void# -> r) -> r
PARAM_MUTABLE_PAUSED = 2048 :: 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 $bPARAM_CONTROLLABLE :: Int32
$mPARAM_CONTROLLABLE :: forall r. Int32 -> (Void# -> r) -> (Void# -> r) -> r
PARAM_CONTROLLABLE = 512 :: Int32

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

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

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

-- | GstMapFlags value alias for GST_MAP_READ | GST_MAP_WRITE
pattern $bMAP_READWRITE :: [MapFlags]
$mMAP_READWRITE :: forall r. [MapFlags] -> (Void# -> r) -> (Void# -> r) -> r
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 $bLOCK_FLAG_READWRITE :: [LockFlags]
$mLOCK_FLAG_READWRITE :: forall r. [LockFlags] -> (Void# -> r) -> (Void# -> r) -> r
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 $bLICENSE_UNKNOWN :: Text
$mLICENSE_UNKNOWN :: forall r. Text -> (Void# -> r) -> (Void# -> r) -> r
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 $bGROUP_ID_INVALID :: Int32
$mGROUP_ID_INVALID :: forall r. Int32 -> (Void# -> r) -> (Void# -> r) -> r
GROUP_ID_INVALID = 0 :: Int32

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

-- | The PERCENT format is between 0 and this value
pattern $bFORMAT_PERCENT_MAX :: Int64
$mFORMAT_PERCENT_MAX :: forall r. Int64 -> (Void# -> r) -> (Void# -> r) -> r
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 $bFLAG_SET_MASK_EXACT :: Word32
$mFLAG_SET_MASK_EXACT :: forall r. Word32 -> (Void# -> r) -> (Void# -> r) -> r
FLAG_SET_MASK_EXACT = 4294967295 :: Word32

-- | The same thing as @/GST_EVENT_TYPE_UPSTREAM/@ | @/GST_EVENT_TYPE_DOWNSTREAM/@.
pattern $bEVENT_TYPE_BOTH :: [EventTypeFlags]
$mEVENT_TYPE_BOTH :: forall r. [EventTypeFlags] -> (Void# -> r) -> (Void# -> r) -> r
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 $bEVENT_NUM_SHIFT :: Int32
$mEVENT_NUM_SHIFT :: forall r. Int32 -> (Void# -> r) -> (Void# -> r) -> r
EVENT_NUM_SHIFT = 8 :: Int32

-- | The long English name of the element. E.g. \"File Sink\"
pattern $bELEMENT_METADATA_LONGNAME :: Text
$mELEMENT_METADATA_LONGNAME :: forall r. Text -> (Void# -> r) -> (Void# -> r) -> r
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 $bELEMENT_METADATA_KLASS :: Text
$mELEMENT_METADATA_KLASS :: forall r. Text -> (Void# -> r) -> (Void# -> r) -> r
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 $bELEMENT_METADATA_ICON_NAME :: Text
$mELEMENT_METADATA_ICON_NAME :: forall r. Text -> (Void# -> r) -> (Void# -> r) -> r
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 $bELEMENT_METADATA_DOC_URI :: Text
$mELEMENT_METADATA_DOC_URI :: forall r. Text -> (Void# -> r) -> (Void# -> r) -> r
ELEMENT_METADATA_DOC_URI = "doc-uri" :: T.Text

-- | Sentence describing the purpose of the element.
-- E.g: \"Write stream to a file\"
pattern $bELEMENT_METADATA_DESCRIPTION :: Text
$mELEMENT_METADATA_DESCRIPTION :: forall r. Text -> (Void# -> r) -> (Void# -> r) -> r
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 $bELEMENT_METADATA_AUTHOR :: Text
$mELEMENT_METADATA_AUTHOR :: forall r. Text -> (Void# -> r) -> (Void# -> r) -> r
ELEMENT_METADATA_AUTHOR = "author" :: T.Text

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

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

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

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

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

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

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

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

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

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

-- | /No description available in the introspection data./
pattern $bELEMENT_FACTORY_TYPE_MEDIA_AUDIO :: Word64
$mELEMENT_FACTORY_TYPE_MEDIA_AUDIO :: forall r. Word64 -> (Void# -> r) -> (Void# -> r) -> r
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 $bELEMENT_FACTORY_TYPE_MEDIA_ANY :: Word64
$mELEMENT_FACTORY_TYPE_MEDIA_ANY :: forall r. Word64 -> (Void# -> r) -> (Void# -> r) -> r
ELEMENT_FACTORY_TYPE_MEDIA_ANY = 18446462598732840960 :: Word64

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-- | /No description available in the introspection data./
pattern $bELEMENT_FACTORY_KLASS_MEDIA_AUDIO :: Text
$mELEMENT_FACTORY_KLASS_MEDIA_AUDIO :: forall r. Text -> (Void# -> r) -> (Void# -> r) -> r
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 $bELEMENT_FACTORY_KLASS_HARDWARE :: Text
$mELEMENT_FACTORY_KLASS_HARDWARE :: forall r. Text -> (Void# -> r) -> (Void# -> r) -> r
ELEMENT_FACTORY_KLASS_HARDWARE = "Hardware" :: T.Text

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-- | Combination of all possible metadata fields that can be copied with
-- 'GI.Gst.Structs.Buffer.bufferCopyInto'.
pattern $bBUFFER_COPY_METADATA :: [BufferCopyFlags]
$mBUFFER_COPY_METADATA :: forall r. [BufferCopyFlags] -> (Void# -> r) -> (Void# -> r) -> r
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 $bBUFFER_COPY_ALL :: [BufferCopyFlags]
$mBUFFER_COPY_ALL :: forall r. [BufferCopyFlags] -> (Void# -> r) -> (Void# -> r) -> r
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 $bALLOCATOR_SYSMEM :: Text
$mALLOCATOR_SYSMEM :: forall r. Text -> (Void# -> r) -> (Void# -> r) -> r
ALLOCATOR_SYSMEM = "SystemMemory" :: T.Text