-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | GLib bindings
--   
--   Bindings for GLib, autogenerated by haskell-gi.
@package gi-glib
@version 2.0.30


-- | Build time configuration used during code generation.
module GI.GLib.Config

-- | Overrides used when generating these bindings.
overrides :: Text

-- | Modules in this package
modules :: [Text]


module GI.GLib.Constants

-- | <i>No description available in the introspection data.</i>
pattern WIN32_MSG_HANDLE :: Int32

-- | A macro that should be defined by the user prior to including the
--   glib.h header. The definition should be one of the predefined GLib
--   version macros: <tt><i>GLIB_VERSION_2_26</i></tt>,
--   <tt><i>GLIB_VERSION_2_28</i></tt>,...
--   
--   This macro defines the earliest version of GLib that the package is
--   required to be able to compile against.
--   
--   If the compiler is configured to warn about the use of deprecated
--   functions, then using functions that were deprecated in version
--   <a>VERSION_MIN_REQUIRED</a> or earlier will cause warnings (but using
--   functions deprecated in later releases will not).
--   
--   <i>Since: 2.32</i>
pattern VERSION_MIN_REQUIRED :: Int32

-- | <i>No description available in the introspection data.</i>
pattern VA_COPY_AS_ARRAY :: Int32

-- | Number of microseconds in one second (1 million). This macro is
--   provided for code readability.
pattern USEC_PER_SEC :: Int32

-- | Subcomponent delimiter characters as defined in <a>RFC 3986</a>.
--   Includes <tt>!$&amp;'()*+,;=</tt>.
--   
--   <i>Since: 2.16</i>
pattern URI_RESERVED_CHARS_SUBCOMPONENT_DELIMITERS :: Text

-- | Generic delimiters characters as defined in <a>RFC 3986</a>. Includes
--   <tt>:/?#[]@</tt>.
--   
--   <i>Since: 2.16</i>
pattern URI_RESERVED_CHARS_GENERIC_DELIMITERS :: Text

-- | The maximum length (in codepoints) of a compatibility or canonical
--   decomposition of a single Unicode character.
--   
--   This is as defined by Unicode 6.1.
--   
--   <i>Since: 2.32</i>
pattern UNICHAR_MAX_DECOMPOSITION_LENGTH :: Int32

-- | Evaluates to a time span of one second.
--   
--   <i>Since: 2.26</i>
pattern TIME_SPAN_SECOND :: Int64

-- | Evaluates to a time span of one minute.
--   
--   <i>Since: 2.26</i>
pattern TIME_SPAN_MINUTE :: Int64

-- | Evaluates to a time span of one millisecond.
--   
--   <i>Since: 2.26</i>
pattern TIME_SPAN_MILLISECOND :: Int64

-- | Evaluates to a time span of one hour.
--   
--   <i>Since: 2.26</i>
pattern TIME_SPAN_HOUR :: Int64

-- | Evaluates to a time span of one day.
--   
--   <i>Since: 2.26</i>
pattern TIME_SPAN_DAY :: Int64

-- | A value that can be passed as an option to
--   <tt><i>GLib.test_init</i></tt>.
--   
--   If this option is given, <tt><i>GLib.test_init</i></tt> will not call
--   <a>setPrgname</a>.
--   
--   <i>Since: 2.84</i>
pattern TEST_OPTION_NO_PRGNAME :: Text

-- | A value that can be passed as an option to
--   <tt><i>GLib.test_init</i></tt>.
--   
--   If this option is given, assertions will not abort the process, but
--   call <a>testFail</a>. Equivalent to <a>testSetNonfatalAssertions</a>.
--   
--   <i>Since: 2.84</i>
pattern TEST_OPTION_NONFATAL_ASSERTIONS :: Text

-- | A value that can be passed as an option to
--   <tt><i>GLib.test_init</i></tt>.
--   
--   Creates a unique temporary directory for each unit test and uses sets
--   XDG directories to point into subdirectories of it for the duration of
--   the unit test. The directory tree is cleaned up after the test
--   finishes successfully.
--   
--   Note that this doesn’t take effect until <a>testRun</a> is called, so
--   calls to (for example) <a>getHomeDir</a> will return the system-wide
--   value when made in a test program’s <tt><i>main()</i></tt> function.
--   
--   The following functions will return subdirectories of the temporary
--   directory when this option is used. The specific subdirectory paths in
--   use are not guaranteed to be stable API — always use a getter function
--   to retrieve them.
--   
--   <ul>
--   <li><a>getHomeDir</a></li>
--   <li><a>getUserCacheDir</a></li>
--   <li><a>getSystemConfigDirs</a></li>
--   <li><a>getUserConfigDir</a></li>
--   <li><a>getSystemDataDirs</a></li>
--   <li><a>getUserDataDir</a></li>
--   <li><a>getUserStateDir</a></li>
--   <li><a>getUserRuntimeDir</a></li>
--   </ul>
--   
--   The subdirectories may not be created by the test harness; as with
--   normal calls to functions like <a>getUserCacheDir</a>, the caller must
--   be prepared to create the directory if it doesn’t exist.
--   
--   <i>Since: 2.60</i>
pattern TEST_OPTION_ISOLATE_DIRS :: Text

-- | <i>No description available in the introspection data.</i>
pattern SYSDEF_MSG_PEEK :: Int32

-- | <i>No description available in the introspection data.</i>
pattern SYSDEF_MSG_OOB :: Int32

-- | <i>No description available in the introspection data.</i>
pattern SYSDEF_MSG_DONTROUTE :: Int32

-- | <i>No description available in the introspection data.</i>
pattern SYSDEF_AF_UNIX :: Int32

-- | <i>No description available in the introspection data.</i>
pattern SYSDEF_AF_INET6 :: Int32

-- | <i>No description available in the introspection data.</i>
pattern SYSDEF_AF_INET :: Int32

-- | The standard delimiters, used in <a>strdelimit</a>.
pattern STR_DELIMITERS :: Text

-- | The square root of two.
pattern SQRT2 :: Double

-- | Use this macro as the return value of a
--   [callback<i><tt>gLib</tt></i>.SourceFunc] to remove the <a>Source</a>
--   from the main loop.
--   
--   <i>Since: 2.32</i>
pattern SOURCE_REMOVE :: Bool

-- | Use this macro as the return value of a
--   [callback<i><tt>gLib</tt></i>.SourceFunc] to leave the <a>Source</a>
--   in the main loop.
--   
--   <i>Since: 2.32</i>
pattern SOURCE_CONTINUE :: Bool

-- | <i>No description available in the introspection data.</i>
pattern SIZEOF_VOID_P :: Int32

-- | <i>No description available in the introspection data.</i>
pattern SIZEOF_SSIZE_T :: Int32

-- | <i>No description available in the introspection data.</i>
pattern SIZEOF_SIZE_T :: Int32

-- | <i>No description available in the introspection data.</i>
pattern SIZEOF_LONG :: Int32

-- | The search path separator as a string. This is ":" on UNIX machines
--   and ";" under Windows.
pattern SEARCHPATH_SEPARATOR_S :: Text

-- | The search path separator character. This is ':' on UNIX machines and
--   ';' under Windows.
pattern SEARCHPATH_SEPARATOR :: Int32

-- | Evaluates to the initial reference count for <tt>grefcount</tt>.
--   
--   This macro is useful for initializing <tt>grefcount</tt> fields inside
--   structures, for instance:
--   
--   <h3><i>C code</i></h3>
--   
--   <pre>
--   typedef struct {
--     grefcount ref_count;
--     char *name;
--     char *address;
--   } Person;
--   
--   static const Person default_person = {
--     .ref_count = G_REF_COUNT_INIT,
--     .name = "Default name",
--     .address = "Default address",
--   };
--   </pre>
--   
--   <i>Since: 2.78</i>
pattern REF_COUNT_INIT :: Int32

-- | Use this for very low priority background tasks.
--   
--   It is not used within GLib or GTK.
pattern PRIORITY_LOW :: Int32

-- | Use this for high priority idle functions.
--   
--   GTK uses <a>PRIORITY_HIGH_IDLE</a> + 10 for resizing operations, and
--   <a>PRIORITY_HIGH_IDLE</a> + 20 for redrawing operations. (This is done
--   to ensure that any pending resizes are processed before any pending
--   redraws, so that widgets are not redrawn twice unnecessarily.)
pattern PRIORITY_HIGH_IDLE :: Int32

-- | Use this for high priority event sources.
--   
--   It is not used within GLib or GTK.
pattern PRIORITY_HIGH :: Int32

-- | Use this for default priority idle functions.
--   
--   In GLib this priority is used when adding idle functions with
--   <a>idleAdd</a>.
pattern PRIORITY_DEFAULT_IDLE :: Int32

-- | Use this for default priority event sources.
--   
--   In GLib this priority is used when adding timeout functions with
--   <a>timeoutAdd</a>. In GDK this priority is used for events from the X
--   server.
pattern PRIORITY_DEFAULT :: Int32

-- | A format specifier that can be used in <tt><i>printf()</i></tt>-style
--   format strings when printing the <i><tt>fd</tt></i> member of a
--   <a>PollFD</a>.
pattern POLLFD_FORMAT :: Text

-- | Pi divided by 4.
pattern PI_4 :: Double

-- | Pi divided by 2.
pattern PI_2 :: Double

-- | A format specifier that can be used in <tt><i>printf()</i></tt>-style
--   format strings when printing a <tt><i>GPid</i></tt>.
--   
--   <i>Since: 2.50</i>
pattern PID_FORMAT :: Text

-- | The value of pi (ratio of circle's circumference to its diameter).
pattern PI :: Double

-- | Specifies one of the possible types of byte order (currently unused).
--   See <tt><i>G_BYTE_ORDER</i></tt>.
pattern PDP_ENDIAN :: Int32

-- | If a long option in the main group has this name, it is not treated as
--   a regular option. Instead it collects all non-option arguments which
--   would otherwise be left in <tt>argv</tt>. The option must be of type
--   <a>OptionArgCallback</a>, <a>OptionArgStringArray</a> or
--   <a>OptionArgFilenameArray</a>.
--   
--   Using <a>OPTION_REMAINING</a> instead of simply scanning <tt>argv</tt>
--   for leftover arguments has the advantage that GOption takes care of
--   necessary encoding conversions for strings or filenames.
--   
--   <i>Since: 2.6</i>
pattern OPTION_REMAINING :: Text

-- | <i>No description available in the introspection data.</i>
pattern MODULE_SUFFIX :: Text

-- | The minor version number of the GLib library.
--   
--   Like <tt><i>gtk_minor_version</i></tt>, but from the headers used at
--   application compile time, rather than from the library linked against
--   at application run time.
pattern MINOR_VERSION :: Int32

-- | The minimum value which can be held in a <tt><i>gint8</i></tt>.
--   
--   <i>Since: 2.4</i>
pattern MININT8 :: Int8

-- | The minimum value which can be held in a <tt><i>gint64</i></tt>.
pattern MININT64 :: Int64

-- | The minimum value which can be held in a <tt><i>gint32</i></tt>.
--   
--   <i>Since: 2.4</i>
pattern MININT32 :: Int32

-- | The minimum value which can be held in a <tt><i>gint16</i></tt>.
--   
--   <i>Since: 2.4</i>
pattern MININT16 :: Int16

-- | The micro version number of the GLib library.
--   
--   Like <tt><i>gtk_micro_version</i></tt>, but from the headers used at
--   application compile time, rather than from the library linked against
--   at application run time.
pattern MICRO_VERSION :: Int32

-- | <i>No description available in the introspection data.</i>
pattern MAXUINT8 :: Word8

-- | <i>No description available in the introspection data.</i>
pattern MAXUINT64 :: Word64

-- | <i>No description available in the introspection data.</i>
pattern MAXUINT32 :: Word32

-- | <i>No description available in the introspection data.</i>
pattern MAXUINT16 :: Word16

-- | <i>No description available in the introspection data.</i>
pattern MAXINT8 :: Int8

-- | <i>No description available in the introspection data.</i>
pattern MAXINT64 :: Int64

-- | <i>No description available in the introspection data.</i>
pattern MAXINT32 :: Int32

-- | <i>No description available in the introspection data.</i>
pattern MAXINT16 :: Int16

-- | The major version number of the GLib library.
--   
--   Like <tt><i>glib_major_version</i></tt>, but from the headers used at
--   application compile time, rather than from the library linked against
--   at application run time.
pattern MAJOR_VERSION :: Int32

-- | Log levels below <tt>1&lt;&lt;G_LOG_LEVEL_USER_SHIFT</tt> are used by
--   GLib. Higher bits can be used for user-defined log levels.
pattern LOG_LEVEL_USER_SHIFT :: Int32

-- | GLib log levels that are considered fatal by default.
--   
--   This is not used if structured logging is enabled; see <a>Using
--   Structured Logging</a>.
pattern LOG_FATAL_MASK :: Int32

-- | Defines the log domain. See <a>Log Domains</a>.
--   
--   Libraries should define this so that any messages which they log can
--   be differentiated from messages from other libraries and application
--   code. But be careful not to define it in any public header files.
--   
--   Log domains must be unique, and it is recommended that they are the
--   application or library name, optionally followed by a hyphen and a
--   sub-domain name. For example, <tt>bloatpad</tt> or
--   <tt>bloatpad-io</tt>.
--   
--   If undefined, it defaults to the default <a>Nothing</a> (or
--   <tt>""</tt>) log domain; this is not advisable, as it cannot be
--   filtered against using the <tt>G_MESSAGES_DEBUG</tt> environment
--   variable.
--   
--   For example, GTK uses this in its <tt>Makefile.am</tt>:
--   
--   <pre>
--   AM_CPPFLAGS = -DG_LOG_DOMAIN=\"Gtk\"
--   </pre>
--   
--   Applications can choose to leave it as the default <a>Nothing</a> (or
--   <tt>""</tt>) domain. However, defining the domain offers the same
--   advantages as above.
pattern LOG_DOMAIN :: Int8

-- | Multiplying the base 2 exponent by this number yields the base 10
--   exponent.
pattern LOG_2_BASE_10 :: Double

-- | The natural logarithm of 2.
pattern LN2 :: Double

-- | The natural logarithm of 10.
pattern LN10 :: Double

-- | Specifies one of the possible types of byte order. See
--   <tt><i>G_BYTE_ORDER</i></tt>.
pattern LITTLE_ENDIAN :: Int32

-- | The value of the
--   [const<i><tt>gLib</tt></i>.KEY_FILE_DESKTOP_KEY_TYPE], key for desktop
--   entries representing links to documents.
--   
--   <i>Since: 2.14</i>
pattern KEY_FILE_DESKTOP_TYPE_LINK :: Text

-- | The value of the
--   [const<i><tt>gLib</tt></i>.KEY_FILE_DESKTOP_KEY_TYPE], key for desktop
--   entries representing directories.
--   
--   <i>Since: 2.14</i>
pattern KEY_FILE_DESKTOP_TYPE_DIRECTORY :: Text

-- | The value of the
--   [const<i><tt>gLib</tt></i>.KEY_FILE_DESKTOP_KEY_TYPE], key for desktop
--   entries representing applications.
--   
--   <i>Since: 2.14</i>
pattern KEY_FILE_DESKTOP_TYPE_APPLICATION :: Text

-- | A key under [const<i><tt>gLib</tt></i>.KEY_FILE_DESKTOP_GROUP], whose
--   value is a string giving the version of the Desktop Entry
--   Specification used for the desktop entry file.
--   
--   <i>Since: 2.14</i>
pattern KEY_FILE_DESKTOP_KEY_VERSION :: Text

-- | A key under [const<i><tt>gLib</tt></i>.KEY_FILE_DESKTOP_GROUP], whose
--   value is a string giving the URL to access.
--   
--   It is only valid for desktop entries with the <tt>Link</tt> type.
--   
--   <i>Since: 2.14</i>
pattern KEY_FILE_DESKTOP_KEY_URL :: Text

-- | A key under [const<i><tt>gLib</tt></i>.KEY_FILE_DESKTOP_GROUP], whose
--   value is a string giving the type of the desktop entry.
--   
--   Usually [const<i><tt>gLib</tt></i>.KEY_FILE_DESKTOP_TYPE_APPLICATION],
--   [const<i><tt>gLib</tt></i>.KEY_FILE_DESKTOP_TYPE_LINK], or
--   [const<i><tt>gLib</tt></i>.KEY_FILE_DESKTOP_TYPE_DIRECTORY].
--   
--   <i>Since: 2.14</i>
pattern KEY_FILE_DESKTOP_KEY_TYPE :: Text

-- | A key under [const<i><tt>gLib</tt></i>.KEY_FILE_DESKTOP_GROUP], whose
--   value is a string giving the file name of a binary on disk used to
--   determine if the program is actually installed.
--   
--   It is only valid for desktop entries with the <tt>Application</tt>
--   type.
--   
--   <i>Since: 2.14</i>
pattern KEY_FILE_DESKTOP_KEY_TRY_EXEC :: Text

-- | A key under [const<i><tt>gLib</tt></i>.KEY_FILE_DESKTOP_GROUP], whose
--   value is a boolean stating whether the program should be run in a
--   terminal window.
--   
--   It is only valid for desktop entries with the <tt>Application</tt>
--   type.
--   
--   <i>Since: 2.14</i>
pattern KEY_FILE_DESKTOP_KEY_TERMINAL :: Text

-- | A key under [const<i><tt>gLib</tt></i>.KEY_FILE_DESKTOP_GROUP], whose
--   value is string identifying the WM class or name hint of a window that
--   the application will create, which can be used to emulate <a>Startup
--   Notification</a> with older applications.
--   
--   <i>Since: 2.14</i>
pattern KEY_FILE_DESKTOP_KEY_STARTUP_WM_CLASS :: Text

-- | A key under [const<i><tt>gLib</tt></i>.KEY_FILE_DESKTOP_GROUP], whose
--   value is a boolean stating whether the application supports the
--   <a>Startup Notification Protocol Specification</a>.
--   
--   <i>Since: 2.14</i>
pattern KEY_FILE_DESKTOP_KEY_STARTUP_NOTIFY :: Text

-- | A key under [const<i><tt>gLib</tt></i>.KEY_FILE_DESKTOP_GROUP], whose
--   value is a string containing the working directory to run the program
--   in.
--   
--   It is only valid for desktop entries with the <tt>Application</tt>
--   type.
--   
--   <i>Since: 2.14</i>
pattern KEY_FILE_DESKTOP_KEY_PATH :: Text

-- | A key under [const<i><tt>gLib</tt></i>.KEY_FILE_DESKTOP_GROUP], whose
--   value is a list of strings identifying the environments that should
--   display the desktop entry.
--   
--   <i>Since: 2.14</i>
pattern KEY_FILE_DESKTOP_KEY_ONLY_SHOW_IN :: Text

-- | A key under [const<i><tt>gLib</tt></i>.KEY_FILE_DESKTOP_GROUP], whose
--   value is a boolean stating whether the desktop entry should be shown
--   in menus.
--   
--   <i>Since: 2.14</i>
pattern KEY_FILE_DESKTOP_KEY_NO_DISPLAY :: Text

-- | A key under [const<i><tt>gLib</tt></i>.KEY_FILE_DESKTOP_GROUP], whose
--   value is a list of strings identifying the environments that should
--   not display the desktop entry.
--   
--   <i>Since: 2.14</i>
pattern KEY_FILE_DESKTOP_KEY_NOT_SHOW_IN :: Text

-- | A key under [const<i><tt>gLib</tt></i>.KEY_FILE_DESKTOP_GROUP], whose
--   value is a localized string giving the specific name of the desktop
--   entry.
--   
--   <i>Since: 2.14</i>
pattern KEY_FILE_DESKTOP_KEY_NAME :: Text

-- | A key under [const<i><tt>gLib</tt></i>.KEY_FILE_DESKTOP_GROUP], whose
--   value is a list of strings giving the MIME types supported by this
--   desktop entry.
--   
--   <i>Since: 2.14</i>
pattern KEY_FILE_DESKTOP_KEY_MIME_TYPE :: Text

-- | A key under [const<i><tt>gLib</tt></i>.KEY_FILE_DESKTOP_GROUP], whose
--   value is a localized string giving the name of the icon to be
--   displayed for the desktop entry.
--   
--   <i>Since: 2.14</i>
pattern KEY_FILE_DESKTOP_KEY_ICON :: Text

-- | A key under [const<i><tt>gLib</tt></i>.KEY_FILE_DESKTOP_GROUP], whose
--   value is a boolean stating whether the desktop entry has been deleted
--   by the user.
--   
--   <i>Since: 2.14</i>
pattern KEY_FILE_DESKTOP_KEY_HIDDEN :: Text

-- | A key under [const<i><tt>gLib</tt></i>.KEY_FILE_DESKTOP_GROUP], whose
--   value is a localized string giving the generic name of the desktop
--   entry.
--   
--   <i>Since: 2.14</i>
pattern KEY_FILE_DESKTOP_KEY_GENERIC_NAME :: Text

-- | A key under [const<i><tt>gLib</tt></i>.KEY_FILE_DESKTOP_GROUP], whose
--   value is a string giving the command line to execute.
--   
--   It is only valid for desktop entries with the <tt>Application</tt>
--   type.
--   
--   <i>Since: 2.14</i>
pattern KEY_FILE_DESKTOP_KEY_EXEC :: Text

-- | A key under [const<i><tt>gLib</tt></i>.KEY_FILE_DESKTOP_GROUP], whose
--   value is a boolean set to true if the application is D-Bus
--   activatable.
--   
--   <i>Since: 2.38</i>
pattern KEY_FILE_DESKTOP_KEY_DBUS_ACTIVATABLE :: Text

-- | A key under [const<i><tt>gLib</tt></i>.KEY_FILE_DESKTOP_GROUP], whose
--   value is a localized string giving the tooltip for the desktop entry.
--   
--   <i>Since: 2.14</i>
pattern KEY_FILE_DESKTOP_KEY_COMMENT :: Text

-- | A key under [const<i><tt>gLib</tt></i>.KEY_FILE_DESKTOP_GROUP], whose
--   value is a list of strings giving the categories in which the desktop
--   entry should be shown in a menu.
--   
--   <i>Since: 2.14</i>
pattern KEY_FILE_DESKTOP_KEY_CATEGORIES :: Text

-- | A key under [const<i><tt>gLib</tt></i>.KEY_FILE_DESKTOP_GROUP], whose
--   value is a string list giving the available application actions.
--   
--   <i>Since: 2.38</i>
pattern KEY_FILE_DESKTOP_KEY_ACTIONS :: Text

-- | The name of the main group of a desktop entry file, as defined in the
--   <a>Desktop Entry Specification</a>.
--   
--   Consult the specification for more details about the meanings of the
--   keys below.
--   
--   <i>Since: 2.14</i>
pattern KEY_FILE_DESKTOP_GROUP :: Text

-- | The bias by which exponents in single-precision floats are offset.
pattern IEEE754_FLOAT_BIAS :: Int32

-- | The bias by which exponents in double-precision floats are offset.
pattern IEEE754_DOUBLE_BIAS :: Int32

-- | The position of the first bit which is not reserved for internal use
--   be the <a>Hook</a> implementation, i.e. <tt>1 &lt;&lt;
--   G_HOOK_FLAG_USER_SHIFT</tt> is the first bit which can be used for
--   application-defined flags.
pattern HOOK_FLAG_USER_SHIFT :: Int32

-- | <i>No description available in the introspection data.</i>
pattern HAVE_ISO_VARARGS :: Int32

-- | <i>No description available in the introspection data.</i>
pattern HAVE_GROWING_STACK :: Int32

-- | Defined to 1 if gcc-style visibility handling is supported.
pattern HAVE_GNUC_VISIBILITY :: Int32

-- | <i>No description available in the introspection data.</i>
pattern HAVE_GNUC_VARARGS :: Int32

-- | <i>No description available in the introspection data.</i>
pattern HAVE_GINT64 :: Int32

-- | <i>No description available in the introspection data.</i>
pattern GUINTPTR_FORMAT :: Text

-- | <i>No description available in the introspection data.</i>
pattern GUINT64_FORMAT :: Text

-- | <i>No description available in the introspection data.</i>
pattern GUINT32_FORMAT :: Text

-- | <i>No description available in the introspection data.</i>
pattern GUINT16_FORMAT :: Text

-- | <i>No description available in the introspection data.</i>
pattern GSSIZE_MODIFIER :: Text

-- | <i>No description available in the introspection data.</i>
pattern GSSIZE_FORMAT :: Text

-- | <i>No description available in the introspection data.</i>
pattern GSIZE_MODIFIER :: Text

-- | <i>No description available in the introspection data.</i>
pattern GSIZE_FORMAT :: Text

-- | Expands to "" on all modern compilers, and to <b>PRETTY_FUNCTION</b>
--   on gcc version 2.x. Don't use it.

-- | <i>Deprecated: (Since version 2.16)Use <tt><i>G_STRFUNC()</i></tt>
--   instead</i>
pattern GNUC_PRETTY_FUNCTION :: Text

-- | Expands to "" on all modern compilers, and to <b>FUNCTION</b> on gcc
--   version 2.x. Don't use it.

-- | <i>Deprecated: (Since version 2.16)Use <tt><i>G_STRFUNC()</i></tt>
--   instead</i>
pattern GNUC_FUNCTION :: Text

-- | <i>No description available in the introspection data.</i>
pattern GINTPTR_MODIFIER :: Text

-- | <i>No description available in the introspection data.</i>
pattern GINTPTR_FORMAT :: Text

-- | <i>No description available in the introspection data.</i>
pattern GINT64_MODIFIER :: Text

-- | <i>No description available in the introspection data.</i>
pattern GINT64_FORMAT :: Text

-- | <i>No description available in the introspection data.</i>
pattern GINT32_MODIFIER :: Text

-- | <i>No description available in the introspection data.</i>
pattern GINT32_FORMAT :: Text

-- | <i>No description available in the introspection data.</i>
pattern GINT16_MODIFIER :: Text

-- | <i>No description available in the introspection data.</i>
pattern GINT16_FORMAT :: Text

-- | The base of natural logarithms.
pattern E :: Double

-- | The directory separator as a string.
--   
--   This is <tt>"/"</tt> on UNIX machines and <tt>"\"</tt> under Windows.
pattern DIR_SEPARATOR_S :: Text

-- | The directory separator character.
--   
--   This is <tt>'/'</tt> on UNIX machines and <tt>'\'</tt> under Windows.
pattern DIR_SEPARATOR :: Int32

-- | Represents an invalid year.
pattern DATE_BAD_YEAR :: Int32

-- | Represents an invalid Julian day number.
pattern DATE_BAD_JULIAN :: Int32

-- | Represents an invalid <tt><i>GDateDay</i></tt>.
pattern DATE_BAD_DAY :: Int32

-- | A bitmask that restricts the possible flags passed to
--   <a>datalistSetFlags</a>. Passing a flags value where flags &amp;
--   ~G_DATALIST_FLAGS_MASK != 0 is an error.
pattern DATALIST_FLAGS_MASK :: Int32

-- | The C standard version the code is compiling against, it's normally
--   defined with the same value of <tt><b>STDC_VERSION</b></tt> for C
--   standard compatible compilers, while it uses the lowest standard
--   version in pure MSVC, given that in such compiler the definition
--   depends on a compilation flag.
--   
--   This is granted to be undefined when compiling with a C++ compiler.
--   
--   See also: <tt><i>G_C_STD_CHECK_VERSION</i></tt> and
--   <tt><i>G_CXX_STD_VERSION</i></tt>
--   
--   <i>Since: 2.76</i>
pattern C_STD_VERSION :: Int32

-- | The set of lowercase ASCII alphabet characters. Used for specifying
--   valid identifier characters in <a>ScannerConfig</a>.
pattern CSET_a_2_z :: Text

-- | The set of ASCII digits. Used for specifying valid identifier
--   characters in <a>ScannerConfig</a>.
pattern CSET_DIGITS :: Text

-- | The set of uppercase ASCII alphabet characters. Used for specifying
--   valid identifier characters in <a>ScannerConfig</a>.
pattern CSET_A_2_Z :: Text

-- | <i>No description available in the introspection data.</i>
pattern C'macro__has_attribute_no_sanitize_address :: Int32

-- | <i>No description available in the introspection data.</i>
pattern C'macro__has_attribute_ifunc :: Int32

-- | <i>No description available in the introspection data.</i>
pattern C'macro__has_attribute___noreturn__ :: Int32

-- | Specifies one of the possible types of byte order. See
--   <tt><i>G_BYTE_ORDER</i></tt>.
pattern BIG_ENDIAN :: Int32

-- | Evaluates to the initial reference count for <tt>gatomicrefcount</tt>.
--   
--   This macro is useful for initializing <tt>gatomicrefcount</tt> fields
--   inside structures, for instance:
--   
--   <h3><i>C code</i></h3>
--   
--   <pre>
--   typedef struct {
--     gatomicrefcount ref_count;
--     char *name;
--     char *address;
--   } Person;
--   
--   static const Person default_person = {
--     .ref_count = G_ATOMIC_REF_COUNT_INIT,
--     .name = "Default name",
--     .address = "Default address",
--   };
--   </pre>
--   
--   <i>Since: 2.78</i>
pattern ATOMIC_REF_COUNT_INIT :: Int32

-- | A good size for a buffer to be passed into <a>asciiDtostr</a>. It is
--   guaranteed to be enough for all output of that function on systems
--   with 64bit IEEE-compatible doubles.
--   
--   The typical usage would be something like:
--   
--   <h3><i>C code</i></h3>
--   
--   <pre>
--   char buf[G_ASCII_DTOSTR_BUF_SIZE];
--   
--   fprintf (out, "value=%s\n", g_ascii_dtostr (buf, sizeof (buf), value));
--   </pre>
pattern ASCII_DTOSTR_BUF_SIZE :: Int32

-- | <i>No description available in the introspection data.</i>
pattern ANALYZER_ANALYZING :: Int32

-- | <i>No description available in the introspection data.</i>

-- | <i>Deprecated: (Since version 2.10)</i>
pattern ALLOC_ONLY :: Int32

-- | <i>No description available in the introspection data.</i>

-- | <i>Deprecated: (Since version 2.10)</i>
pattern ALLOC_AND_FREE :: Int32

-- | <i>No description available in the introspection data.</i>

-- | <i>Deprecated: (Since version 2.10)</i>
pattern ALLOCATOR_SLIST :: Int32

-- | <i>No description available in the introspection data.</i>

-- | <i>Deprecated: (Since version 2.10)</i>
pattern ALLOCATOR_NODE :: Int32

-- | <i>No description available in the introspection data.</i>

-- | <i>Deprecated: (Since version 2.10)</i>
pattern ALLOCATOR_LIST :: Int32


module GI.GLib.Enums

-- | Error codes returned by bookmark file parsing.
data BookmarkFileError

-- | URI was ill-formed
BookmarkFileErrorInvalidUri :: BookmarkFileError

-- | a requested field was not found
BookmarkFileErrorInvalidValue :: BookmarkFileError

-- | a requested application did not register a bookmark
BookmarkFileErrorAppNotRegistered :: BookmarkFileError

-- | a requested URI was not found
BookmarkFileErrorUriNotFound :: BookmarkFileError

-- | document was ill formed
BookmarkFileErrorRead :: BookmarkFileError

-- | the text being parsed was in an unknown encoding
BookmarkFileErrorUnknownEncoding :: BookmarkFileError

-- | an error occurred while writing
BookmarkFileErrorWrite :: BookmarkFileError

-- | requested file was not found
BookmarkFileErrorFileNotFound :: BookmarkFileError

-- | Catch-all for unknown values
AnotherBookmarkFileError :: Int -> BookmarkFileError

-- | Catch exceptions of type <a>BookmarkFileError</a>. This is a
--   specialized version of <a>catchGErrorJustDomain</a>.
catchBookmarkFileError :: IO a -> (BookmarkFileError -> GErrorMessage -> IO a) -> IO a

-- | Handle exceptions of type <a>BookmarkFileError</a>. This is a
--   specialized version of <a>handleGErrorJustDomain</a>.
handleBookmarkFileError :: (BookmarkFileError -> GErrorMessage -> IO a) -> IO a -> IO a

-- | The hashing algorithm to be used by <a>Checksum</a> when performing
--   the digest of some data.
--   
--   Note that the <a>ChecksumType</a> enumeration may be extended at a
--   later date to include new hashing algorithm types.
--   
--   <i>Since: 2.16</i>
data ChecksumType

-- | Use the MD5 hashing algorithm
ChecksumTypeMd5 :: ChecksumType

-- | Use the SHA-1 hashing algorithm
ChecksumTypeSha1 :: ChecksumType

-- | Use the SHA-256 hashing algorithm
ChecksumTypeSha256 :: ChecksumType

-- | Use the SHA-512 hashing algorithm (Since: 2.36)
ChecksumTypeSha512 :: ChecksumType

-- | Use the SHA-384 hashing algorithm (Since: 2.51)
ChecksumTypeSha384 :: ChecksumType

-- | Catch-all for unknown values
AnotherChecksumType :: Int -> ChecksumType

-- | Error codes returned by character set conversion routines.
data ConvertError

-- | Conversion between the requested character sets is not supported.
ConvertErrorNoConversion :: ConvertError

-- | Invalid byte sequence in conversion input; or the character sequence
--   could not be represented in the target character set.
ConvertErrorIllegalSequence :: ConvertError

-- | Conversion failed for some reason.
ConvertErrorFailed :: ConvertError

-- | Partial character sequence at end of input.
ConvertErrorPartialInput :: ConvertError

-- | URI is invalid.
ConvertErrorBadUri :: ConvertError

-- | Pathname is not an absolute path.
ConvertErrorNotAbsolutePath :: ConvertError

-- | No memory available. Since: 2.40
ConvertErrorNoMemory :: ConvertError

-- | An embedded NUL character is present in conversion output where a
--   NUL-terminated string is expected. Since: 2.56
ConvertErrorEmbeddedNul :: ConvertError

-- | Catch-all for unknown values
AnotherConvertError :: Int -> ConvertError

-- | Catch exceptions of type <a>ConvertError</a>. This is a specialized
--   version of <a>catchGErrorJustDomain</a>.
catchConvertError :: IO a -> (ConvertError -> GErrorMessage -> IO a) -> IO a

-- | Handle exceptions of type <a>ConvertError</a>. This is a specialized
--   version of <a>handleGErrorJustDomain</a>.
handleConvertError :: (ConvertError -> GErrorMessage -> IO a) -> IO a -> IO a

-- | This enumeration isn't used in the API, but may be useful if you need
--   to mark a number as a day, month, or year.
data DateDMY

-- | a day
DateDMYDay :: DateDMY

-- | a month
DateDMYMonth :: DateDMY

-- | a year
DateDMYYear :: DateDMY

-- | Catch-all for unknown values
AnotherDateDMY :: Int -> DateDMY

-- | Enumeration representing a month; values are <a>DateMonthJanuary</a>,
--   <a>DateMonthFebruary</a>, etc. <a>DateMonthBadMonth</a> is the invalid
--   value.
data DateMonth

-- | invalid value
DateMonthBadMonth :: DateMonth

-- | January
DateMonthJanuary :: DateMonth

-- | February
DateMonthFebruary :: DateMonth

-- | March
DateMonthMarch :: DateMonth

-- | April
DateMonthApril :: DateMonth

-- | May
DateMonthMay :: DateMonth

-- | June
DateMonthJune :: DateMonth

-- | July
DateMonthJuly :: DateMonth

-- | August
DateMonthAugust :: DateMonth

-- | September
DateMonthSeptember :: DateMonth

-- | October
DateMonthOctober :: DateMonth

-- | November
DateMonthNovember :: DateMonth

-- | December
DateMonthDecember :: DateMonth

-- | Catch-all for unknown values
AnotherDateMonth :: Int -> DateMonth

-- | Enumeration representing a day of the week; <a>DateWeekdayMonday</a>,
--   <a>DateWeekdayTuesday</a>, etc. <a>DateWeekdayBadWeekday</a> is an
--   invalid weekday.
data DateWeekday

-- | invalid value
DateWeekdayBadWeekday :: DateWeekday

-- | Monday
DateWeekdayMonday :: DateWeekday

-- | Tuesday
DateWeekdayTuesday :: DateWeekday

-- | Wednesday
DateWeekdayWednesday :: DateWeekday

-- | Thursday
DateWeekdayThursday :: DateWeekday

-- | Friday
DateWeekdayFriday :: DateWeekday

-- | Saturday
DateWeekdaySaturday :: DateWeekday

-- | Sunday
DateWeekdaySunday :: DateWeekday

-- | Catch-all for unknown values
AnotherDateWeekday :: Int -> DateWeekday

-- | The possible errors, used in the <i><tt>vError</tt></i> field of
--   <a>TokenValue</a>, when the token is a <a>TokenTypeError</a>.
data ErrorType

-- | unknown error
ErrorTypeUnknown :: ErrorType

-- | unexpected end of file
ErrorTypeUnexpEof :: ErrorType

-- | unterminated string constant
ErrorTypeUnexpEofInString :: ErrorType

-- | unterminated comment
ErrorTypeUnexpEofInComment :: ErrorType

-- | non-digit character in a number
ErrorTypeNonDigitInConst :: ErrorType

-- | digit beyond radix in a number
ErrorTypeDigitRadix :: ErrorType

-- | non-decimal floating point number
ErrorTypeFloatRadix :: ErrorType

-- | malformed floating point number
ErrorTypeFloatMalformed :: ErrorType

-- | Catch-all for unknown values
AnotherErrorType :: Int -> ErrorType

-- | Values corresponding to <i><tt>errno</tt></i> codes returned from file
--   operations on UNIX. Unlike <i><tt>errno</tt></i> codes, GFileError
--   values are available on all systems, even Windows. The exact meaning
--   of each code depends on what sort of file operation you were
--   performing; the UNIX documentation gives more details. The following
--   error code descriptions come from the GNU C Library manual, and are
--   under the copyright of that manual.
--   
--   It's not very portable to make detailed assumptions about exactly
--   which errors will be returned from a given operation. Some errors
--   don't occur on some systems, etc., sometimes there are subtle
--   differences in when a system will report a given error, etc.
data FileError

-- | Operation not permitted; only the owner of the file (or other
--   resource) or processes with special privileges can perform the
--   operation.
FileErrorExist :: FileError

-- | File is a directory; you cannot open a directory for writing, or
--   create or remove hard links to it.
FileErrorIsdir :: FileError

-- | Permission denied; the file permissions do not allow the attempted
--   operation.
FileErrorAcces :: FileError

-- | Filename too long.
FileErrorNametoolong :: FileError

-- | No such file or directory. This is a "file doesn't exist" error for
--   ordinary files that are referenced in contexts where they are expected
--   to already exist.
FileErrorNoent :: FileError

-- | A file that isn't a directory was specified when a directory is
--   required.
FileErrorNotdir :: FileError

-- | No such device or address. The system tried to use the device
--   represented by a file you specified, and it couldn't find the device.
--   This can mean that the device file was installed incorrectly, or that
--   the physical device is missing or not correctly attached to the
--   computer.
FileErrorNxio :: FileError

-- | The underlying file system of the specified file does not support
--   memory mapping.
FileErrorNodev :: FileError

-- | The directory containing the new link can't be modified because it's
--   on a read-only file system.
FileErrorRofs :: FileError

-- | Text file busy.
FileErrorTxtbsy :: FileError

-- | You passed in a pointer to bad memory. (GLib won't reliably return
--   this, don't pass in pointers to bad memory.)
FileErrorFault :: FileError

-- | Too many levels of symbolic links were encountered in looking up a
--   file name. This often indicates a cycle of symbolic links.
FileErrorLoop :: FileError

-- | No space left on device; write operation on a file failed because the
--   disk is full.
FileErrorNospc :: FileError

-- | No memory available. The system cannot allocate more virtual memory
--   because its capacity is full.
FileErrorNomem :: FileError

-- | The current process has too many files open and can't open any more.
--   Duplicate descriptors do count toward this limit.
FileErrorMfile :: FileError

-- | There are too many distinct file openings in the entire system.
FileErrorNfile :: FileError

-- | Bad file descriptor; for example, I/O on a descriptor that has been
--   closed or reading from a descriptor open only for writing (or vice
--   versa).
FileErrorBadf :: FileError

-- | Invalid argument. This is used to indicate various kinds of problems
--   with passing the wrong argument to a library function.
FileErrorInval :: FileError

-- | Broken pipe; there is no process reading from the other end of a pipe.
--   Every library function that returns this error code also generates a
--   'SIGPIPE' signal; this signal terminates the program if not handled or
--   blocked. Thus, your program will never actually see this code unless
--   it has handled or blocked 'SIGPIPE'.
FileErrorPipe :: FileError

-- | Resource temporarily unavailable; the call might work if you try again
--   later.
FileErrorAgain :: FileError

-- | Interrupted function call; an asynchronous signal occurred and
--   prevented completion of the call. When this happens, you should try
--   the call again.
FileErrorIntr :: FileError

-- | Input/output error; usually used for physical read or write errors.
--   i.e. the disk or other physical device hardware is returning errors.
FileErrorIo :: FileError

-- | Operation not permitted; only the owner of the file (or other
--   resource) or processes with special privileges can perform the
--   operation.
FileErrorPerm :: FileError

-- | Function not implemented; this indicates that the system is missing
--   some functionality.
FileErrorNosys :: FileError

-- | Does not correspond to a UNIX error code; this is the standard "failed
--   for unspecified reason" error code present in all <a>GError</a> error
--   code enumerations. Returned if no specific code applies.
FileErrorFailed :: FileError

-- | Catch-all for unknown values
AnotherFileError :: Int -> FileError

-- | Catch exceptions of type <a>FileError</a>. This is a specialized
--   version of <a>catchGErrorJustDomain</a>.
catchFileError :: IO a -> (FileError -> GErrorMessage -> IO a) -> IO a

-- | Handle exceptions of type <a>FileError</a>. This is a specialized
--   version of <a>handleGErrorJustDomain</a>.
handleFileError :: (FileError -> GErrorMessage -> IO a) -> IO a -> IO a

-- | Error codes returned by <a>IOChannel</a> operations.
data IOChannelError

-- | File too large.
IOChannelErrorFbig :: IOChannelError

-- | Invalid argument.
IOChannelErrorInval :: IOChannelError

-- | IO error.
IOChannelErrorIo :: IOChannelError

-- | File is a directory.
IOChannelErrorIsdir :: IOChannelError

-- | No space left on device.
IOChannelErrorNospc :: IOChannelError

-- | No such device or address.
IOChannelErrorNxio :: IOChannelError

-- | Value too large for defined datatype.
IOChannelErrorOverflow :: IOChannelError

-- | Broken pipe.
IOChannelErrorPipe :: IOChannelError

-- | Some other error.
IOChannelErrorFailed :: IOChannelError

-- | Catch-all for unknown values
AnotherIOChannelError :: Int -> IOChannelError

-- | Catch exceptions of type <a>IOChannelError</a>. This is a specialized
--   version of <a>catchGErrorJustDomain</a>.
catchIOChannelError :: IO a -> (IOChannelError -> GErrorMessage -> IO a) -> IO a

-- | Handle exceptions of type <a>IOChannelError</a>. This is a specialized
--   version of <a>handleGErrorJustDomain</a>.
handleIOChannelError :: (IOChannelError -> GErrorMessage -> IO a) -> IO a -> IO a

-- | <a>IOError</a> is only used by the deprecated functions
--   <a>iOChannelRead</a>, <a>iOChannelWrite</a>, and <a>iOChannelSeek</a>.
data IOError

-- | no error
IOErrorNone :: IOError

-- | an EAGAIN error occurred
IOErrorAgain :: IOError

-- | an EINVAL error occurred
IOErrorInval :: IOError

-- | another error occurred
IOErrorUnknown :: IOError

-- | Catch-all for unknown values
AnotherIOError :: Int -> IOError

-- | Statuses returned by most of the <a>IOFuncs</a> functions.
data IOStatus

-- | An error occurred.
IOStatusError :: IOStatus

-- | Success.
IOStatusNormal :: IOStatus

-- | End of file.
IOStatusEof :: IOStatus

-- | Resource temporarily unavailable.
IOStatusAgain :: IOStatus

-- | Catch-all for unknown values
AnotherIOStatus :: Int -> IOStatus

-- | Error codes returned by key file parsing.
data KeyFileError

-- | the text being parsed was in an unknown encoding
KeyFileErrorUnknownEncoding :: KeyFileError

-- | document was ill-formed
KeyFileErrorParse :: KeyFileError

-- | the file was not found
KeyFileErrorNotFound :: KeyFileError

-- | a requested key was not found
KeyFileErrorKeyNotFound :: KeyFileError

-- | a requested group was not found
KeyFileErrorGroupNotFound :: KeyFileError

-- | a value could not be parsed
KeyFileErrorInvalidValue :: KeyFileError

-- | Catch-all for unknown values
AnotherKeyFileError :: Int -> KeyFileError

-- | Catch exceptions of type <a>KeyFileError</a>. This is a specialized
--   version of <a>catchGErrorJustDomain</a>.
catchKeyFileError :: IO a -> (KeyFileError -> GErrorMessage -> IO a) -> IO a

-- | Handle exceptions of type <a>KeyFileError</a>. This is a specialized
--   version of <a>handleGErrorJustDomain</a>.
handleKeyFileError :: (KeyFileError -> GErrorMessage -> IO a) -> IO a -> IO a

-- | Return values from <tt><i>GLogWriterFuncs</i></tt> to indicate whether
--   the given log entry was successfully handled by the writer, or whether
--   there was an error in handling it (and hence a fallback writer should
--   be used).
--   
--   If a <a>LogWriterFunc</a> ignores a log entry, it should return
--   <a>LogWriterOutputHandled</a>.
--   
--   <i>Since: 2.50</i>
data LogWriterOutput

-- | Log writer has handled the log entry.
LogWriterOutputHandled :: LogWriterOutput

-- | Log writer could not handle the log entry.
LogWriterOutputUnhandled :: LogWriterOutput

-- | Catch-all for unknown values
AnotherLogWriterOutput :: Int -> LogWriterOutput

-- | Error codes returned by markup parsing.
data MarkupError

-- | text being parsed was not valid UTF-8
MarkupErrorBadUtf8 :: MarkupError

-- | document contained nothing, or only whitespace
MarkupErrorEmpty :: MarkupError

-- | document was ill-formed
MarkupErrorParse :: MarkupError

-- | error should be set by <a>MarkupParser</a> functions; element wasn't
--   known
MarkupErrorUnknownElement :: MarkupError

-- | error should be set by <a>MarkupParser</a> functions; attribute wasn't
--   known
MarkupErrorUnknownAttribute :: MarkupError

-- | error should be set by <a>MarkupParser</a> functions; content was
--   invalid
MarkupErrorInvalidContent :: MarkupError

-- | error should be set by <a>MarkupParser</a> functions; a required
--   attribute was missing
MarkupErrorMissingAttribute :: MarkupError

-- | Catch-all for unknown values
AnotherMarkupError :: Int -> MarkupError

-- | Catch exceptions of type <a>MarkupError</a>. This is a specialized
--   version of <a>catchGErrorJustDomain</a>.
catchMarkupError :: IO a -> (MarkupError -> GErrorMessage -> IO a) -> IO a

-- | Handle exceptions of type <a>MarkupError</a>. This is a specialized
--   version of <a>handleGErrorJustDomain</a>.
handleMarkupError :: (MarkupError -> GErrorMessage -> IO a) -> IO a -> IO a

-- | Defines how a Unicode string is transformed in a canonical form,
--   standardizing such issues as whether a character with an accent is
--   represented as a base character and combining accent or as a single
--   precomposed character. Unicode strings should generally be normalized
--   before comparing them.
data NormalizeMode

-- | standardize differences that do not affect the text content, such as
--   the above-mentioned accent representation
NormalizeModeDefault :: NormalizeMode

-- | another name for <a>NormalizeModeDefault</a>
NormalizeModeNfd :: NormalizeMode

-- | like <a>NormalizeModeDefault</a>, but with composed forms rather than
--   a maximally decomposed form
NormalizeModeDefaultCompose :: NormalizeMode

-- | another name for <a>NormalizeModeDefaultCompose</a>
NormalizeModeNfc :: NormalizeMode

-- | beyond <a>NormalizeModeDefault</a> also standardize the
--   "compatibility" characters in Unicode, such as SUPERSCRIPT THREE to
--   the standard forms (in this case DIGIT THREE). Formatting information
--   may be lost but for most text operations such characters should be
--   considered the same
NormalizeModeAll :: NormalizeMode

-- | another name for <a>NormalizeModeAll</a>
NormalizeModeNfkd :: NormalizeMode

-- | like <a>NormalizeModeAll</a>, but with composed forms rather than a
--   maximally decomposed form
NormalizeModeAllCompose :: NormalizeMode

-- | another name for <a>NormalizeModeAllCompose</a>
NormalizeModeNfkc :: NormalizeMode

-- | Catch-all for unknown values
AnotherNormalizeMode :: Int -> NormalizeMode

-- | Error codes returned by functions converting a string to a number.
--   
--   <i>Since: 2.54</i>
data NumberParserError

-- | string was not a valid number
NumberParserErrorInvalid :: NumberParserError

-- | string was a number, but out of bounds
NumberParserErrorOutOfBounds :: NumberParserError

-- | Catch-all for unknown values
AnotherNumberParserError :: Int -> NumberParserError

-- | Catch exceptions of type <a>NumberParserError</a>. This is a
--   specialized version of <a>catchGErrorJustDomain</a>.
catchNumberParserError :: IO a -> (NumberParserError -> GErrorMessage -> IO a) -> IO a

-- | Handle exceptions of type <a>NumberParserError</a>. This is a
--   specialized version of <a>handleGErrorJustDomain</a>.
handleNumberParserError :: (NumberParserError -> GErrorMessage -> IO a) -> IO a -> IO a

-- | The possible statuses of a one-time initialization function controlled
--   by a <a>Once</a> struct.
--   
--   <i>Since: 2.4</i>
data OnceStatus

-- | the function has not been called yet.
OnceStatusNotcalled :: OnceStatus

-- | the function call is currently in progress.
OnceStatusProgress :: OnceStatus

-- | the function has been called.
OnceStatusReady :: OnceStatus

-- | Catch-all for unknown values
AnotherOnceStatus :: Int -> OnceStatus

-- | The <a>OptionArg</a> enum values determine which type of extra
--   argument the options expect to find. If an option expects an extra
--   argument, it can be specified in several ways; with a short option:
--   <tt>-x arg</tt>, with a long option: <tt>--name arg</tt> or combined
--   in a single argument: <tt>--name=arg</tt>.
data OptionArg

-- | No extra argument. This is useful for simple flags or booleans.
OptionArgNone :: OptionArg

-- | The option takes a UTF-8 string argument.
OptionArgString :: OptionArg

-- | The option takes an integer argument.
OptionArgInt :: OptionArg

-- | The option provides a callback (of type <a>OptionArgFunc</a>) to parse
--   the extra argument.
OptionArgCallback :: OptionArg

-- | The option takes a filename as argument, which will be in the GLib
--   filename encoding rather than UTF-8.
OptionArgFilename :: OptionArg

-- | The option takes a string argument, multiple uses of the option are
--   collected into an array of strings.
OptionArgStringArray :: OptionArg

-- | The option takes a filename as argument, multiple uses of the option
--   are collected into an array of strings.
OptionArgFilenameArray :: OptionArg

-- | The option takes a double argument. The argument can be formatted
--   either for the user's locale or for the "C" locale. Since 2.12
OptionArgDouble :: OptionArg

-- | The option takes a 64-bit integer. Like <a>OptionArgInt</a> but for
--   larger numbers. The number can be in decimal base, or in hexadecimal
--   (when prefixed with <tt>0x</tt>, for example, <tt>0xffffffff</tt>).
--   Since 2.12
OptionArgInt64 :: OptionArg

-- | Catch-all for unknown values
AnotherOptionArg :: Int -> OptionArg

-- | Error codes returned by option parsing.
data OptionError

-- | An option was not known to the parser. This error will only be
--   reported, if the parser hasn't been instructed to ignore unknown
--   options, see <a>optionContextSetIgnoreUnknownOptions</a>.
OptionErrorUnknownOption :: OptionError

-- | A value couldn't be parsed.
OptionErrorBadValue :: OptionError

-- | A <a>OptionArgFunc</a> callback failed.
OptionErrorFailed :: OptionError

-- | Catch-all for unknown values
AnotherOptionError :: Int -> OptionError

-- | Catch exceptions of type <a>OptionError</a>. This is a specialized
--   version of <a>catchGErrorJustDomain</a>.
catchOptionError :: IO a -> (OptionError -> GErrorMessage -> IO a) -> IO a

-- | Handle exceptions of type <a>OptionError</a>. This is a specialized
--   version of <a>handleGErrorJustDomain</a>.
handleOptionError :: (OptionError -> GErrorMessage -> IO a) -> IO a -> IO a

-- | Error codes returned by regular expressions functions.
--   
--   <i>Since: 2.14</i>
data RegexError

-- | Compilation of the regular expression failed.
RegexErrorCompile :: RegexError

-- | Optimization of the regular expression failed.
RegexErrorOptimize :: RegexError

-- | Replacement failed due to an ill-formed replacement string.
RegexErrorReplace :: RegexError

-- | The match process failed.
RegexErrorMatch :: RegexError

-- | Internal error of the regular expression engine. Since 2.16
RegexErrorInternal :: RegexError

-- | "\" at end of pattern. Since 2.16
RegexErrorStrayBackslash :: RegexError

-- | "\c" at end of pattern. Since 2.16
RegexErrorMissingControlChar :: RegexError

-- | Unrecognized character follows "\". Since 2.16
RegexErrorUnrecognizedEscape :: RegexError

-- | Numbers out of order in "{}" quantifier. Since 2.16
RegexErrorQuantifiersOutOfOrder :: RegexError

-- | Number too big in "{}" quantifier. Since 2.16
RegexErrorQuantifierTooBig :: RegexError

-- | Missing terminating "]" for character class. Since 2.16
RegexErrorUnterminatedCharacterClass :: RegexError

-- | Invalid escape sequence in character class. Since 2.16
RegexErrorInvalidEscapeInCharacterClass :: RegexError

-- | Range out of order in character class. Since 2.16
RegexErrorRangeOutOfOrder :: RegexError

-- | Nothing to repeat. Since 2.16
RegexErrorNothingToRepeat :: RegexError

-- | Unrecognized character after "(?", "(?&lt;" or "(?P". Since 2.16
RegexErrorUnrecognizedCharacter :: RegexError

-- | POSIX named classes are supported only within a class. Since 2.16
RegexErrorPosixNamedClassOutsideClass :: RegexError

-- | Missing terminating ")" or ")" without opening "(". Since 2.16
RegexErrorUnmatchedParenthesis :: RegexError

-- | Reference to non-existent subpattern. Since 2.16
RegexErrorInexistentSubpatternReference :: RegexError

-- | Missing terminating ")" after comment. Since 2.16
RegexErrorUnterminatedComment :: RegexError

-- | Regular expression too large. Since 2.16
RegexErrorExpressionTooLarge :: RegexError

-- | Failed to get memory. Since 2.16
RegexErrorMemoryError :: RegexError

-- | Lookbehind assertion is not fixed length. Since 2.16
RegexErrorVariableLengthLookbehind :: RegexError

-- | Malformed number or name after "(?(". Since 2.16
RegexErrorMalformedCondition :: RegexError

-- | Conditional group contains more than two branches. Since 2.16
RegexErrorTooManyConditionalBranches :: RegexError

-- | Assertion expected after "(?(". Since 2.16
RegexErrorAssertionExpected :: RegexError

-- | Unknown POSIX class name. Since 2.16
RegexErrorUnknownPosixClassName :: RegexError

-- | POSIX collating elements are not supported. Since 2.16
RegexErrorPosixCollatingElementsNotSupported :: RegexError

-- | Character value in "\x{...}" sequence is too large. Since 2.16
RegexErrorHexCodeTooLarge :: RegexError

-- | Invalid condition "(?(0)". Since 2.16
RegexErrorInvalidCondition :: RegexError

-- | \C not allowed in lookbehind assertion. Since 2.16
RegexErrorSingleByteMatchInLookbehind :: RegexError

-- | Recursive call could loop indefinitely. Since 2.16
RegexErrorInfiniteLoop :: RegexError

-- | Missing terminator in subpattern name. Since 2.16
RegexErrorMissingSubpatternNameTerminator :: RegexError

-- | Two named subpatterns have the same name. Since 2.16
RegexErrorDuplicateSubpatternName :: RegexError

-- | Malformed "\P" or "\p" sequence. Since 2.16
RegexErrorMalformedProperty :: RegexError

-- | Unknown property name after "\P" or "\p". Since 2.16
RegexErrorUnknownProperty :: RegexError

-- | Subpattern name is too long (maximum 32 characters). Since 2.16
RegexErrorSubpatternNameTooLong :: RegexError

-- | Too many named subpatterns (maximum 10,000). Since 2.16
RegexErrorTooManySubpatterns :: RegexError

-- | Octal value is greater than "\377". Since 2.16
RegexErrorInvalidOctalValue :: RegexError

-- | "DEFINE" group contains more than one branch. Since 2.16
RegexErrorTooManyBranchesInDefine :: RegexError

-- | Repeating a "DEFINE" group is not allowed. This error is never raised.
--   Since: 2.16 Deprecated: 2.34
RegexErrorDefineRepetion :: RegexError

-- | Inconsistent newline options. Since 2.16
RegexErrorInconsistentNewlineOptions :: RegexError

-- | "\g" is not followed by a braced, angle-bracketed, or quoted name or
--   number, or by a plain number. Since: 2.16
RegexErrorMissingBackReference :: RegexError

-- | relative reference must not be zero. Since: 2.34
RegexErrorInvalidRelativeReference :: RegexError

-- | the backtracing control verb used does not allow an argument. Since:
--   2.34
RegexErrorBacktrackingControlVerbArgumentForbidden :: RegexError

-- | unknown backtracing control verb. Since: 2.34
RegexErrorUnknownBacktrackingControlVerb :: RegexError

-- | number is too big in escape sequence. Since: 2.34
RegexErrorNumberTooBig :: RegexError

-- | Missing subpattern name. Since: 2.34
RegexErrorMissingSubpatternName :: RegexError

-- | Missing digit. Since 2.34
RegexErrorMissingDigit :: RegexError

-- | In JavaScript compatibility mode, "[" is an invalid data character.
--   Since: 2.34
RegexErrorInvalidDataCharacter :: RegexError

-- | different names for subpatterns of the same number are not allowed.
--   Since: 2.34
RegexErrorExtraSubpatternName :: RegexError

-- | the backtracing control verb requires an argument. Since: 2.34
RegexErrorBacktrackingControlVerbArgumentRequired :: RegexError

-- | "\c" must be followed by an ASCII character. Since: 2.34
RegexErrorInvalidControlChar :: RegexError

-- | "\k" is not followed by a braced, angle-bracketed, or quoted name.
--   Since: 2.34
RegexErrorMissingName :: RegexError

-- | "\N" is not supported in a class. Since: 2.34
RegexErrorNotSupportedInClass :: RegexError

-- | too many forward references. Since: 2.34
RegexErrorTooManyForwardReferences :: RegexError

-- | the name is too long in "(*MARK)", "(*PRUNE)", "(*SKIP)", or
--   "(*THEN)". Since: 2.34
RegexErrorNameTooLong :: RegexError

-- | the character value in the \u sequence is too large. Since: 2.34
RegexErrorCharacterValueTooLarge :: RegexError

-- | Catch-all for unknown values
AnotherRegexError :: Int -> RegexError

-- | Catch exceptions of type <a>RegexError</a>. This is a specialized
--   version of <a>catchGErrorJustDomain</a>.
catchRegexError :: IO a -> (RegexError -> GErrorMessage -> IO a) -> IO a

-- | Handle exceptions of type <a>RegexError</a>. This is a specialized
--   version of <a>handleGErrorJustDomain</a>.
handleRegexError :: (RegexError -> GErrorMessage -> IO a) -> IO a -> IO a

-- | An enumeration specifying the base position for a
--   <a>iOChannelSeekPosition</a> operation.
data SeekType

-- | the current position in the file.
SeekTypeCur :: SeekType

-- | the start of the file.
SeekTypeSet :: SeekType

-- | the end of the file.
SeekTypeEnd :: SeekType

-- | Catch-all for unknown values
AnotherSeekType :: Int -> SeekType

-- | Error codes returned by shell functions.
data ShellError

-- | Mismatched or otherwise mangled quoting.
ShellErrorBadQuoting :: ShellError

-- | String to be parsed was empty.
ShellErrorEmptyString :: ShellError

-- | Some other error.
ShellErrorFailed :: ShellError

-- | Catch-all for unknown values
AnotherShellError :: Int -> ShellError

-- | Catch exceptions of type <a>ShellError</a>. This is a specialized
--   version of <a>catchGErrorJustDomain</a>.
catchShellError :: IO a -> (ShellError -> GErrorMessage -> IO a) -> IO a

-- | Handle exceptions of type <a>ShellError</a>. This is a specialized
--   version of <a>handleGErrorJustDomain</a>.
handleShellError :: (ShellError -> GErrorMessage -> IO a) -> IO a -> IO a

-- | <i>No description available in the introspection data.</i>
data SliceConfig

-- | <i>No description available in the introspection data.</i>
SliceConfigAlwaysMalloc :: SliceConfig

-- | <i>No description available in the introspection data.</i>
SliceConfigBypassMagazines :: SliceConfig

-- | <i>No description available in the introspection data.</i>
SliceConfigWorkingSetMsecs :: SliceConfig

-- | <i>No description available in the introspection data.</i>
SliceConfigColorIncrement :: SliceConfig

-- | <i>No description available in the introspection data.</i>
SliceConfigChunkSizes :: SliceConfig

-- | <i>No description available in the introspection data.</i>
SliceConfigContentionCounter :: SliceConfig

-- | Catch-all for unknown values
AnotherSliceConfig :: Int -> SliceConfig

-- | Error codes returned by spawning processes.
data SpawnError

-- | Fork failed due to lack of memory.
SpawnErrorFork :: SpawnError

-- | Read or select on pipes failed.
SpawnErrorRead :: SpawnError

-- | Changing to working directory failed.
SpawnErrorChdir :: SpawnError

-- | <tt><i>execv()</i></tt> returned <tt>EACCES</tt>
SpawnErrorAcces :: SpawnError

-- | <tt><i>execv()</i></tt> returned <tt>EPERM</tt>
SpawnErrorPerm :: SpawnError

-- | <tt><i>execv()</i></tt> returned <tt>E2BIG</tt>
SpawnErrorTooBig :: SpawnError

-- | deprecated alias for <a>SpawnErrorTooBig</a> (deprecated since GLib
--   2.32)
SpawnError2big :: SpawnError

-- | <tt><i>execv()</i></tt> returned <tt>ENOEXEC</tt>
SpawnErrorNoexec :: SpawnError

-- | <tt><i>execv()</i></tt> returned <tt>ENAMETOOLONG</tt>
SpawnErrorNametoolong :: SpawnError

-- | <tt><i>execv()</i></tt> returned <tt>ENOENT</tt>
SpawnErrorNoent :: SpawnError

-- | <tt><i>execv()</i></tt> returned <tt>ENOMEM</tt>
SpawnErrorNomem :: SpawnError

-- | <tt><i>execv()</i></tt> returned <tt>ENOTDIR</tt>
SpawnErrorNotdir :: SpawnError

-- | <tt><i>execv()</i></tt> returned <tt>ELOOP</tt>
SpawnErrorLoop :: SpawnError

-- | <tt><i>execv()</i></tt> returned <tt>ETXTBUSY</tt>
SpawnErrorTxtbusy :: SpawnError

-- | <tt><i>execv()</i></tt> returned <tt>EIO</tt>
SpawnErrorIo :: SpawnError

-- | <tt><i>execv()</i></tt> returned <tt>ENFILE</tt>
SpawnErrorNfile :: SpawnError

-- | <tt><i>execv()</i></tt> returned <tt>EMFILE</tt>
SpawnErrorMfile :: SpawnError

-- | <tt><i>execv()</i></tt> returned <tt>EINVAL</tt>
SpawnErrorInval :: SpawnError

-- | <tt><i>execv()</i></tt> returned <tt>EISDIR</tt>
SpawnErrorIsdir :: SpawnError

-- | <tt><i>execv()</i></tt> returned <tt>ELIBBAD</tt>
SpawnErrorLibbad :: SpawnError

-- | Some other fatal failure, <tt>error-&gt;message</tt> should explain.
SpawnErrorFailed :: SpawnError

-- | Catch-all for unknown values
AnotherSpawnError :: Int -> SpawnError

-- | Catch exceptions of type <a>SpawnError</a>. This is a specialized
--   version of <a>catchGErrorJustDomain</a>.
catchSpawnError :: IO a -> (SpawnError -> GErrorMessage -> IO a) -> IO a

-- | Handle exceptions of type <a>SpawnError</a>. This is a specialized
--   version of <a>handleGErrorJustDomain</a>.
handleSpawnError :: (SpawnError -> GErrorMessage -> IO a) -> IO a -> IO a

-- | The type of file to return the filename for, when used with
--   <tt><i>GLib.test_build_filename</i></tt>.
--   
--   These two options correspond rather directly to the 'dist' and 'built'
--   terminology that automake uses and are explicitly used to distinguish
--   between the 'srcdir' and 'builddir' being separate. All files in your
--   project should either be dist (in the <tt>EXTRA_DIST</tt> or
--   <tt>dist_schema_DATA</tt> sense, in which case they will always be in
--   the srcdir) or built (in the <tt>BUILT_SOURCES</tt> sense, in which
--   case they will always be in the builddir).
--   
--   Note: As a general rule of automake, files that are generated only as
--   part of the build-from-git process (but then are distributed with the
--   tarball) always go in srcdir (even if doing a srcdir != builddir build
--   from git) and are considered as distributed files.
--   
--   The same principles apply for other build systems, such as meson.
--   
--   <i>Since: 2.38</i>
data TestFileType

-- | a file that was included in the distribution tarball
TestFileTypeDist :: TestFileType

-- | a file that was built on the compiling machine
TestFileTypeBuilt :: TestFileType

-- | Catch-all for unknown values
AnotherTestFileType :: Int -> TestFileType

-- | <i>No description available in the introspection data.</i>
data TestLogType

-- | <i>No description available in the introspection data.</i>
TestLogTypeNone :: TestLogType

-- | <i>No description available in the introspection data.</i>
TestLogTypeError :: TestLogType

-- | <i>No description available in the introspection data.</i>
TestLogTypeStartBinary :: TestLogType

-- | <i>No description available in the introspection data.</i>
TestLogTypeListCase :: TestLogType

-- | <i>No description available in the introspection data.</i>
TestLogTypeSkipCase :: TestLogType

-- | <i>No description available in the introspection data.</i>
TestLogTypeStartCase :: TestLogType

-- | <i>No description available in the introspection data.</i>
TestLogTypeStopCase :: TestLogType

-- | <i>No description available in the introspection data.</i>
TestLogTypeMinResult :: TestLogType

-- | <i>No description available in the introspection data.</i>
TestLogTypeMaxResult :: TestLogType

-- | <i>No description available in the introspection data.</i>
TestLogTypeMessage :: TestLogType

-- | <i>No description available in the introspection data.</i>
TestLogTypeStartSuite :: TestLogType

-- | <i>No description available in the introspection data.</i>
TestLogTypeStopSuite :: TestLogType

-- | Catch-all for unknown values
AnotherTestLogType :: Int -> TestLogType

-- | <i>No description available in the introspection data.</i>
data TestResult

-- | <i>No description available in the introspection data.</i>
TestResultSuccess :: TestResult

-- | <i>No description available in the introspection data.</i>
TestResultSkipped :: TestResult

-- | <i>No description available in the introspection data.</i>
TestResultFailure :: TestResult

-- | <i>No description available in the introspection data.</i>
TestResultIncomplete :: TestResult

-- | Catch-all for unknown values
AnotherTestResult :: Int -> TestResult

-- | Possible errors of thread related functions.
data ThreadError

-- | a thread couldn't be created due to resource shortage. Try again
--   later.
ThreadErrorThreadErrorAgain :: ThreadError

-- | Catch-all for unknown values
AnotherThreadError :: Int -> ThreadError

-- | Catch exceptions of type <a>ThreadError</a>. This is a specialized
--   version of <a>catchGErrorJustDomain</a>.
catchThreadError :: IO a -> (ThreadError -> GErrorMessage -> IO a) -> IO a

-- | Handle exceptions of type <a>ThreadError</a>. This is a specialized
--   version of <a>handleGErrorJustDomain</a>.
handleThreadError :: (ThreadError -> GErrorMessage -> IO a) -> IO a -> IO a

-- | Disambiguates a given time in two ways.
--   
--   First, specifies if the given time is in universal or local time.
--   
--   Second, if the time is in local time, specifies if it is local
--   standard time or local daylight time. This is important for the case
--   where the same local time occurs twice (during daylight savings time
--   transitions, for example).
data TimeType

-- | the time is in local standard time
TimeTypeStandard :: TimeType

-- | the time is in local daylight time
TimeTypeDaylight :: TimeType

-- | the time is in UTC
TimeTypeUniversal :: TimeType

-- | Catch-all for unknown values
AnotherTimeType :: Int -> TimeType

-- | The possible types of token returned from each
--   <a>scannerGetNextToken</a> call.
data TokenType

-- | the end of the file
TokenTypeEof :: TokenType

-- | a '(' character
TokenTypeLeftParen :: TokenType

-- | a ')' character
TokenTypeRightParen :: TokenType

-- | a '{' character
TokenTypeLeftCurly :: TokenType

-- | a '}' character
TokenTypeRightCurly :: TokenType

-- | a '[' character
TokenTypeLeftBrace :: TokenType

-- | a ']' character
TokenTypeRightBrace :: TokenType

-- | a '=' character
TokenTypeEqualSign :: TokenType

-- | a ',' character
TokenTypeComma :: TokenType

-- | not a token
TokenTypeNone :: TokenType

-- | an error occurred
TokenTypeError :: TokenType

-- | a character
TokenTypeChar :: TokenType

-- | a binary integer
TokenTypeBinary :: TokenType

-- | an octal integer
TokenTypeOctal :: TokenType

-- | an integer
TokenTypeInt :: TokenType

-- | a hex integer
TokenTypeHex :: TokenType

-- | a floating point number
TokenTypeFloat :: TokenType

-- | a string
TokenTypeString :: TokenType

-- | a symbol
TokenTypeSymbol :: TokenType

-- | an identifier
TokenTypeIdentifier :: TokenType

-- | a null identifier
TokenTypeIdentifierNull :: TokenType

-- | one line comment
TokenTypeCommentSingle :: TokenType

-- | multi line comment
TokenTypeCommentMulti :: TokenType

-- | Catch-all for unknown values
AnotherTokenType :: Int -> TokenType

-- | Specifies the type of traversal performed by <a>treeTraverse</a>,
--   <a>nodeTraverse</a> and <tt><i>g_node_find()</i></tt>.
--   
--   The different orders are illustrated here:
--   
--   <ul>
--   <li>In order: A, B, C, D, E, F, G, H, I &lt;picture&gt; &lt;source
--   srcset="Sorted_binary_tree_inorder-dark.svg"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img
--   src="Sorted_binary_tree_inorder.svg" alt="Sorted binary tree, in-order
--   traversal"&gt; &lt;/picture&gt;</li>
--   <li>Pre order: F, B, A, D, C, E, G, I, H &lt;picture&gt; &lt;source
--   srcset="Sorted_binary_tree_preorder-dark.svg"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img
--   src="Sorted_binary_tree_preorder.svg" alt="Sorted binary tree,
--   pre-order traversal"&gt; &lt;/picture&gt;</li>
--   <li>Post order: A, C, E, D, B, H, I, G, F &lt;picture&gt; &lt;source
--   srcset="Sorted_binary_tree_postorder-dark.svg"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img
--   src="Sorted_binary_tree_postorder.svg" alt="Sorted binary tree,
--   post-order traversal"&gt; &lt;/picture&gt;</li>
--   <li>Level order: F, B, G, A, D, I, C, E, H &lt;picture&gt; &lt;source
--   srcset="Sorted_binary_tree_breadth-first_traversal-dark.svg"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img
--   src="Sorted_binary_tree_breadth-first_traversal.svg" alt="Sorted
--   binary tree, breadth-first level order traversal"&gt;
--   &lt;/picture&gt;</li>
--   </ul>
data TraverseType

-- | visits a node's left child first, then the node itself, then its right
--   child. This is the one to use if you want the output sorted according
--   to the compare function.
TraverseTypeInOrder :: TraverseType

-- | visits a node, then its children.
TraverseTypePreOrder :: TraverseType

-- | visits the node's children, then the node itself.
TraverseTypePostOrder :: TraverseType

-- | is not implemented for <a>balanced binary trees</a>. For <a>n-ary
--   trees</a>, it visits the root node first, then its children, then its
--   grandchildren, and so on. Note that this is less efficient than the
--   other orders.
TraverseTypeLevelOrder :: TraverseType

-- | Catch-all for unknown values
AnotherTraverseType :: Int -> TraverseType

-- | These are the possible line break classifications.
--   
--   Since new Unicode versions may add new types here, applications should
--   be ready to handle unknown values. They may be regarded as
--   <a>UnicodeBreakTypeUnknown</a>.
--   
--   See <a>Unicode Line Breaking Algorithm</a>.
data UnicodeBreakType

-- | Mandatory Break (BK)
UnicodeBreakTypeMandatory :: UnicodeBreakType

-- | Carriage Return (CR)
UnicodeBreakTypeCarriageReturn :: UnicodeBreakType

-- | Line Feed (LF)
UnicodeBreakTypeLineFeed :: UnicodeBreakType

-- | Attached Characters and Combining Marks (CM)
UnicodeBreakTypeCombiningMark :: UnicodeBreakType

-- | Surrogates (SG)
UnicodeBreakTypeSurrogate :: UnicodeBreakType

-- | Zero Width Space (ZW)
UnicodeBreakTypeZeroWidthSpace :: UnicodeBreakType

-- | Inseparable (IN)
UnicodeBreakTypeInseparable :: UnicodeBreakType

-- | Non-breaking ("Glue") (GL)
UnicodeBreakTypeNonBreakingGlue :: UnicodeBreakType

-- | Contingent Break Opportunity (CB)
UnicodeBreakTypeContingent :: UnicodeBreakType

-- | Space (SP)
UnicodeBreakTypeSpace :: UnicodeBreakType

-- | Break Opportunity After (BA)
UnicodeBreakTypeAfter :: UnicodeBreakType

-- | Break Opportunity Before (BB)
UnicodeBreakTypeBefore :: UnicodeBreakType

-- | Break Opportunity Before and After (B2)
UnicodeBreakTypeBeforeAndAfter :: UnicodeBreakType

-- | Hyphen (HY)
UnicodeBreakTypeHyphen :: UnicodeBreakType

-- | Nonstarter (NS)
UnicodeBreakTypeNonStarter :: UnicodeBreakType

-- | Opening Punctuation (OP)
UnicodeBreakTypeOpenPunctuation :: UnicodeBreakType

-- | Closing Punctuation (CL)
UnicodeBreakTypeClosePunctuation :: UnicodeBreakType

-- | Ambiguous Quotation (QU)
UnicodeBreakTypeQuotation :: UnicodeBreakType

-- | Exclamation/Interrogation (EX)
UnicodeBreakTypeExclamation :: UnicodeBreakType

-- | Ideographic (ID)
UnicodeBreakTypeIdeographic :: UnicodeBreakType

-- | Numeric (NU)
UnicodeBreakTypeNumeric :: UnicodeBreakType

-- | Infix Separator (Numeric) (IS)
UnicodeBreakTypeInfixSeparator :: UnicodeBreakType

-- | Symbols Allowing Break After (SY)
UnicodeBreakTypeSymbol :: UnicodeBreakType

-- | Ordinary Alphabetic and Symbol Characters (AL)
UnicodeBreakTypeAlphabetic :: UnicodeBreakType

-- | Prefix (Numeric) (PR)
UnicodeBreakTypePrefix :: UnicodeBreakType

-- | Postfix (Numeric) (PO)
UnicodeBreakTypePostfix :: UnicodeBreakType

-- | Complex Content Dependent (South East Asian) (SA)
UnicodeBreakTypeComplexContext :: UnicodeBreakType

-- | Ambiguous (Alphabetic or Ideographic) (AI)
UnicodeBreakTypeAmbiguous :: UnicodeBreakType

-- | Unknown (XX)
UnicodeBreakTypeUnknown :: UnicodeBreakType

-- | Next Line (NL)
UnicodeBreakTypeNextLine :: UnicodeBreakType

-- | Word Joiner (WJ)
UnicodeBreakTypeWordJoiner :: UnicodeBreakType

-- | Hangul L Jamo (JL)
UnicodeBreakTypeHangulLJamo :: UnicodeBreakType

-- | Hangul V Jamo (JV)
UnicodeBreakTypeHangulVJamo :: UnicodeBreakType

-- | Hangul T Jamo (JT)
UnicodeBreakTypeHangulTJamo :: UnicodeBreakType

-- | Hangul LV Syllable (H2)
UnicodeBreakTypeHangulLvSyllable :: UnicodeBreakType

-- | Hangul LVT Syllable (H3)
UnicodeBreakTypeHangulLvtSyllable :: UnicodeBreakType

-- | Closing Parenthesis (CP). Since 2.28. Deprecated: 2.70: Use
--   <a>UnicodeBreakTypeCloseParenthesis</a> instead.
UnicodeBreakTypeCloseParanthesis :: UnicodeBreakType

-- | Closing Parenthesis (CP). Since 2.70
UnicodeBreakTypeCloseParenthesis :: UnicodeBreakType

-- | Conditional Japanese Starter (CJ). Since: 2.32
UnicodeBreakTypeConditionalJapaneseStarter :: UnicodeBreakType

-- | Hebrew Letter (HL). Since: 2.32
UnicodeBreakTypeHebrewLetter :: UnicodeBreakType

-- | Regional Indicator (RI). Since: 2.36
UnicodeBreakTypeRegionalIndicator :: UnicodeBreakType

-- | Emoji Base (EB). Since: 2.50
UnicodeBreakTypeEmojiBase :: UnicodeBreakType

-- | Emoji Modifier (EM). Since: 2.50
UnicodeBreakTypeEmojiModifier :: UnicodeBreakType

-- | Zero Width Joiner (ZWJ). Since: 2.50
UnicodeBreakTypeZeroWidthJoiner :: UnicodeBreakType

-- | Aksara (AK). Since: 2.80
UnicodeBreakTypeAksara :: UnicodeBreakType

-- | Aksara Pre-Base (AP). Since: 2.80
UnicodeBreakTypeAksaraPreBase :: UnicodeBreakType

-- | Aksara Start (AS). Since: 2.80
UnicodeBreakTypeAksaraStart :: UnicodeBreakType

-- | Virama Final (VF). Since: 2.80
UnicodeBreakTypeViramaFinal :: UnicodeBreakType

-- | Virama (VI). Since: 2.80
UnicodeBreakTypeVirama :: UnicodeBreakType

-- | Unambiguous Hyphen (HH). Since: 2.88
UnicodeBreakTypeUnambiguousHyphen :: UnicodeBreakType

-- | Catch-all for unknown values
AnotherUnicodeBreakType :: Int -> UnicodeBreakType

-- | The <a>UnicodeScript</a> enumeration identifies different writing
--   systems. The values correspond to the names as defined in the Unicode
--   standard. The enumeration has been added in GLib 2.14, and is
--   interchangeable with <tt><i>PangoScript</i></tt>.
--   
--   Note that new types may be added in the future. Applications should be
--   ready to handle unknown values. See <a>Unicode Standard Annex #24:
--   Script names</a>.
data UnicodeScript

-- | a value never returned from <a>unicharGetScript</a>
UnicodeScriptInvalidCode :: UnicodeScript

-- | a character used by multiple different scripts
UnicodeScriptCommon :: UnicodeScript

-- | a mark glyph that takes its script from the base glyph to which it is
--   attached
UnicodeScriptInherited :: UnicodeScript

-- | Arabic
UnicodeScriptArabic :: UnicodeScript

-- | Armenian
UnicodeScriptArmenian :: UnicodeScript

-- | Bengali
UnicodeScriptBengali :: UnicodeScript

-- | Bopomofo
UnicodeScriptBopomofo :: UnicodeScript

-- | Cherokee
UnicodeScriptCherokee :: UnicodeScript

-- | Coptic
UnicodeScriptCoptic :: UnicodeScript

-- | Cyrillic
UnicodeScriptCyrillic :: UnicodeScript

-- | Deseret
UnicodeScriptDeseret :: UnicodeScript

-- | Devanagari
UnicodeScriptDevanagari :: UnicodeScript

-- | Ethiopic
UnicodeScriptEthiopic :: UnicodeScript

-- | Georgian
UnicodeScriptGeorgian :: UnicodeScript

-- | Gothic
UnicodeScriptGothic :: UnicodeScript

-- | Greek
UnicodeScriptGreek :: UnicodeScript

-- | Gujarati
UnicodeScriptGujarati :: UnicodeScript

-- | Gurmukhi
UnicodeScriptGurmukhi :: UnicodeScript

-- | Han
UnicodeScriptHan :: UnicodeScript

-- | Hangul
UnicodeScriptHangul :: UnicodeScript

-- | Hebrew
UnicodeScriptHebrew :: UnicodeScript

-- | Hiragana
UnicodeScriptHiragana :: UnicodeScript

-- | Kannada
UnicodeScriptKannada :: UnicodeScript

-- | Katakana
UnicodeScriptKatakana :: UnicodeScript

-- | Khmer
UnicodeScriptKhmer :: UnicodeScript

-- | Lao
UnicodeScriptLao :: UnicodeScript

-- | Latin
UnicodeScriptLatin :: UnicodeScript

-- | Malayalam
UnicodeScriptMalayalam :: UnicodeScript

-- | Mongolian
UnicodeScriptMongolian :: UnicodeScript

-- | Myanmar
UnicodeScriptMyanmar :: UnicodeScript

-- | Ogham
UnicodeScriptOgham :: UnicodeScript

-- | Old Italic
UnicodeScriptOldItalic :: UnicodeScript

-- | Oriya
UnicodeScriptOriya :: UnicodeScript

-- | Runic
UnicodeScriptRunic :: UnicodeScript

-- | Sinhala
UnicodeScriptSinhala :: UnicodeScript

-- | Syriac
UnicodeScriptSyriac :: UnicodeScript

-- | Tamil
UnicodeScriptTamil :: UnicodeScript

-- | Telugu
UnicodeScriptTelugu :: UnicodeScript

-- | Thaana
UnicodeScriptThaana :: UnicodeScript

-- | Thai
UnicodeScriptThai :: UnicodeScript

-- | Tibetan
UnicodeScriptTibetan :: UnicodeScript

-- | Canadian Aboriginal
UnicodeScriptCanadianAboriginal :: UnicodeScript

-- | Yi
UnicodeScriptYi :: UnicodeScript

-- | Tagalog
UnicodeScriptTagalog :: UnicodeScript

-- | Hanunoo
UnicodeScriptHanunoo :: UnicodeScript

-- | Buhid
UnicodeScriptBuhid :: UnicodeScript

-- | Tagbanwa
UnicodeScriptTagbanwa :: UnicodeScript

-- | Braille
UnicodeScriptBraille :: UnicodeScript

-- | Cypriot
UnicodeScriptCypriot :: UnicodeScript

-- | Limbu
UnicodeScriptLimbu :: UnicodeScript

-- | Osmanya
UnicodeScriptOsmanya :: UnicodeScript

-- | Shavian
UnicodeScriptShavian :: UnicodeScript

-- | Linear B
UnicodeScriptLinearB :: UnicodeScript

-- | Tai Le
UnicodeScriptTaiLe :: UnicodeScript

-- | Ugaritic
UnicodeScriptUgaritic :: UnicodeScript

-- | New Tai Lue
UnicodeScriptNewTaiLue :: UnicodeScript

-- | Buginese
UnicodeScriptBuginese :: UnicodeScript

-- | Glagolitic
UnicodeScriptGlagolitic :: UnicodeScript

-- | Tifinagh
UnicodeScriptTifinagh :: UnicodeScript

-- | Syloti Nagri
UnicodeScriptSylotiNagri :: UnicodeScript

-- | Old Persian
UnicodeScriptOldPersian :: UnicodeScript

-- | Kharoshthi
UnicodeScriptKharoshthi :: UnicodeScript

-- | an unassigned code point
UnicodeScriptUnknown :: UnicodeScript

-- | Balinese
UnicodeScriptBalinese :: UnicodeScript

-- | Cuneiform
UnicodeScriptCuneiform :: UnicodeScript

-- | Phoenician
UnicodeScriptPhoenician :: UnicodeScript

-- | Phags-pa
UnicodeScriptPhagsPa :: UnicodeScript

-- | N'Ko
UnicodeScriptNko :: UnicodeScript

-- | Kayah Li. Since 2.16.3
UnicodeScriptKayahLi :: UnicodeScript

-- | Lepcha. Since 2.16.3
UnicodeScriptLepcha :: UnicodeScript

-- | Rejang. Since 2.16.3
UnicodeScriptRejang :: UnicodeScript

-- | Sundanese. Since 2.16.3
UnicodeScriptSundanese :: UnicodeScript

-- | Saurashtra. Since 2.16.3
UnicodeScriptSaurashtra :: UnicodeScript

-- | Cham. Since 2.16.3
UnicodeScriptCham :: UnicodeScript

-- | Ol Chiki. Since 2.16.3
UnicodeScriptOlChiki :: UnicodeScript

-- | Vai. Since 2.16.3
UnicodeScriptVai :: UnicodeScript

-- | Carian. Since 2.16.3
UnicodeScriptCarian :: UnicodeScript

-- | Lycian. Since 2.16.3
UnicodeScriptLycian :: UnicodeScript

-- | Lydian. Since 2.16.3
UnicodeScriptLydian :: UnicodeScript

-- | Avestan. Since 2.26
UnicodeScriptAvestan :: UnicodeScript

-- | Bamum. Since 2.26
UnicodeScriptBamum :: UnicodeScript

-- | Egyptian Hieroglpyhs. Since 2.26
UnicodeScriptEgyptianHieroglyphs :: UnicodeScript

-- | Imperial Aramaic. Since 2.26
UnicodeScriptImperialAramaic :: UnicodeScript

-- | Inscriptional Pahlavi. Since 2.26
UnicodeScriptInscriptionalPahlavi :: UnicodeScript

-- | Inscriptional Parthian. Since 2.26
UnicodeScriptInscriptionalParthian :: UnicodeScript

-- | Javanese. Since 2.26
UnicodeScriptJavanese :: UnicodeScript

-- | Kaithi. Since 2.26
UnicodeScriptKaithi :: UnicodeScript

-- | Lisu. Since 2.26
UnicodeScriptLisu :: UnicodeScript

-- | Meetei Mayek. Since 2.26
UnicodeScriptMeeteiMayek :: UnicodeScript

-- | Old South Arabian. Since 2.26
UnicodeScriptOldSouthArabian :: UnicodeScript

-- | Old Turkic. Since 2.28
UnicodeScriptOldTurkic :: UnicodeScript

-- | Samaritan. Since 2.26
UnicodeScriptSamaritan :: UnicodeScript

-- | Tai Tham. Since 2.26
UnicodeScriptTaiTham :: UnicodeScript

-- | Tai Viet. Since 2.26
UnicodeScriptTaiViet :: UnicodeScript

-- | Batak. Since 2.28
UnicodeScriptBatak :: UnicodeScript

-- | Brahmi. Since 2.28
UnicodeScriptBrahmi :: UnicodeScript

-- | Mandaic. Since 2.28
UnicodeScriptMandaic :: UnicodeScript

-- | Chakma. Since: 2.32
UnicodeScriptChakma :: UnicodeScript

-- | Meroitic Cursive. Since: 2.32
UnicodeScriptMeroiticCursive :: UnicodeScript

-- | Meroitic Hieroglyphs. Since: 2.32
UnicodeScriptMeroiticHieroglyphs :: UnicodeScript

-- | Miao. Since: 2.32
UnicodeScriptMiao :: UnicodeScript

-- | Sharada. Since: 2.32
UnicodeScriptSharada :: UnicodeScript

-- | Sora Sompeng. Since: 2.32
UnicodeScriptSoraSompeng :: UnicodeScript

-- | Takri. Since: 2.32
UnicodeScriptTakri :: UnicodeScript

-- | Bassa. Since: 2.42
UnicodeScriptBassaVah :: UnicodeScript

-- | Caucasian Albanian. Since: 2.42
UnicodeScriptCaucasianAlbanian :: UnicodeScript

-- | Duployan. Since: 2.42
UnicodeScriptDuployan :: UnicodeScript

-- | Elbasan. Since: 2.42
UnicodeScriptElbasan :: UnicodeScript

-- | Grantha. Since: 2.42
UnicodeScriptGrantha :: UnicodeScript

-- | Kjohki. Since: 2.42
UnicodeScriptKhojki :: UnicodeScript

-- | Khudawadi, Sindhi. Since: 2.42
UnicodeScriptKhudawadi :: UnicodeScript

-- | Linear A. Since: 2.42
UnicodeScriptLinearA :: UnicodeScript

-- | Mahajani. Since: 2.42
UnicodeScriptMahajani :: UnicodeScript

-- | Manichaean. Since: 2.42
UnicodeScriptManichaean :: UnicodeScript

-- | Mende Kikakui. Since: 2.42
UnicodeScriptMendeKikakui :: UnicodeScript

-- | Modi. Since: 2.42
UnicodeScriptModi :: UnicodeScript

-- | Mro. Since: 2.42
UnicodeScriptMro :: UnicodeScript

-- | Nabataean. Since: 2.42
UnicodeScriptNabataean :: UnicodeScript

-- | Old North Arabian. Since: 2.42
UnicodeScriptOldNorthArabian :: UnicodeScript

-- | Old Permic. Since: 2.42
UnicodeScriptOldPermic :: UnicodeScript

-- | Pahawh Hmong. Since: 2.42
UnicodeScriptPahawhHmong :: UnicodeScript

-- | Palmyrene. Since: 2.42
UnicodeScriptPalmyrene :: UnicodeScript

-- | Pau Cin Hau. Since: 2.42
UnicodeScriptPauCinHau :: UnicodeScript

-- | Psalter Pahlavi. Since: 2.42
UnicodeScriptPsalterPahlavi :: UnicodeScript

-- | Siddham. Since: 2.42
UnicodeScriptSiddham :: UnicodeScript

-- | Tirhuta. Since: 2.42
UnicodeScriptTirhuta :: UnicodeScript

-- | Warang Citi. Since: 2.42
UnicodeScriptWarangCiti :: UnicodeScript

-- | Ahom. Since: 2.48
UnicodeScriptAhom :: UnicodeScript

-- | Anatolian Hieroglyphs. Since: 2.48
UnicodeScriptAnatolianHieroglyphs :: UnicodeScript

-- | Hatran. Since: 2.48
UnicodeScriptHatran :: UnicodeScript

-- | Multani. Since: 2.48
UnicodeScriptMultani :: UnicodeScript

-- | Old Hungarian. Since: 2.48
UnicodeScriptOldHungarian :: UnicodeScript

-- | Signwriting. Since: 2.48
UnicodeScriptSignwriting :: UnicodeScript

-- | Adlam. Since: 2.50
UnicodeScriptAdlam :: UnicodeScript

-- | Bhaiksuki. Since: 2.50
UnicodeScriptBhaiksuki :: UnicodeScript

-- | Marchen. Since: 2.50
UnicodeScriptMarchen :: UnicodeScript

-- | Newa. Since: 2.50
UnicodeScriptNewa :: UnicodeScript

-- | Osage. Since: 2.50
UnicodeScriptOsage :: UnicodeScript

-- | Tangut. Since: 2.50
UnicodeScriptTangut :: UnicodeScript

-- | Masaram Gondi. Since: 2.54
UnicodeScriptMasaramGondi :: UnicodeScript

-- | Nushu. Since: 2.54
UnicodeScriptNushu :: UnicodeScript

-- | Soyombo. Since: 2.54
UnicodeScriptSoyombo :: UnicodeScript

-- | Zanabazar Square. Since: 2.54
UnicodeScriptZanabazarSquare :: UnicodeScript

-- | Dogra. Since: 2.58
UnicodeScriptDogra :: UnicodeScript

-- | Gunjala Gondi. Since: 2.58
UnicodeScriptGunjalaGondi :: UnicodeScript

-- | Hanifi Rohingya. Since: 2.58
UnicodeScriptHanifiRohingya :: UnicodeScript

-- | Makasar. Since: 2.58
UnicodeScriptMakasar :: UnicodeScript

-- | Medefaidrin. Since: 2.58
UnicodeScriptMedefaidrin :: UnicodeScript

-- | Old Sogdian. Since: 2.58
UnicodeScriptOldSogdian :: UnicodeScript

-- | Sogdian. Since: 2.58
UnicodeScriptSogdian :: UnicodeScript

-- | Elym. Since: 2.62
UnicodeScriptElymaic :: UnicodeScript

-- | Nand. Since: 2.62
UnicodeScriptNandinagari :: UnicodeScript

-- | Rohg. Since: 2.62
UnicodeScriptNyiakengPuachueHmong :: UnicodeScript

-- | Wcho. Since: 2.62
UnicodeScriptWancho :: UnicodeScript

-- | Chorasmian. Since: 2.66
UnicodeScriptChorasmian :: UnicodeScript

-- | Dives Akuru. Since: 2.66
UnicodeScriptDivesAkuru :: UnicodeScript

-- | Khitan small script. Since: 2.66
UnicodeScriptKhitanSmallScript :: UnicodeScript

-- | Yezidi. Since: 2.66
UnicodeScriptYezidi :: UnicodeScript

-- | Cypro-Minoan. Since: 2.72
UnicodeScriptCyproMinoan :: UnicodeScript

-- | Old Uyghur. Since: 2.72
UnicodeScriptOldUyghur :: UnicodeScript

-- | Tangsa. Since: 2.72
UnicodeScriptTangsa :: UnicodeScript

-- | Toto. Since: 2.72
UnicodeScriptToto :: UnicodeScript

-- | Vithkuqi. Since: 2.72
UnicodeScriptVithkuqi :: UnicodeScript

-- | Mathematical notation. Since: 2.72
UnicodeScriptMath :: UnicodeScript

-- | Kawi. Since 2.74
UnicodeScriptKawi :: UnicodeScript

-- | Nag Mundari. Since 2.74
UnicodeScriptNagMundari :: UnicodeScript

-- | Todhri. Since: 2.84
UnicodeScriptTodhri :: UnicodeScript

-- | Garay. Since: 2.84
UnicodeScriptGaray :: UnicodeScript

-- | Tulu-Tigalari. Since: 2.84
UnicodeScriptTuluTigalari :: UnicodeScript

-- | Sunuwar. Since: 2.84
UnicodeScriptSunuwar :: UnicodeScript

-- | Gurung Khema. Since: 2.84
UnicodeScriptGurungKhema :: UnicodeScript

-- | Kirat Rai. Since: 2.84
UnicodeScriptKiratRai :: UnicodeScript

-- | Ol Onal. Since: 2.84
UnicodeScriptOlOnal :: UnicodeScript

-- | Sidetic. Since: 2.88
UnicodeScriptSidetic :: UnicodeScript

-- | Tolong Siki. Since: 2.88
UnicodeScriptTolongSiki :: UnicodeScript

-- | Tai Yo. Since: 2.88
UnicodeScriptTaiYo :: UnicodeScript

-- | Beria Erfe. Since: 2.88
UnicodeScriptBeriaErfe :: UnicodeScript

-- | Catch-all for unknown values
AnotherUnicodeScript :: Int -> UnicodeScript

-- | These are the possible character classifications from the Unicode
--   specification. See <a>Unicode Character Database</a>.
data UnicodeType

-- | General category "Other, Control" (Cc)
UnicodeTypeControl :: UnicodeType

-- | General category "Other, Format" (Cf)
UnicodeTypeFormat :: UnicodeType

-- | General category "Other, Not Assigned" (Cn)
UnicodeTypeUnassigned :: UnicodeType

-- | General category "Other, Private Use" (Co)
UnicodeTypePrivateUse :: UnicodeType

-- | General category "Other, Surrogate" (Cs)
UnicodeTypeSurrogate :: UnicodeType

-- | General category "Letter, Lowercase" (Ll)
UnicodeTypeLowercaseLetter :: UnicodeType

-- | General category "Letter, Modifier" (Lm)
UnicodeTypeModifierLetter :: UnicodeType

-- | General category "Letter, Other" (Lo)
UnicodeTypeOtherLetter :: UnicodeType

-- | General category "Letter, Titlecase" (Lt)
UnicodeTypeTitlecaseLetter :: UnicodeType

-- | General category "Letter, Uppercase" (Lu)
UnicodeTypeUppercaseLetter :: UnicodeType

-- | General category "Mark, Spacing" (Mc)
UnicodeTypeSpacingMark :: UnicodeType

-- | General category "Mark, Enclosing" (Me)
UnicodeTypeEnclosingMark :: UnicodeType

-- | General category "Mark, Nonspacing" (Mn)
UnicodeTypeNonSpacingMark :: UnicodeType

-- | General category "Number, Decimal Digit" (Nd)
UnicodeTypeDecimalNumber :: UnicodeType

-- | General category "Number, Letter" (Nl)
UnicodeTypeLetterNumber :: UnicodeType

-- | General category "Number, Other" (No)
UnicodeTypeOtherNumber :: UnicodeType

-- | General category "Punctuation, Connector" (Pc)
UnicodeTypeConnectPunctuation :: UnicodeType

-- | General category "Punctuation, Dash" (Pd)
UnicodeTypeDashPunctuation :: UnicodeType

-- | General category "Punctuation, Close" (Pe)
UnicodeTypeClosePunctuation :: UnicodeType

-- | General category "Punctuation, Final quote" (Pf)
UnicodeTypeFinalPunctuation :: UnicodeType

-- | General category "Punctuation, Initial quote" (Pi)
UnicodeTypeInitialPunctuation :: UnicodeType

-- | General category "Punctuation, Other" (Po)
UnicodeTypeOtherPunctuation :: UnicodeType

-- | General category "Punctuation, Open" (Ps)
UnicodeTypeOpenPunctuation :: UnicodeType

-- | General category "Symbol, Currency" (Sc)
UnicodeTypeCurrencySymbol :: UnicodeType

-- | General category "Symbol, Modifier" (Sk)
UnicodeTypeModifierSymbol :: UnicodeType

-- | General category "Symbol, Math" (Sm)
UnicodeTypeMathSymbol :: UnicodeType

-- | General category "Symbol, Other" (So)
UnicodeTypeOtherSymbol :: UnicodeType

-- | General category "Separator, Line" (Zl)
UnicodeTypeLineSeparator :: UnicodeType

-- | General category "Separator, Paragraph" (Zp)
UnicodeTypeParagraphSeparator :: UnicodeType

-- | General category "Separator, Space" (Zs)
UnicodeTypeSpaceSeparator :: UnicodeType

-- | Catch-all for unknown values
AnotherUnicodeType :: Int -> UnicodeType

-- | Mnemonic constants for the ends of a Unix pipe.
--   
--   <i>Since: 2.80</i>
data UnixPipeEnd

-- | The readable file descriptor 0
UnixPipeEndRead :: UnixPipeEnd

-- | The writable file descriptor 1
UnixPipeEndWrite :: UnixPipeEnd

-- | Catch-all for unknown values
AnotherUnixPipeEnd :: Int -> UnixPipeEnd

-- | Error codes returned by <a>Uri</a> methods.
--   
--   <i>Since: 2.66</i>
data UriError

-- | Generic error if no more specific error is available. See the error
--   message for details.
UriErrorFailed :: UriError

-- | The scheme of a URI could not be parsed.
UriErrorBadScheme :: UriError

-- | The user/userinfo of a URI could not be parsed.
UriErrorBadUser :: UriError

-- | The password of a URI could not be parsed.
UriErrorBadPassword :: UriError

-- | The authentication parameters of a URI could not be parsed.
UriErrorBadAuthParams :: UriError

-- | The host of a URI could not be parsed.
UriErrorBadHost :: UriError

-- | The port of a URI could not be parsed.
UriErrorBadPort :: UriError

-- | The path of a URI could not be parsed.
UriErrorBadPath :: UriError

-- | The query of a URI could not be parsed.
UriErrorBadQuery :: UriError

-- | The fragment of a URI could not be parsed.
UriErrorBadFragment :: UriError

-- | Catch-all for unknown values
AnotherUriError :: Int -> UriError

-- | Catch exceptions of type <a>UriError</a>. This is a specialized
--   version of <a>catchGErrorJustDomain</a>.
catchUriError :: IO a -> (UriError -> GErrorMessage -> IO a) -> IO a

-- | Handle exceptions of type <a>UriError</a>. This is a specialized
--   version of <a>handleGErrorJustDomain</a>.
handleUriError :: (UriError -> GErrorMessage -> IO a) -> IO a -> IO a

-- | These are logical ids for special directories which are defined
--   depending on the platform used. You should use
--   <a>getUserSpecialDir</a> to retrieve the full path associated to the
--   logical id.
--   
--   The <a>UserDirectory</a> enumeration can be extended at later date.
--   Not every platform has a directory for every logical id in this
--   enumeration.
--   
--   <i>Since: 2.14</i>
data UserDirectory

-- | the user's Desktop directory
UserDirectoryDirectoryDesktop :: UserDirectory

-- | the user's Documents directory
UserDirectoryDirectoryDocuments :: UserDirectory

-- | the user's Downloads directory
UserDirectoryDirectoryDownload :: UserDirectory

-- | the user's Music directory
UserDirectoryDirectoryMusic :: UserDirectory

-- | the user's Pictures directory
UserDirectoryDirectoryPictures :: UserDirectory

-- | the user's shared directory
UserDirectoryDirectoryPublicShare :: UserDirectory

-- | the user's Templates directory
UserDirectoryDirectoryTemplates :: UserDirectory

-- | the user's Movies directory
UserDirectoryDirectoryVideos :: UserDirectory

-- | the number of enum values
UserDirectoryNDirectories :: UserDirectory

-- | Catch-all for unknown values
AnotherUserDirectory :: Int -> UserDirectory

-- | The range of possible top-level types of <a>GVariant</a> instances.
--   
--   <i>Since: 2.24</i>
data VariantClass

-- | The <a>GVariant</a> is a boolean.
VariantClassBoolean :: VariantClass

-- | The <a>GVariant</a> is a byte.
VariantClassByte :: VariantClass

-- | The <a>GVariant</a> is a signed 16 bit integer.
VariantClassInt16 :: VariantClass

-- | The <a>GVariant</a> is an unsigned 16 bit integer.
VariantClassUint16 :: VariantClass

-- | The <a>GVariant</a> is a signed 32 bit integer.
VariantClassInt32 :: VariantClass

-- | The <a>GVariant</a> is an unsigned 32 bit integer.
VariantClassUint32 :: VariantClass

-- | The <a>GVariant</a> is a signed 64 bit integer.
VariantClassInt64 :: VariantClass

-- | The <a>GVariant</a> is an unsigned 64 bit integer.
VariantClassUint64 :: VariantClass

-- | The <a>GVariant</a> is a file handle index.
VariantClassHandle :: VariantClass

-- | The <a>GVariant</a> is a double precision floating point value.
VariantClassDouble :: VariantClass

-- | The <a>GVariant</a> is a normal string.
VariantClassString :: VariantClass

-- | The <a>GVariant</a> is a D-Bus object path string.
VariantClassObjectPath :: VariantClass

-- | The <a>GVariant</a> is a D-Bus signature string.
VariantClassSignature :: VariantClass

-- | The <a>GVariant</a> is a variant.
VariantClassVariant :: VariantClass

-- | The <a>GVariant</a> is a maybe-typed value.
VariantClassMaybe :: VariantClass

-- | The <a>GVariant</a> is an array.
VariantClassArray :: VariantClass

-- | The <a>GVariant</a> is a tuple.
VariantClassTuple :: VariantClass

-- | The <a>GVariant</a> is a dictionary entry.
VariantClassDictEntry :: VariantClass

-- | Catch-all for unknown values
AnotherVariantClass :: Int -> VariantClass

-- | Error codes returned by parsing text-format GVariants.
data VariantParseError

-- | generic error (unused)
VariantParseErrorFailed :: VariantParseError

-- | a non-basic <a>VariantType</a> was given where a basic type was
--   expected
VariantParseErrorBasicTypeExpected :: VariantParseError

-- | cannot infer the <a>VariantType</a>
VariantParseErrorCannotInferType :: VariantParseError

-- | an indefinite <a>VariantType</a> was given where a definite type was
--   expected
VariantParseErrorDefiniteTypeExpected :: VariantParseError

-- | extra data after parsing finished
VariantParseErrorInputNotAtEnd :: VariantParseError

-- | invalid character in number or unicode escape
VariantParseErrorInvalidCharacter :: VariantParseError

-- | not a valid <a>GVariant</a> format string
VariantParseErrorInvalidFormatString :: VariantParseError

-- | not a valid object path
VariantParseErrorInvalidObjectPath :: VariantParseError

-- | not a valid type signature
VariantParseErrorInvalidSignature :: VariantParseError

-- | not a valid <a>GVariant</a> type string
VariantParseErrorInvalidTypeString :: VariantParseError

-- | could not find a common type for array entries
VariantParseErrorNoCommonType :: VariantParseError

-- | the numerical value is out of range of the given type
VariantParseErrorNumberOutOfRange :: VariantParseError

-- | the numerical value is out of range for any type
VariantParseErrorNumberTooBig :: VariantParseError

-- | cannot parse as variant of the specified type
VariantParseErrorTypeError :: VariantParseError

-- | an unexpected token was encountered
VariantParseErrorUnexpectedToken :: VariantParseError

-- | an unknown keyword was encountered
VariantParseErrorUnknownKeyword :: VariantParseError

-- | unterminated string constant
VariantParseErrorUnterminatedStringConstant :: VariantParseError

-- | no value given
VariantParseErrorValueExpected :: VariantParseError

-- | variant was too deeply nested; <a>GVariant</a> is only guaranteed to
--   handle nesting up to 64 levels (Since: 2.64)
VariantParseErrorRecursion :: VariantParseError

-- | Catch-all for unknown values
AnotherVariantParseError :: Int -> VariantParseError

-- | Catch exceptions of type <a>VariantParseError</a>. This is a
--   specialized version of <a>catchGErrorJustDomain</a>.
catchVariantParseError :: IO a -> (VariantParseError -> GErrorMessage -> IO a) -> IO a

-- | Handle exceptions of type <a>VariantParseError</a>. This is a
--   specialized version of <a>handleGErrorJustDomain</a>.
handleVariantParseError :: (VariantParseError -> GErrorMessage -> IO a) -> IO a -> IO a
instance Data.GI.Base.BasicTypes.BoxedEnum GI.GLib.Enums.NormalizeMode
instance Data.GI.Base.BasicTypes.BoxedEnum GI.GLib.Enums.UnicodeBreakType
instance Data.GI.Base.BasicTypes.BoxedEnum GI.GLib.Enums.UnicodeScript
instance Data.GI.Base.BasicTypes.BoxedEnum GI.GLib.Enums.UnicodeType
instance GHC.Internal.Enum.Enum GI.GLib.Enums.BookmarkFileError
instance GHC.Internal.Enum.Enum GI.GLib.Enums.ChecksumType
instance GHC.Internal.Enum.Enum GI.GLib.Enums.ConvertError
instance GHC.Internal.Enum.Enum GI.GLib.Enums.DateDMY
instance GHC.Internal.Enum.Enum GI.GLib.Enums.DateMonth
instance GHC.Internal.Enum.Enum GI.GLib.Enums.DateWeekday
instance GHC.Internal.Enum.Enum GI.GLib.Enums.ErrorType
instance GHC.Internal.Enum.Enum GI.GLib.Enums.FileError
instance GHC.Internal.Enum.Enum GI.GLib.Enums.IOChannelError
instance GHC.Internal.Enum.Enum GI.GLib.Enums.IOError
instance GHC.Internal.Enum.Enum GI.GLib.Enums.IOStatus
instance GHC.Internal.Enum.Enum GI.GLib.Enums.KeyFileError
instance GHC.Internal.Enum.Enum GI.GLib.Enums.LogWriterOutput
instance GHC.Internal.Enum.Enum GI.GLib.Enums.MarkupError
instance GHC.Internal.Enum.Enum GI.GLib.Enums.NormalizeMode
instance GHC.Internal.Enum.Enum GI.GLib.Enums.NumberParserError
instance GHC.Internal.Enum.Enum GI.GLib.Enums.OnceStatus
instance GHC.Internal.Enum.Enum GI.GLib.Enums.OptionArg
instance GHC.Internal.Enum.Enum GI.GLib.Enums.OptionError
instance GHC.Internal.Enum.Enum GI.GLib.Enums.RegexError
instance GHC.Internal.Enum.Enum GI.GLib.Enums.SeekType
instance GHC.Internal.Enum.Enum GI.GLib.Enums.ShellError
instance GHC.Internal.Enum.Enum GI.GLib.Enums.SliceConfig
instance GHC.Internal.Enum.Enum GI.GLib.Enums.SpawnError
instance GHC.Internal.Enum.Enum GI.GLib.Enums.TestFileType
instance GHC.Internal.Enum.Enum GI.GLib.Enums.TestLogType
instance GHC.Internal.Enum.Enum GI.GLib.Enums.TestResult
instance GHC.Internal.Enum.Enum GI.GLib.Enums.ThreadError
instance GHC.Internal.Enum.Enum GI.GLib.Enums.TimeType
instance GHC.Internal.Enum.Enum GI.GLib.Enums.TokenType
instance GHC.Internal.Enum.Enum GI.GLib.Enums.TraverseType
instance GHC.Internal.Enum.Enum GI.GLib.Enums.UnicodeBreakType
instance GHC.Internal.Enum.Enum GI.GLib.Enums.UnicodeScript
instance GHC.Internal.Enum.Enum GI.GLib.Enums.UnicodeType
instance GHC.Internal.Enum.Enum GI.GLib.Enums.UnixPipeEnd
instance GHC.Internal.Enum.Enum GI.GLib.Enums.UriError
instance GHC.Internal.Enum.Enum GI.GLib.Enums.UserDirectory
instance GHC.Internal.Enum.Enum GI.GLib.Enums.VariantClass
instance GHC.Internal.Enum.Enum GI.GLib.Enums.VariantParseError
instance GHC.Classes.Eq GI.GLib.Enums.BookmarkFileError
instance GHC.Classes.Eq GI.GLib.Enums.ChecksumType
instance GHC.Classes.Eq GI.GLib.Enums.ConvertError
instance GHC.Classes.Eq GI.GLib.Enums.DateDMY
instance GHC.Classes.Eq GI.GLib.Enums.DateMonth
instance GHC.Classes.Eq GI.GLib.Enums.DateWeekday
instance GHC.Classes.Eq GI.GLib.Enums.ErrorType
instance GHC.Classes.Eq GI.GLib.Enums.FileError
instance GHC.Classes.Eq GI.GLib.Enums.IOChannelError
instance GHC.Classes.Eq GI.GLib.Enums.IOError
instance GHC.Classes.Eq GI.GLib.Enums.IOStatus
instance GHC.Classes.Eq GI.GLib.Enums.KeyFileError
instance GHC.Classes.Eq GI.GLib.Enums.LogWriterOutput
instance GHC.Classes.Eq GI.GLib.Enums.MarkupError
instance GHC.Classes.Eq GI.GLib.Enums.NormalizeMode
instance GHC.Classes.Eq GI.GLib.Enums.NumberParserError
instance GHC.Classes.Eq GI.GLib.Enums.OnceStatus
instance GHC.Classes.Eq GI.GLib.Enums.OptionArg
instance GHC.Classes.Eq GI.GLib.Enums.OptionError
instance GHC.Classes.Eq GI.GLib.Enums.RegexError
instance GHC.Classes.Eq GI.GLib.Enums.SeekType
instance GHC.Classes.Eq GI.GLib.Enums.ShellError
instance GHC.Classes.Eq GI.GLib.Enums.SliceConfig
instance GHC.Classes.Eq GI.GLib.Enums.SpawnError
instance GHC.Classes.Eq GI.GLib.Enums.TestFileType
instance GHC.Classes.Eq GI.GLib.Enums.TestLogType
instance GHC.Classes.Eq GI.GLib.Enums.TestResult
instance GHC.Classes.Eq GI.GLib.Enums.ThreadError
instance GHC.Classes.Eq GI.GLib.Enums.TimeType
instance GHC.Classes.Eq GI.GLib.Enums.TokenType
instance GHC.Classes.Eq GI.GLib.Enums.TraverseType
instance GHC.Classes.Eq GI.GLib.Enums.UnicodeBreakType
instance GHC.Classes.Eq GI.GLib.Enums.UnicodeScript
instance GHC.Classes.Eq GI.GLib.Enums.UnicodeType
instance GHC.Classes.Eq GI.GLib.Enums.UnixPipeEnd
instance GHC.Classes.Eq GI.GLib.Enums.UriError
instance GHC.Classes.Eq GI.GLib.Enums.UserDirectory
instance GHC.Classes.Eq GI.GLib.Enums.VariantClass
instance GHC.Classes.Eq GI.GLib.Enums.VariantParseError
instance Data.GI.Base.GError.GErrorClass GI.GLib.Enums.BookmarkFileError
instance Data.GI.Base.GError.GErrorClass GI.GLib.Enums.ConvertError
instance Data.GI.Base.GError.GErrorClass GI.GLib.Enums.FileError
instance Data.GI.Base.GError.GErrorClass GI.GLib.Enums.IOChannelError
instance Data.GI.Base.GError.GErrorClass GI.GLib.Enums.KeyFileError
instance Data.GI.Base.GError.GErrorClass GI.GLib.Enums.MarkupError
instance Data.GI.Base.GError.GErrorClass GI.GLib.Enums.NumberParserError
instance Data.GI.Base.GError.GErrorClass GI.GLib.Enums.OptionError
instance Data.GI.Base.GError.GErrorClass GI.GLib.Enums.RegexError
instance Data.GI.Base.GError.GErrorClass GI.GLib.Enums.ShellError
instance Data.GI.Base.GError.GErrorClass GI.GLib.Enums.SpawnError
instance Data.GI.Base.GError.GErrorClass GI.GLib.Enums.ThreadError
instance Data.GI.Base.GError.GErrorClass GI.GLib.Enums.UriError
instance Data.GI.Base.GError.GErrorClass GI.GLib.Enums.VariantParseError
instance Data.GI.Base.Overloading.HasParentTypes GI.GLib.Enums.NormalizeMode
instance Data.GI.Base.Overloading.HasParentTypes GI.GLib.Enums.UnicodeBreakType
instance Data.GI.Base.Overloading.HasParentTypes GI.GLib.Enums.UnicodeScript
instance Data.GI.Base.Overloading.HasParentTypes GI.GLib.Enums.UnicodeType
instance GHC.Classes.Ord GI.GLib.Enums.BookmarkFileError
instance GHC.Classes.Ord GI.GLib.Enums.ChecksumType
instance GHC.Classes.Ord GI.GLib.Enums.ConvertError
instance GHC.Classes.Ord GI.GLib.Enums.DateDMY
instance GHC.Classes.Ord GI.GLib.Enums.DateMonth
instance GHC.Classes.Ord GI.GLib.Enums.DateWeekday
instance GHC.Classes.Ord GI.GLib.Enums.ErrorType
instance GHC.Classes.Ord GI.GLib.Enums.FileError
instance GHC.Classes.Ord GI.GLib.Enums.IOChannelError
instance GHC.Classes.Ord GI.GLib.Enums.IOError
instance GHC.Classes.Ord GI.GLib.Enums.IOStatus
instance GHC.Classes.Ord GI.GLib.Enums.KeyFileError
instance GHC.Classes.Ord GI.GLib.Enums.LogWriterOutput
instance GHC.Classes.Ord GI.GLib.Enums.MarkupError
instance GHC.Classes.Ord GI.GLib.Enums.NormalizeMode
instance GHC.Classes.Ord GI.GLib.Enums.NumberParserError
instance GHC.Classes.Ord GI.GLib.Enums.OnceStatus
instance GHC.Classes.Ord GI.GLib.Enums.OptionArg
instance GHC.Classes.Ord GI.GLib.Enums.OptionError
instance GHC.Classes.Ord GI.GLib.Enums.RegexError
instance GHC.Classes.Ord GI.GLib.Enums.SeekType
instance GHC.Classes.Ord GI.GLib.Enums.ShellError
instance GHC.Classes.Ord GI.GLib.Enums.SliceConfig
instance GHC.Classes.Ord GI.GLib.Enums.SpawnError
instance GHC.Classes.Ord GI.GLib.Enums.TestFileType
instance GHC.Classes.Ord GI.GLib.Enums.TestLogType
instance GHC.Classes.Ord GI.GLib.Enums.TestResult
instance GHC.Classes.Ord GI.GLib.Enums.ThreadError
instance GHC.Classes.Ord GI.GLib.Enums.TimeType
instance GHC.Classes.Ord GI.GLib.Enums.TokenType
instance GHC.Classes.Ord GI.GLib.Enums.TraverseType
instance GHC.Classes.Ord GI.GLib.Enums.UnicodeBreakType
instance GHC.Classes.Ord GI.GLib.Enums.UnicodeScript
instance GHC.Classes.Ord GI.GLib.Enums.UnicodeType
instance GHC.Classes.Ord GI.GLib.Enums.UnixPipeEnd
instance GHC.Classes.Ord GI.GLib.Enums.UriError
instance GHC.Classes.Ord GI.GLib.Enums.UserDirectory
instance GHC.Classes.Ord GI.GLib.Enums.VariantClass
instance GHC.Classes.Ord GI.GLib.Enums.VariantParseError
instance GHC.Internal.Show.Show GI.GLib.Enums.BookmarkFileError
instance GHC.Internal.Show.Show GI.GLib.Enums.ChecksumType
instance GHC.Internal.Show.Show GI.GLib.Enums.ConvertError
instance GHC.Internal.Show.Show GI.GLib.Enums.DateDMY
instance GHC.Internal.Show.Show GI.GLib.Enums.DateMonth
instance GHC.Internal.Show.Show GI.GLib.Enums.DateWeekday
instance GHC.Internal.Show.Show GI.GLib.Enums.ErrorType
instance GHC.Internal.Show.Show GI.GLib.Enums.FileError
instance GHC.Internal.Show.Show GI.GLib.Enums.IOChannelError
instance GHC.Internal.Show.Show GI.GLib.Enums.IOError
instance GHC.Internal.Show.Show GI.GLib.Enums.IOStatus
instance GHC.Internal.Show.Show GI.GLib.Enums.KeyFileError
instance GHC.Internal.Show.Show GI.GLib.Enums.LogWriterOutput
instance GHC.Internal.Show.Show GI.GLib.Enums.MarkupError
instance GHC.Internal.Show.Show GI.GLib.Enums.NormalizeMode
instance GHC.Internal.Show.Show GI.GLib.Enums.NumberParserError
instance GHC.Internal.Show.Show GI.GLib.Enums.OnceStatus
instance GHC.Internal.Show.Show GI.GLib.Enums.OptionArg
instance GHC.Internal.Show.Show GI.GLib.Enums.OptionError
instance GHC.Internal.Show.Show GI.GLib.Enums.RegexError
instance GHC.Internal.Show.Show GI.GLib.Enums.SeekType
instance GHC.Internal.Show.Show GI.GLib.Enums.ShellError
instance GHC.Internal.Show.Show GI.GLib.Enums.SliceConfig
instance GHC.Internal.Show.Show GI.GLib.Enums.SpawnError
instance GHC.Internal.Show.Show GI.GLib.Enums.TestFileType
instance GHC.Internal.Show.Show GI.GLib.Enums.TestLogType
instance GHC.Internal.Show.Show GI.GLib.Enums.TestResult
instance GHC.Internal.Show.Show GI.GLib.Enums.ThreadError
instance GHC.Internal.Show.Show GI.GLib.Enums.TimeType
instance GHC.Internal.Show.Show GI.GLib.Enums.TokenType
instance GHC.Internal.Show.Show GI.GLib.Enums.TraverseType
instance GHC.Internal.Show.Show GI.GLib.Enums.UnicodeBreakType
instance GHC.Internal.Show.Show GI.GLib.Enums.UnicodeScript
instance GHC.Internal.Show.Show GI.GLib.Enums.UnicodeType
instance GHC.Internal.Show.Show GI.GLib.Enums.UnixPipeEnd
instance GHC.Internal.Show.Show GI.GLib.Enums.UriError
instance GHC.Internal.Show.Show GI.GLib.Enums.UserDirectory
instance GHC.Internal.Show.Show GI.GLib.Enums.VariantClass
instance GHC.Internal.Show.Show GI.GLib.Enums.VariantParseError
instance Data.GI.Base.BasicTypes.TypedObject GI.GLib.Enums.NormalizeMode
instance Data.GI.Base.BasicTypes.TypedObject GI.GLib.Enums.UnicodeBreakType
instance Data.GI.Base.BasicTypes.TypedObject GI.GLib.Enums.UnicodeScript
instance Data.GI.Base.BasicTypes.TypedObject GI.GLib.Enums.UnicodeType


module GI.GLib.Flags

-- | <i>No description available in the introspection data.</i>
data AsciiType

-- | <i>No description available in the introspection data.</i>
AsciiTypeAlnum :: AsciiType

-- | <i>No description available in the introspection data.</i>
AsciiTypeAlpha :: AsciiType

-- | <i>No description available in the introspection data.</i>
AsciiTypeCntrl :: AsciiType

-- | <i>No description available in the introspection data.</i>
AsciiTypeDigit :: AsciiType

-- | <i>No description available in the introspection data.</i>
AsciiTypeGraph :: AsciiType

-- | <i>No description available in the introspection data.</i>
AsciiTypeLower :: AsciiType

-- | <i>No description available in the introspection data.</i>
AsciiTypePrint :: AsciiType

-- | <i>No description available in the introspection data.</i>
AsciiTypePunct :: AsciiType

-- | <i>No description available in the introspection data.</i>
AsciiTypeSpace :: AsciiType

-- | <i>No description available in the introspection data.</i>
AsciiTypeUpper :: AsciiType

-- | <i>No description available in the introspection data.</i>
AsciiTypeXdigit :: AsciiType

-- | Catch-all for unknown values
AnotherAsciiType :: Int -> AsciiType

-- | Flags to pass to <a>fileSetContentsFull</a> to affect its safety and
--   performance.
--   
--   <i>Since: 2.66</i>
data FileSetContentsFlags

-- | No guarantees about file consistency or durability. The most dangerous
--   setting, which is slightly faster than other settings.
FileSetContentsFlagsNone :: FileSetContentsFlags

-- | Guarantee file consistency: after a crash, either the old version of
--   the file or the new version of the file will be available, but not a
--   mixture. On Unix systems this equates to an <tt>fsync()</tt> on the
--   file and use of an atomic <tt>rename()</tt> of the new version of the
--   file over the old.
FileSetContentsFlagsConsistent :: FileSetContentsFlags

-- | Guarantee file durability: after a crash, the new version of the file
--   will be available. On Unix systems this equates to an <tt>fsync()</tt>
--   on the file (if <a>FileSetContentsFlagsConsistent</a> is unset), or
--   the effects of <a>FileSetContentsFlagsConsistent</a> plus an
--   <tt>fsync()</tt> on the directory containing the file after calling
--   <tt>rename()</tt>.
FileSetContentsFlagsDurable :: FileSetContentsFlags

-- | Only apply consistency and durability guarantees if the file already
--   exists. This may speed up file operations if the file doesn’t
--   currently exist, but may result in a corrupted version of the new file
--   if the system crashes while writing it.
FileSetContentsFlagsOnlyExisting :: FileSetContentsFlags

-- | Catch-all for unknown values
AnotherFileSetContentsFlags :: Int -> FileSetContentsFlags

-- | A test to perform on a file using <a>fileTest</a>.
data FileTest

-- | <a>True</a> if the file is a regular file (not a directory). Note that
--   this test will also return <a>True</a> if the tested file is a symlink
--   to a regular file.
FileTestIsRegular :: FileTest

-- | <a>True</a> if the file is a symlink.
FileTestIsSymlink :: FileTest

-- | <a>True</a> if the file is a directory.
FileTestIsDir :: FileTest

-- | <a>True</a> if the file is executable.
FileTestIsExecutable :: FileTest

-- | <a>True</a> if the file exists. It may or may not be a regular file.
FileTestExists :: FileTest

-- | Catch-all for unknown values
AnotherFileTest :: Int -> FileTest

-- | Flags to modify the format of the string returned by
--   <a>formatSizeFull</a>.
data FormatSizeFlags

-- | behave the same as <a>formatSize</a>
FormatSizeFlagsDefault :: FormatSizeFlags

-- | include the exact number of bytes as part of the returned string. For
--   example, "45.6 kB (45,612 bytes)".
FormatSizeFlagsLongFormat :: FormatSizeFlags

-- | use IEC (base 1024) units with "KiB"-style suffixes. IEC units should
--   only be used for reporting things with a strong "power of 2" basis,
--   like RAM sizes or RAID stripe sizes. Network and storage sizes should
--   be reported in the normal SI units.
FormatSizeFlagsIecUnits :: FormatSizeFlags

-- | set the size as a quantity in bits, rather than bytes, and return
--   units in bits. For example, ‘Mbit’ rather than ‘MB’.
FormatSizeFlagsBits :: FormatSizeFlags

-- | return only value, without unit; this should not be used together with
--   <i><tt>gFORMATSIZELONGFORMAT</tt></i> nor
--   <i><tt>gFORMATSIZEONLYUNIT</tt></i>. Since: 2.74
FormatSizeFlagsOnlyValue :: FormatSizeFlags

-- | return only unit, without value; this should not be used together with
--   <i><tt>gFORMATSIZELONGFORMAT</tt></i> nor
--   <i><tt>gFORMATSIZEONLYVALUE</tt></i>. Since: 2.74
FormatSizeFlagsOnlyUnit :: FormatSizeFlags

-- | Catch-all for unknown values
AnotherFormatSizeFlags :: Int -> FormatSizeFlags

-- | Flags used internally in the <a>Hook</a> implementation.
data HookFlagMask

-- | set if the hook has not been destroyed
HookFlagMaskActive :: HookFlagMask

-- | set if the hook is currently being run
HookFlagMaskInCall :: HookFlagMask

-- | <i>No description available in the introspection data.</i>
HookFlagMaskReserved1 :: HookFlagMask

-- | Catch-all for unknown values
AnotherHookFlagMask :: Int -> HookFlagMask

-- | A bitwise combination representing a condition to watch for on an
--   event source.
data IOCondition

-- | There is data to read.
IOConditionIn :: IOCondition

-- | Data can be written (without blocking).
IOConditionOut :: IOCondition

-- | There is urgent data to read.
IOConditionPri :: IOCondition

-- | Error condition.
IOConditionErr :: IOCondition

-- | Hung up (the connection has been broken, usually for pipes and
--   sockets).
IOConditionHup :: IOCondition

-- | Invalid request. The file descriptor is not open.
IOConditionNval :: IOCondition

-- | Catch-all for unknown values
AnotherIOCondition :: Int -> IOCondition

-- | Specifies properties of a <a>IOChannel</a>. Some of the flags can only
--   be read with <a>iOChannelGetFlags</a>, but not changed with
--   <a>iOChannelSetFlags</a>.
data IOFlags

-- | no special flags set. Since: 2.74
IOFlagsNone :: IOFlags

-- | turns on append mode, corresponds to <tt><i>O_APPEND</i></tt> (see the
--   documentation of the UNIX <tt><i>open()</i></tt> syscall)
IOFlagsAppend :: IOFlags

-- | turns on nonblocking mode, corresponds to
--   <tt><i>O_NONBLOCK</i></tt>/<tt><i>O_NDELAY</i></tt> (see the
--   documentation of the UNIX <tt><i>open()</i></tt> syscall)
IOFlagsNonblock :: IOFlags

-- | indicates that the io channel is readable. This flag cannot be
--   changed.
IOFlagsIsReadable :: IOFlags

-- | indicates that the io channel is writable. This flag cannot be
--   changed.
IOFlagsIsWritable :: IOFlags

-- | a misspelled version of <i><tt>gIOFLAGISWRITABLE</tt></i> that existed
--   before the spelling was fixed in GLib 2.30. It is kept here for
--   compatibility reasons. Deprecated since 2.30
IOFlagsIsWriteable :: IOFlags

-- | indicates that the io channel is seekable, i.e. that
--   <a>iOChannelSeekPosition</a> can be used on it. This flag cannot be
--   changed.
IOFlagsIsSeekable :: IOFlags

-- | the mask that specifies all the valid flags.
IOFlagsMask :: IOFlags

-- | the mask of the flags that are returned from <a>iOChannelGetFlags</a>
IOFlagsGetMask :: IOFlags

-- | the mask of the flags that the user can modify with
--   <a>iOChannelSetFlags</a>
IOFlagsSetMask :: IOFlags

-- | Catch-all for unknown values
AnotherIOFlags :: Int -> IOFlags

-- | Flags which influence the parsing.
data KeyFileFlags

-- | No flags, default behaviour
KeyFileFlagsNone :: KeyFileFlags

-- | Use this flag if you plan to write the (possibly modified) contents of
--   the key file back to a file; otherwise all comments will be lost when
--   the key file is written back.
KeyFileFlagsKeepComments :: KeyFileFlags

-- | Use this flag if you plan to write the (possibly modified) contents of
--   the key file back to a file; otherwise only the translations for the
--   current language will be written back.
KeyFileFlagsKeepTranslations :: KeyFileFlags

-- | Catch-all for unknown values
AnotherKeyFileFlags :: Int -> KeyFileFlags

-- | Flags specifying the level of log messages.
--   
--   It is possible to change how GLib treats messages of the various
--   levels using <a>logSetHandler</a> and <a>logSetFatalMask</a>.
data LogLevelFlags

-- | internal flag
LogLevelFlagsFlagRecursion :: LogLevelFlags

-- | internal flag
LogLevelFlagsFlagFatal :: LogLevelFlags

-- | log level for errors, see <tt><i>GLib.error</i></tt>. This level is
--   also used for messages produced by <tt><i>GLib.assert</i></tt>.
LogLevelFlagsLevelError :: LogLevelFlags

-- | log level for critical warning messages, see
--   <tt><i>GLib.critical</i></tt>. This level is also used for messages
--   produced by <tt><i>GLib.return_if_fail</i></tt> and
--   <tt><i>GLib.return_val_if_fail</i></tt>.
LogLevelFlagsLevelCritical :: LogLevelFlags

-- | log level for warnings, see <tt><i>GLib.warning</i></tt>
LogLevelFlagsLevelWarning :: LogLevelFlags

-- | log level for messages, see <tt><i>GLib.message</i></tt>
LogLevelFlagsLevelMessage :: LogLevelFlags

-- | log level for informational messages, see <tt><i>GLib.info</i></tt>
LogLevelFlagsLevelInfo :: LogLevelFlags

-- | log level for debug messages, see <tt><i>GLib.debug</i></tt>
LogLevelFlagsLevelDebug :: LogLevelFlags

-- | a mask including all log levels
LogLevelFlagsLevelMask :: LogLevelFlags

-- | Catch-all for unknown values
AnotherLogLevelFlags :: Int -> LogLevelFlags

-- | Flags to pass to <a>mainContextNewWithFlags</a> which affect the
--   behaviour of a <a>MainContext</a>.
--   
--   <i>Since: 2.72</i>
data MainContextFlags

-- | Default behaviour.
MainContextFlagsNone :: MainContextFlags

-- | Assume that polling for events will free the thread to process other
--   jobs. That's useful if you're using
--   <tt>g_main_context_{prepare,query,check,dispatch}</tt> to integrate
--   GMainContext in other event loops.
MainContextFlagsOwnerlessPolling :: MainContextFlags

-- | Catch-all for unknown values
AnotherMainContextFlags :: Int -> MainContextFlags

-- | A mixed enumerated type and flags field. You must specify one type
--   (string, strdup, boolean, tristate). Additionally, you may optionally
--   bitwise OR the type with the flag <a>MarkupCollectTypeOptional</a>.
--   
--   It is likely that this enum will be extended in the future to support
--   other types.
data MarkupCollectType

-- | used to terminate the list of attributes to collect
MarkupCollectTypeInvalid :: MarkupCollectType

-- | collect the string pointer directly from the attribute_values[] array.
--   Expects a parameter of type (const char __). If
--   <a>MarkupCollectTypeOptional</a> is specified and the attribute isn't
--   present then the pointer will be set to <a>Nothing</a>
MarkupCollectTypeString :: MarkupCollectType

-- | as with <a>MarkupCollectTypeString</a>, but expects a parameter of
--   type (char __) and <a>strdup</a>s the returned pointer. The pointer
--   must be freed with <a>free</a>
MarkupCollectTypeStrdup :: MarkupCollectType

-- | expects a parameter of type (<tt>gboolean *</tt>) and parses the
--   attribute value as a boolean. Sets <a>False</a> if the attribute isn't
--   present. Valid boolean values consist of (case-insensitive) "false",
--   "f", "no", "n", "0" and "true", "t", "yes", "y", "1"
MarkupCollectTypeBoolean :: MarkupCollectType

-- | as with <a>MarkupCollectTypeBoolean</a>, but in the case of a missing
--   attribute a value is set that compares equal to neither <a>False</a>
--   nor <a>True</a> <a>MarkupCollectTypeOptional</a> is implied
MarkupCollectTypeTristate :: MarkupCollectType

-- | can be bitwise ORed with the other fields. If present, allows the
--   attribute not to appear. A default value is set depending on what
--   value type is used
MarkupCollectTypeOptional :: MarkupCollectType

-- | Catch-all for unknown values
AnotherMarkupCollectType :: Int -> MarkupCollectType

-- | Flags that affect the behaviour of the parser.
data MarkupParseFlags

-- | No special behaviour. Since: 2.74
MarkupParseFlagsDefaultFlags :: MarkupParseFlags

-- | flag you should not use
MarkupParseFlagsDoNotUseThisUnsupportedFlag :: MarkupParseFlags

-- | When this flag is set, CDATA marked sections are not passed literally
--   to the <i><tt>passthrough</tt></i> function of the parser. Instead,
--   the content of the section (without the <tt>&lt;![CDATA[</tt> and
--   <tt>]]&gt;</tt>) is passed to the <i><tt>text</tt></i> function. This
--   flag was added in GLib 2.12
MarkupParseFlagsTreatCdataAsText :: MarkupParseFlags

-- | Normally errors caught by GMarkup itself have line/column information
--   prefixed to them to let the caller know the location of the error.
--   When this flag is set the location information is also prefixed to
--   errors generated by the <a>MarkupParser</a> implementation functions
MarkupParseFlagsPrefixErrorPosition :: MarkupParseFlags

-- | Ignore (don't report) qualified attributes and tags, along with their
--   contents. A qualified attribute or tag is one that contains ':' in its
--   name (ie: is in another namespace). Since: 2.40.
MarkupParseFlagsIgnoreQualified :: MarkupParseFlags

-- | Catch-all for unknown values
AnotherMarkupParseFlags :: Int -> MarkupParseFlags

-- | Flags which modify individual options.
data OptionFlags

-- | No flags.
--   
--   <i>Since: 2.42</i>
OptionFlagsNone :: OptionFlags

-- | The option doesn't appear in <tt>--help</tt> output.
OptionFlagsHidden :: OptionFlags

-- | The option appears in the main section of the <tt>--help</tt> output,
--   even if it is defined in a group.
OptionFlagsInMain :: OptionFlags

-- | For options of the <a>OptionArgNone</a> kind, this flag indicates that
--   the sense of the option is reversed. i.e. <a>False</a> will be stored
--   into the argument rather than <a>True</a>.
OptionFlagsReverse :: OptionFlags

-- | For options of the <a>OptionArgCallback</a> kind, this flag indicates
--   that the callback does not take any argument (like a
--   <a>OptionArgNone</a> option). Since 2.8
OptionFlagsNoArg :: OptionFlags

-- | For options of the <a>OptionArgCallback</a> kind, this flag indicates
--   that the argument should be passed to the callback in the GLib
--   filename encoding rather than UTF-8. Since 2.8
OptionFlagsFilename :: OptionFlags

-- | For options of the <a>OptionArgCallback</a> kind, this flag indicates
--   that the argument supply is optional. If no argument is given then
--   data of <tt><i>GOptionParseFunc</i></tt> will be set to NULL. Since
--   2.8
OptionFlagsOptionalArg :: OptionFlags

-- | This flag turns off the automatic conflict resolution which prefixes
--   long option names with <tt>groupname-</tt> if there is a conflict.
--   This option should only be used in situations where aliasing is
--   necessary to model some legacy commandline interface. It is not safe
--   to use this option, unless all option groups are under your direct
--   control. Since 2.8.
OptionFlagsNoalias :: OptionFlags

-- | This flag marks the option as deprecated in the <tt>--help</tt>.
--   
--   You should update the description of the option to describe what the
--   user should do in response to the deprecation, for instance: remove
--   the option, or replace it with another one.
--   
--   <i>Since: 2.84</i>
OptionFlagsDeprecated :: OptionFlags

-- | Catch-all for unknown values
AnotherOptionFlags :: Int -> OptionFlags

-- | Flags specifying compile-time options.
--   
--   <i>Since: 2.14</i>
data RegexCompileFlags

-- | No special options set. Since: 2.74
RegexCompileFlagsDefault :: RegexCompileFlags

-- | Letters in the pattern match both upper- and lowercase letters. This
--   option can be changed within a pattern by a "(?i)" option setting.
RegexCompileFlagsCaseless :: RegexCompileFlags

-- | By default, GRegex treats the strings as consisting of a single line
--   of characters (even if it actually contains newlines). The "start of
--   line" metacharacter ("^") matches only at the start of the string,
--   while the "end of line" metacharacter ("$") matches only at the end of
--   the string, or before a terminating newline (unless
--   <a>RegexCompileFlagsDollarEndonly</a> is set). When
--   <a>RegexCompileFlagsMultiline</a> is set, the "start of line" and "end
--   of line" constructs match immediately following or immediately before
--   any newline in the string, respectively, as well as at the very start
--   and end. This can be changed within a pattern by a "(?m)" option
--   setting.
RegexCompileFlagsMultiline :: RegexCompileFlags

-- | A dot metacharacter (".") in the pattern matches all characters,
--   including newlines. Without it, newlines are excluded. This option can
--   be changed within a pattern by a ("?s") option setting.
RegexCompileFlagsDotall :: RegexCompileFlags

-- | Whitespace data characters in the pattern are totally ignored except
--   when escaped or inside a character class. Whitespace does not include
--   the VT character (code 11). In addition, characters between an
--   unescaped "#" outside a character class and the next newline
--   character, inclusive, are also ignored. This can be changed within a
--   pattern by a "(?x)" option setting.
RegexCompileFlagsExtended :: RegexCompileFlags

-- | The pattern is forced to be "anchored", that is, it is constrained to
--   match only at the first matching point in the string that is being
--   searched. This effect can also be achieved by appropriate constructs
--   in the pattern itself such as the "^" metacharacter.
RegexCompileFlagsAnchored :: RegexCompileFlags

-- | A dollar metacharacter ("$") in the pattern matches only at the end of
--   the string. Without this option, a dollar also matches immediately
--   before the final character if it is a newline (but not before any
--   other newlines). This option is ignored if
--   <a>RegexCompileFlagsMultiline</a> is set.
RegexCompileFlagsDollarEndonly :: RegexCompileFlags

-- | Inverts the "greediness" of the quantifiers so that they are not
--   greedy by default, but become greedy if followed by "?". It can also
--   be set by a "(?U)" option setting within the pattern.
RegexCompileFlagsUngreedy :: RegexCompileFlags

-- | Usually strings must be valid UTF-8 strings, using this flag they are
--   considered as a raw sequence of bytes.
RegexCompileFlagsRaw :: RegexCompileFlags

-- | Disables the use of numbered capturing parentheses in the pattern. Any
--   opening parenthesis that is not followed by "?" behaves as if it were
--   followed by "?:" but named parentheses can still be used for capturing
--   (and they acquire numbers in the usual way).
RegexCompileFlagsNoAutoCapture :: RegexCompileFlags

-- | Since 2.74 and the port to pcre2, requests JIT compilation, which, if
--   the just-in-time compiler is available, further processes a compiled
--   pattern into machine code that executes much faster. However, it comes
--   at the cost of extra processing before the match is performed, so it
--   is most beneficial to use this when the same compiled pattern is used
--   for matching many times. Before 2.74 this option used the built-in
--   non-JIT optimizations in pcre1.
RegexCompileFlagsOptimize :: RegexCompileFlags

-- | Limits an unanchored pattern to match before (or at) the first
--   newline. Since: 2.34
RegexCompileFlagsFirstline :: RegexCompileFlags

-- | Names used to identify capturing subpatterns need not be unique. This
--   can be helpful for certain types of pattern when it is known that only
--   one instance of the named subpattern can ever be matched.
RegexCompileFlagsDupnames :: RegexCompileFlags

-- | Usually any newline character or character sequence is recognized. If
--   this option is set, the only recognized newline character is '\r'.
RegexCompileFlagsNewlineCr :: RegexCompileFlags

-- | Usually any newline character or character sequence is recognized. If
--   this option is set, the only recognized newline character is '\n'.
RegexCompileFlagsNewlineLf :: RegexCompileFlags

-- | <i>No description available in the introspection data.</i>
RegexCompileFlagsNewlineReserved1 :: RegexCompileFlags

-- | Catch-all for unknown values
AnotherRegexCompileFlags :: Int -> RegexCompileFlags

-- | Flags specifying match-time options.
--   
--   <i>Since: 2.14</i>
data RegexMatchFlags

-- | No special options set. Since: 2.74
RegexMatchFlagsDefault :: RegexMatchFlags

-- | The pattern is forced to be "anchored", that is, it is constrained to
--   match only at the first matching point in the string that is being
--   searched. This effect can also be achieved by appropriate constructs
--   in the pattern itself such as the "^" metacharacter.
RegexMatchFlagsAnchored :: RegexMatchFlags

-- | Specifies that first character of the string is not the beginning of a
--   line, so the circumflex metacharacter should not match before it.
--   Setting this without <a>RegexCompileFlagsMultiline</a> (at compile
--   time) causes circumflex never to match. This option affects only the
--   behaviour of the circumflex metacharacter, it does not affect "\A".
RegexMatchFlagsNotbol :: RegexMatchFlags

-- | Specifies that the end of the subject string is not the end of a line,
--   so the dollar metacharacter should not match it nor (except in
--   multiline mode) a newline immediately before it. Setting this without
--   <a>RegexCompileFlagsMultiline</a> (at compile time) causes dollar
--   never to match. This option affects only the behaviour of the dollar
--   metacharacter, it does not affect "\Z" or "\z".
RegexMatchFlagsNoteol :: RegexMatchFlags

-- | An empty string is not considered to be a valid match if this option
--   is set. If there are alternatives in the pattern, they are tried. If
--   all the alternatives match the empty string, the entire match fails.
--   For example, if the pattern "a?b?" is applied to a string not
--   beginning with "a" or "b", it matches the empty string at the start of
--   the string. With this flag set, this match is not valid, so GRegex
--   searches further into the string for occurrences of "a" or "b".
RegexMatchFlagsNotempty :: RegexMatchFlags

-- | Turns on the partial matching feature, for more documentation on
--   partial matching see <a>matchInfoIsPartialMatch</a>.
RegexMatchFlagsPartial :: RegexMatchFlags

-- | Overrides the newline definition set when creating a new <a>Regex</a>,
--   setting the '\r' character as line terminator.
RegexMatchFlagsNewlineCr :: RegexMatchFlags

-- | Overrides the newline definition set when creating a new <a>Regex</a>,
--   setting the '\n' character as line terminator.
RegexMatchFlagsNewlineLf :: RegexMatchFlags

-- | Overrides the newline definition set when creating a new <a>Regex</a>,
--   setting the '\r\n' characters sequence as line terminator.
RegexMatchFlagsNewlineCrlf :: RegexMatchFlags

-- | Overrides the newline definition set when creating a new <a>Regex</a>,
--   any Unicode newline sequence is recognised as a newline. These are
--   '\r', '\n' and '\rn', and the single characters U+000B LINE
--   TABULATION, U+000C FORM FEED (FF), U+0085 NEXT LINE (NEL), U+2028 LINE
--   SEPARATOR and U+2029 PARAGRAPH SEPARATOR.
RegexMatchFlagsNewlineAny :: RegexMatchFlags

-- | Overrides the newline definition set when creating a new <a>Regex</a>;
--   any '\r', '\n', or '\r\n' character sequence is recognized as a
--   newline. Since: 2.34
RegexMatchFlagsNewlineAnycrlf :: RegexMatchFlags

-- | Overrides the newline definition for "\R" set when creating a new
--   <a>Regex</a>; only '\r', '\n', or '\r\n' character sequences are
--   recognized as a newline by "\R". Since: 2.34
RegexMatchFlagsBsrAnycrlf :: RegexMatchFlags

-- | Overrides the newline definition for "\R" set when creating a new
--   <a>Regex</a>; any Unicode newline character or character sequence are
--   recognized as a newline by "\R". These are '\r', '\n' and '\rn', and
--   the single characters U+000B LINE TABULATION, U+000C FORM FEED (FF),
--   U+0085 NEXT LINE (NEL), U+2028 LINE SEPARATOR and U+2029 PARAGRAPH
--   SEPARATOR. Since: 2.34
RegexMatchFlagsBsrAny :: RegexMatchFlags

-- | An alias for <a>RegexMatchFlagsPartial</a>. Since: 2.34
RegexMatchFlagsPartialSoft :: RegexMatchFlags

-- | Turns on the partial matching feature. In contrast to to
--   <a>RegexMatchFlagsPartialSoft</a>, this stops matching as soon as a
--   partial match is found, without continuing to search for a possible
--   complete match. See <a>matchInfoIsPartialMatch</a> for more
--   information. Since: 2.34
RegexMatchFlagsPartialHard :: RegexMatchFlags

-- | Like <a>RegexMatchFlagsNotempty</a>, but only applied to the start of
--   the matched string. For anchored patterns this can only happen for
--   pattern containing "\K". Since: 2.34
RegexMatchFlagsNotemptyAtstart :: RegexMatchFlags

-- | Catch-all for unknown values
AnotherRegexMatchFlags :: Int -> RegexMatchFlags

-- | Flags passed to <a>spawnSync</a>, <a>spawnAsync</a> and
--   <a>spawnAsyncWithPipes</a>.
data SpawnFlags

-- | no flags, default behaviour
SpawnFlagsDefault :: SpawnFlags

-- | the parent's open file descriptors will be inherited by the child;
--   otherwise all descriptors except stdin, stdout and stderr will be
--   closed before calling <tt><i>exec()</i></tt> in the child.
SpawnFlagsLeaveDescriptorsOpen :: SpawnFlags

-- | the child will not be automatically reaped; you must use
--   <tt><i>g_child_watch_add()</i></tt> yourself (or call
--   <tt><i>waitpid()</i></tt> or handle <tt>SIGCHLD</tt> yourself), or the
--   child will become a zombie.
SpawnFlagsDoNotReapChild :: SpawnFlags

-- | <tt>argv[0]</tt> need not be an absolute path, it will be looked for
--   in the user's <tt>PATH</tt>.
SpawnFlagsSearchPath :: SpawnFlags

-- | the child's standard output will be discarded, instead of going to the
--   same location as the parent's standard output.
SpawnFlagsStdoutToDevNull :: SpawnFlags

-- | the child's standard error will be discarded.
SpawnFlagsStderrToDevNull :: SpawnFlags

-- | the child will inherit the parent's standard input (by default, the
--   child's standard input is attached to <tt>/dev/null</tt>).
SpawnFlagsChildInheritsStdin :: SpawnFlags

-- | the first element of <tt>argv</tt> is the file to execute, while the
--   remaining elements are the actual argument vector to pass to the file.
--   Normally <a>spawnAsyncWithPipes</a> uses <tt>argv[0]</tt> as the file
--   to execute, and passes all of <tt>argv</tt> to the child.
SpawnFlagsFileAndArgvZero :: SpawnFlags

-- | if <tt>argv[0]</tt> is not an absolute path, it will be looked for in
--   the <tt>PATH</tt> from the passed child environment. Since: 2.34
SpawnFlagsSearchPathFromEnvp :: SpawnFlags

-- | create all pipes with the <tt>O_CLOEXEC</tt> flag set. Since: 2.40
SpawnFlagsCloexecPipes :: SpawnFlags

-- | The child will inherit the parent's standard output.
--   
--   <i>Since: 2.74</i>
SpawnFlagsChildInheritsStdout :: SpawnFlags

-- | The child will inherit the parent's standard error.
--   
--   <i>Since: 2.74</i>
SpawnFlagsChildInheritsStderr :: SpawnFlags

-- | The child's standard input is attached to <tt>/dev/null</tt>.
--   
--   <i>Since: 2.74</i>
SpawnFlagsStdinFromDevNull :: SpawnFlags

-- | Catch-all for unknown values
AnotherSpawnFlags :: Int -> SpawnFlags

-- | Flags to pass to <a>testTrapSubprocess</a> to control input and
--   output.
--   
--   Note that in contrast with <a>testTrapFork</a>, the default behavior
--   of <a>testTrapSubprocess</a> is to not show stdout and stderr.
data TestSubprocessFlags

-- | Default behaviour. Since: 2.74
TestSubprocessFlagsDefault :: TestSubprocessFlags

-- | If this flag is given, the child process will inherit the parent's
--   stdin. Otherwise, the child's stdin is redirected to
--   <tt>/dev/null</tt>.
TestSubprocessFlagsInheritStdin :: TestSubprocessFlags

-- | If this flag is given, the child process will inherit the parent's
--   stdout. Otherwise, the child's stdout will not be visible, but it will
--   be captured to allow later tests with
--   <tt><i>GLib.test_trap_assert_stdout</i></tt>.
TestSubprocessFlagsInheritStdout :: TestSubprocessFlags

-- | If this flag is given, the child process will inherit the parent's
--   stderr. Otherwise, the child's stderr will not be visible, but it will
--   be captured to allow later tests with
--   <tt><i>GLib.test_trap_assert_stderr</i></tt>.
TestSubprocessFlagsInheritStderr :: TestSubprocessFlags

-- | If this flag is given, the child process will inherit the parent’s
--   open file descriptors.
TestSubprocessFlagsInheritDescriptors :: TestSubprocessFlags

-- | Catch-all for unknown values
AnotherTestSubprocessFlags :: Int -> TestSubprocessFlags

-- | Flags to pass to <a>testTrapFork</a> to control input and output.
--   
--   Test traps are guards around forked tests. These flags determine what
--   traps to set.

-- | <i>Deprecated: (Since version 2.38)<tt>GTestTrapFlags</tt> is used
--   only with <a>testTrapFork</a>,which is deprecated. Its replacement,
--   <a>testTrapSubprocess</a>
--   uses[flags<i><tt>gLib</tt></i>.TestSubprocessFlags].</i>
data TestTrapFlags

-- | Default behaviour. Since: 2.74
TestTrapFlagsDefault :: TestTrapFlags

-- | Redirect stdout of the test child to <tt>/dev/null</tt> so it cannot
--   be observed on the console during test runs. The actual output is
--   still captured though to allow later tests with
--   <tt><i>g_test_trap_assert_stdout()</i></tt>.
TestTrapFlagsSilenceStdout :: TestTrapFlags

-- | Redirect stderr of the test child to <tt>/dev/null</tt> so it cannot
--   be observed on the console during test runs. The actual output is
--   still captured though to allow later tests with
--   <tt><i>g_test_trap_assert_stderr()</i></tt>.
TestTrapFlagsSilenceStderr :: TestTrapFlags

-- | If this flag is given, stdin of the child process is shared with stdin
--   of its parent process. It is redirected to <tt>/dev/null</tt>
--   otherwise.
TestTrapFlagsInheritStdin :: TestTrapFlags

-- | Catch-all for unknown values
AnotherTestTrapFlags :: Int -> TestTrapFlags

-- | Specifies which nodes are visited during several of the tree
--   functions, including <a>nodeTraverse</a> and
--   <tt><i>g_node_find()</i></tt>.
data TraverseFlags

-- | only leaf nodes should be visited. This name has been introduced in
--   2.6, for older version use <a>TraverseFlagsLeafs</a>.
TraverseFlagsLeaves :: TraverseFlags

-- | only non-leaf nodes should be visited. This name has been introduced
--   in 2.6, for older version use <a>TraverseFlagsNonLeafs</a>.
TraverseFlagsNonLeaves :: TraverseFlags

-- | all nodes should be visited.
TraverseFlagsAll :: TraverseFlags

-- | a mask of all traverse flags.
TraverseFlagsMask :: TraverseFlags

-- | identical to <a>TraverseFlagsLeaves</a>.
TraverseFlagsLeafs :: TraverseFlags

-- | identical to <a>TraverseFlagsNonLeaves</a>.
TraverseFlagsNonLeafs :: TraverseFlags

-- | Catch-all for unknown values
AnotherTraverseFlags :: Int -> TraverseFlags

-- | Flags that describe a URI.
--   
--   When parsing a URI, if you need to choose different flags based on the
--   type of URI, you can use <a>uriPeekScheme</a> on the URI string to
--   check the scheme first, and use that to decide what flags to parse it
--   with.
--   
--   <i>Since: 2.66</i>
data UriFlags

-- | No flags set.
UriFlagsNone :: UriFlags

-- | Parse the URI more relaxedly than the <a>RFC 3986</a> grammar
--   specifies, fixing up or ignoring common mistakes in URIs coming from
--   external sources. This is also needed for some obscure URI schemes
--   where <tt>;</tt> separates the host from the path. Don’t use this flag
--   unless you need to.
UriFlagsParseRelaxed :: UriFlags

-- | The userinfo field may contain a password, which will be separated
--   from the username by <tt>:</tt>.
UriFlagsHasPassword :: UriFlags

-- | The userinfo may contain additional authentication-related parameters,
--   which will be separated from the username and/or password by
--   <tt>;</tt>.
UriFlagsHasAuthParams :: UriFlags

-- | When parsing a URI, this indicates that <tt>%</tt>-encoded characters
--   in the userinfo, path, query, and fragment fields should not be
--   decoded. (And likewise the host field if <a>UriFlagsNonDns</a> is also
--   set.) When building a URI, it indicates that you have already
--   <tt>%</tt>-encoded the components, and so <a>Uri</a> should not do any
--   encoding itself.
UriFlagsEncoded :: UriFlags

-- | The host component should not be assumed to be a DNS hostname or IP
--   address (for example, for <tt>smb</tt> URIs with NetBIOS hostnames).
UriFlagsNonDns :: UriFlags

-- | Same as <a>UriFlagsEncoded</a>, for the query field only.
UriFlagsEncodedQuery :: UriFlags

-- | Same as <a>UriFlagsEncoded</a>, for the path only.
UriFlagsEncodedPath :: UriFlags

-- | Same as <a>UriFlagsEncoded</a>, for the fragment only.
UriFlagsEncodedFragment :: UriFlags

-- | A scheme-based normalization will be applied. For example, when
--   parsing an HTTP URI changing omitted path to <tt>/</tt> and omitted
--   port to <tt>80</tt>; and when building a URI, changing empty path to
--   <tt>/</tt> and default port <tt>80</tt>). This only supports a subset
--   of known schemes. (Since: 2.68)
UriFlagsSchemeNormalize :: UriFlags

-- | Catch-all for unknown values
AnotherUriFlags :: Int -> UriFlags

-- | Flags describing what parts of the URI to hide in
--   <a>uriToStringPartial</a>. Note that <a>UriHideFlagsPassword</a> and
--   <a>UriHideFlagsAuthParams</a> will only work if the <a>Uri</a> was
--   parsed with the corresponding flags.
--   
--   <i>Since: 2.66</i>
data UriHideFlags

-- | No flags set.
UriHideFlagsNone :: UriHideFlags

-- | Hide the userinfo.
UriHideFlagsUserinfo :: UriHideFlags

-- | Hide the password.
UriHideFlagsPassword :: UriHideFlags

-- | Hide the auth_params.
UriHideFlagsAuthParams :: UriHideFlags

-- | Hide the query.
UriHideFlagsQuery :: UriHideFlags

-- | Hide the fragment.
UriHideFlagsFragment :: UriHideFlags

-- | Catch-all for unknown values
AnotherUriHideFlags :: Int -> UriHideFlags

-- | Flags modifying the way parameters are handled by
--   <a>uriParseParams</a> and <a>UriParamsIter</a>.
--   
--   <i>Since: 2.66</i>
data UriParamsFlags

-- | No flags set.
UriParamsFlagsNone :: UriParamsFlags

-- | Parameter names are case insensitive.
UriParamsFlagsCaseInsensitive :: UriParamsFlags

-- | Replace <tt>+</tt> with space character. Only useful for URLs on the
--   web, using the <tt>https</tt> or <tt>http</tt> schemas.
UriParamsFlagsWwwForm :: UriParamsFlags

-- | See <a>UriFlagsParseRelaxed</a>.
UriParamsFlagsParseRelaxed :: UriParamsFlags

-- | Catch-all for unknown values
AnotherUriParamsFlags :: Int -> UriParamsFlags
instance Data.GI.Base.BasicTypes.BoxedFlags GI.GLib.Flags.IOCondition
instance GHC.Internal.Enum.Enum GI.GLib.Flags.AsciiType
instance GHC.Internal.Enum.Enum GI.GLib.Flags.FileSetContentsFlags
instance GHC.Internal.Enum.Enum GI.GLib.Flags.FileTest
instance GHC.Internal.Enum.Enum GI.GLib.Flags.FormatSizeFlags
instance GHC.Internal.Enum.Enum GI.GLib.Flags.HookFlagMask
instance GHC.Internal.Enum.Enum GI.GLib.Flags.IOCondition
instance GHC.Internal.Enum.Enum GI.GLib.Flags.IOFlags
instance GHC.Internal.Enum.Enum GI.GLib.Flags.KeyFileFlags
instance GHC.Internal.Enum.Enum GI.GLib.Flags.LogLevelFlags
instance GHC.Internal.Enum.Enum GI.GLib.Flags.MainContextFlags
instance GHC.Internal.Enum.Enum GI.GLib.Flags.MarkupCollectType
instance GHC.Internal.Enum.Enum GI.GLib.Flags.MarkupParseFlags
instance GHC.Internal.Enum.Enum GI.GLib.Flags.OptionFlags
instance GHC.Internal.Enum.Enum GI.GLib.Flags.RegexCompileFlags
instance GHC.Internal.Enum.Enum GI.GLib.Flags.RegexMatchFlags
instance GHC.Internal.Enum.Enum GI.GLib.Flags.SpawnFlags
instance GHC.Internal.Enum.Enum GI.GLib.Flags.TestSubprocessFlags
instance GHC.Internal.Enum.Enum GI.GLib.Flags.TestTrapFlags
instance GHC.Internal.Enum.Enum GI.GLib.Flags.TraverseFlags
instance GHC.Internal.Enum.Enum GI.GLib.Flags.UriFlags
instance GHC.Internal.Enum.Enum GI.GLib.Flags.UriHideFlags
instance GHC.Internal.Enum.Enum GI.GLib.Flags.UriParamsFlags
instance GHC.Classes.Eq GI.GLib.Flags.AsciiType
instance GHC.Classes.Eq GI.GLib.Flags.FileSetContentsFlags
instance GHC.Classes.Eq GI.GLib.Flags.FileTest
instance GHC.Classes.Eq GI.GLib.Flags.FormatSizeFlags
instance GHC.Classes.Eq GI.GLib.Flags.HookFlagMask
instance GHC.Classes.Eq GI.GLib.Flags.IOCondition
instance GHC.Classes.Eq GI.GLib.Flags.IOFlags
instance GHC.Classes.Eq GI.GLib.Flags.KeyFileFlags
instance GHC.Classes.Eq GI.GLib.Flags.LogLevelFlags
instance GHC.Classes.Eq GI.GLib.Flags.MainContextFlags
instance GHC.Classes.Eq GI.GLib.Flags.MarkupCollectType
instance GHC.Classes.Eq GI.GLib.Flags.MarkupParseFlags
instance GHC.Classes.Eq GI.GLib.Flags.OptionFlags
instance GHC.Classes.Eq GI.GLib.Flags.RegexCompileFlags
instance GHC.Classes.Eq GI.GLib.Flags.RegexMatchFlags
instance GHC.Classes.Eq GI.GLib.Flags.SpawnFlags
instance GHC.Classes.Eq GI.GLib.Flags.TestSubprocessFlags
instance GHC.Classes.Eq GI.GLib.Flags.TestTrapFlags
instance GHC.Classes.Eq GI.GLib.Flags.TraverseFlags
instance GHC.Classes.Eq GI.GLib.Flags.UriFlags
instance GHC.Classes.Eq GI.GLib.Flags.UriHideFlags
instance GHC.Classes.Eq GI.GLib.Flags.UriParamsFlags
instance Data.GI.Base.Overloading.HasParentTypes GI.GLib.Flags.IOCondition
instance Data.GI.Base.BasicTypes.IsGFlag GI.GLib.Flags.AsciiType
instance Data.GI.Base.BasicTypes.IsGFlag GI.GLib.Flags.FileSetContentsFlags
instance Data.GI.Base.BasicTypes.IsGFlag GI.GLib.Flags.FileTest
instance Data.GI.Base.BasicTypes.IsGFlag GI.GLib.Flags.FormatSizeFlags
instance Data.GI.Base.BasicTypes.IsGFlag GI.GLib.Flags.HookFlagMask
instance Data.GI.Base.BasicTypes.IsGFlag GI.GLib.Flags.IOCondition
instance Data.GI.Base.BasicTypes.IsGFlag GI.GLib.Flags.IOFlags
instance Data.GI.Base.BasicTypes.IsGFlag GI.GLib.Flags.KeyFileFlags
instance Data.GI.Base.BasicTypes.IsGFlag GI.GLib.Flags.LogLevelFlags
instance Data.GI.Base.BasicTypes.IsGFlag GI.GLib.Flags.MainContextFlags
instance Data.GI.Base.BasicTypes.IsGFlag GI.GLib.Flags.MarkupCollectType
instance Data.GI.Base.BasicTypes.IsGFlag GI.GLib.Flags.MarkupParseFlags
instance Data.GI.Base.BasicTypes.IsGFlag GI.GLib.Flags.OptionFlags
instance Data.GI.Base.BasicTypes.IsGFlag GI.GLib.Flags.RegexCompileFlags
instance Data.GI.Base.BasicTypes.IsGFlag GI.GLib.Flags.RegexMatchFlags
instance Data.GI.Base.BasicTypes.IsGFlag GI.GLib.Flags.SpawnFlags
instance Data.GI.Base.BasicTypes.IsGFlag GI.GLib.Flags.TestSubprocessFlags
instance Data.GI.Base.BasicTypes.IsGFlag GI.GLib.Flags.TestTrapFlags
instance Data.GI.Base.BasicTypes.IsGFlag GI.GLib.Flags.TraverseFlags
instance Data.GI.Base.BasicTypes.IsGFlag GI.GLib.Flags.UriFlags
instance Data.GI.Base.BasicTypes.IsGFlag GI.GLib.Flags.UriHideFlags
instance Data.GI.Base.BasicTypes.IsGFlag GI.GLib.Flags.UriParamsFlags
instance GHC.Classes.Ord GI.GLib.Flags.AsciiType
instance GHC.Classes.Ord GI.GLib.Flags.FileSetContentsFlags
instance GHC.Classes.Ord GI.GLib.Flags.FileTest
instance GHC.Classes.Ord GI.GLib.Flags.FormatSizeFlags
instance GHC.Classes.Ord GI.GLib.Flags.HookFlagMask
instance GHC.Classes.Ord GI.GLib.Flags.IOCondition
instance GHC.Classes.Ord GI.GLib.Flags.IOFlags
instance GHC.Classes.Ord GI.GLib.Flags.KeyFileFlags
instance GHC.Classes.Ord GI.GLib.Flags.LogLevelFlags
instance GHC.Classes.Ord GI.GLib.Flags.MainContextFlags
instance GHC.Classes.Ord GI.GLib.Flags.MarkupCollectType
instance GHC.Classes.Ord GI.GLib.Flags.MarkupParseFlags
instance GHC.Classes.Ord GI.GLib.Flags.OptionFlags
instance GHC.Classes.Ord GI.GLib.Flags.RegexCompileFlags
instance GHC.Classes.Ord GI.GLib.Flags.RegexMatchFlags
instance GHC.Classes.Ord GI.GLib.Flags.SpawnFlags
instance GHC.Classes.Ord GI.GLib.Flags.TestSubprocessFlags
instance GHC.Classes.Ord GI.GLib.Flags.TestTrapFlags
instance GHC.Classes.Ord GI.GLib.Flags.TraverseFlags
instance GHC.Classes.Ord GI.GLib.Flags.UriFlags
instance GHC.Classes.Ord GI.GLib.Flags.UriHideFlags
instance GHC.Classes.Ord GI.GLib.Flags.UriParamsFlags
instance GHC.Internal.Show.Show GI.GLib.Flags.AsciiType
instance GHC.Internal.Show.Show GI.GLib.Flags.FileSetContentsFlags
instance GHC.Internal.Show.Show GI.GLib.Flags.FileTest
instance GHC.Internal.Show.Show GI.GLib.Flags.FormatSizeFlags
instance GHC.Internal.Show.Show GI.GLib.Flags.HookFlagMask
instance GHC.Internal.Show.Show GI.GLib.Flags.IOCondition
instance GHC.Internal.Show.Show GI.GLib.Flags.IOFlags
instance GHC.Internal.Show.Show GI.GLib.Flags.KeyFileFlags
instance GHC.Internal.Show.Show GI.GLib.Flags.LogLevelFlags
instance GHC.Internal.Show.Show GI.GLib.Flags.MainContextFlags
instance GHC.Internal.Show.Show GI.GLib.Flags.MarkupCollectType
instance GHC.Internal.Show.Show GI.GLib.Flags.MarkupParseFlags
instance GHC.Internal.Show.Show GI.GLib.Flags.OptionFlags
instance GHC.Internal.Show.Show GI.GLib.Flags.RegexCompileFlags
instance GHC.Internal.Show.Show GI.GLib.Flags.RegexMatchFlags
instance GHC.Internal.Show.Show GI.GLib.Flags.SpawnFlags
instance GHC.Internal.Show.Show GI.GLib.Flags.TestSubprocessFlags
instance GHC.Internal.Show.Show GI.GLib.Flags.TestTrapFlags
instance GHC.Internal.Show.Show GI.GLib.Flags.TraverseFlags
instance GHC.Internal.Show.Show GI.GLib.Flags.UriFlags
instance GHC.Internal.Show.Show GI.GLib.Flags.UriHideFlags
instance GHC.Internal.Show.Show GI.GLib.Flags.UriParamsFlags
instance Data.GI.Base.BasicTypes.TypedObject GI.GLib.Flags.IOCondition


-- | <i>No description available in the introspection data.</i>
module GI.GLib.Structs.Allocator

-- | Memory-managed wrapper type.
newtype Allocator
Allocator :: ManagedPtr Allocator -> Allocator

-- | <i>No description available in the introspection data.</i>

-- | <i>Deprecated: (Since version 2.10)</i>
allocatorFree :: (HasCallStack, MonadIO m) => Allocator -> m ()
instance Data.GI.Base.BasicTypes.BoxedPtr GI.GLib.Structs.Allocator.Allocator
instance GHC.Classes.Eq GI.GLib.Structs.Allocator.Allocator
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GLib.Structs.Allocator.Allocator


-- | A simple reference counted data type representing an immutable
--   sequence of zero or more bytes from an unspecified origin.
--   
--   The purpose of a <tt>GBytes</tt> is to keep the memory region that it
--   holds alive for as long as anyone holds a reference to the bytes. When
--   the last reference count is dropped, the memory is released. Multiple
--   unrelated callers can use byte data in the <tt>GBytes</tt> without
--   coordinating their activities, resting assured that the byte data will
--   not change or move while they hold a reference.
--   
--   A <tt>GBytes</tt> can come from many different origins that may have
--   different procedures for freeing the memory region. Examples are
--   memory from <a>malloc</a>, from memory slices, from a
--   <a>MappedFile</a> or memory from other allocators.
--   
--   <tt>GBytes</tt> work well as keys in <a>GHashTable</a>. Use
--   <a>bytesEqual</a> and <a>bytesHash</a> as parameters to
--   <a>GHashTable</a>.<tt><i>new</i></tt>() or
--   <a>GHashTable</a>.<tt><i>new_full</i></tt>(). <tt>GBytes</tt> can also
--   be used as keys in a <a>Tree</a> by passing the <a>bytesCompare</a>
--   function to <a>Tree</a>.<tt><i>new</i></tt>().
--   
--   The data pointed to by this bytes must not be modified. For a mutable
--   array of bytes see <a>ByteArray</a>. Use <a>bytesUnrefToArray</a> to
--   create a mutable array for a <tt>GBytes</tt> sequence. To create an
--   immutable <tt>GBytes</tt> from a mutable <a>ByteArray</a>, use the
--   <a>byteArrayFreeToBytes</a> function.
--   
--   <i>Since: 2.32</i>
module GI.GLib.Structs.Bytes

-- | Memory-managed wrapper type.
newtype Bytes
Bytes :: ManagedPtr Bytes -> Bytes

-- | Compares the two <a>Bytes</a> values.
--   
--   This function can be used to sort <tt>GBytes</tt> instances in
--   lexicographical order.
--   
--   If <i><tt>bytes1</tt></i> and <i><tt>bytes2</tt></i> have different
--   length but the shorter one is a prefix of the longer one then the
--   shorter one is considered to be less than the longer one. Otherwise
--   the first byte where both differ is used for comparison. If
--   <i><tt>bytes1</tt></i> has a smaller value at that position it is
--   considered less, otherwise greater than <i><tt>bytes2</tt></i>.
--   
--   <i>Since: 2.32</i>
bytesCompare :: (HasCallStack, MonadIO m) => Bytes -> Bytes -> m Int32

-- | Compares the two <a>Bytes</a> values being pointed to and returns
--   <tt>TRUE</tt> if they are equal.
--   
--   This function can be passed to <a>GHashTable</a>.<tt><i>new</i></tt>()
--   as the <i><tt>keyEqualFunc</tt></i> parameter, when using
--   non-<tt>NULL</tt> <tt>GBytes</tt> pointers as keys in a
--   <a>GHashTable</a>.
--   
--   <i>Since: 2.32</i>
bytesEqual :: (HasCallStack, MonadIO m) => Bytes -> Bytes -> m Bool

-- | Get the byte data in the <a>Bytes</a>.
--   
--   This data should not be modified.
--   
--   This function will always return the same pointer for a given
--   <tt>GBytes</tt>.
--   
--   <tt>NULL</tt> may be returned if <i><tt>size</tt></i> is 0. This is
--   not guaranteed, as the <tt>GBytes</tt> may represent an empty string
--   with <i><tt>data</tt></i> non-<tt>NULL</tt> and <i><tt>size</tt></i>
--   as 0. <tt>NULL</tt> will not be returned if <i><tt>size</tt></i> is
--   non-zero.
--   
--   <i>Since: 2.32</i>
bytesGetData :: (HasCallStack, MonadIO m) => Bytes -> m (Maybe ByteString)

-- | Gets a pointer to a region in <i><tt>bytes</tt></i>.
--   
--   The region starts at <i><tt>offset</tt></i> many bytes from the start
--   of the data and contains <i><tt>nElements</tt></i> many elements of
--   <i><tt>elementSize</tt></i> size.
--   
--   <i><tt>nElements</tt></i> may be zero, but <i><tt>elementSize</tt></i>
--   must always be non-zero. Ideally, <i><tt>elementSize</tt></i> is a
--   static constant (eg: <tt>sizeof</tt> a struct).
--   
--   This function does careful bounds checking (including checking for
--   arithmetic overflows) and returns a non-<tt>NULL</tt> pointer if the
--   specified region lies entirely within the <i><tt>bytes</tt></i>. If
--   the region is in some way out of range, or if an overflow has
--   occurred, then <tt>NULL</tt> is returned.
--   
--   Note: it is possible to have a valid zero-size region. In this case,
--   the returned pointer will be equal to the base pointer of the data of
--   <i><tt>bytes</tt></i>, plus <i><tt>offset</tt></i>. This will be
--   non-<tt>NULL</tt> except for the case where <i><tt>bytes</tt></i>
--   itself was a zero-sized region. Since it is unlikely that you will be
--   using this function to check for a zero-sized region in a zero-sized
--   <i><tt>bytes</tt></i>, <tt>NULL</tt> effectively always means ‘error’.
--   
--   <i>Since: 2.70</i>
bytesGetRegion :: (HasCallStack, MonadIO m) => Bytes -> CSize -> CSize -> CSize -> m (Ptr ())

-- | Get the size of the byte data in the <a>Bytes</a>.
--   
--   This function will always return the same value for a given
--   <tt>GBytes</tt>.
--   
--   <i>Since: 2.32</i>
bytesGetSize :: (HasCallStack, MonadIO m) => Bytes -> m CSize

-- | Creates an integer hash code for the byte data in the <a>Bytes</a>.
--   
--   This function can be passed to <a>GHashTable</a>.<tt><i>new</i></tt>()
--   as the <i><tt>keyHashFunc</tt></i> parameter, when using
--   non-<tt>NULL</tt> <tt>GBytes</tt> pointers as keys in a
--   <a>GHashTable</a>.
--   
--   <i>Since: 2.32</i>
bytesHash :: (HasCallStack, MonadIO m) => Bytes -> m Word32

-- | Creates a new <a>Bytes</a> from <i><tt>data</tt></i>.
--   
--   <i><tt>data</tt></i> is copied. If <i><tt>size</tt></i> is 0,
--   <i><tt>data</tt></i> may be <tt>NULL</tt>.
--   
--   As an optimization, <a>bytesNew</a> may avoid an extra allocation by
--   copying the data within the resulting bytes structure if sufficiently
--   small (since GLib 2.84).
--   
--   <i>Since: 2.32</i>
bytesNew :: (HasCallStack, MonadIO m) => Maybe ByteString -> m Bytes

-- | Creates a <a>Bytes</a> which is a subsection of another
--   <tt>GBytes</tt>.
--   
--   The <i><tt>offset</tt></i> + <i><tt>length</tt></i> may not be longer
--   than the size of <i><tt>bytes</tt></i>.
--   
--   A reference to <i><tt>bytes</tt></i> will be held by the newly created
--   <tt>GBytes</tt> until the byte data is no longer needed.
--   
--   Since 2.56, if <i><tt>offset</tt></i> is 0 and <i><tt>length</tt></i>
--   matches the size of <i><tt>bytes</tt></i>, then <i><tt>bytes</tt></i>
--   will be returned with the reference count incremented by 1. If
--   <i><tt>bytes</tt></i> is a slice of another <tt>GBytes</tt>, then the
--   resulting <tt>GBytes</tt> will reference the same <tt>GBytes</tt>
--   instead of <i><tt>bytes</tt></i>. This allows consumers to simplify
--   the usage of <tt>GBytes</tt> when asynchronously writing to streams.
--   
--   <i>Since: 2.32</i>
bytesNewFromBytes :: (HasCallStack, MonadIO m) => Bytes -> CSize -> CSize -> m Bytes

-- | Creates a new <a>Bytes</a> from <i><tt>data</tt></i>.
--   
--   After this call, <i><tt>data</tt></i> belongs to the <tt>GBytes</tt>
--   and may no longer be modified by the caller. The memory of
--   <i><tt>data</tt></i> has to be dynamically allocated and will
--   eventually be freed with <a>free</a>.
--   
--   For creating <tt>GBytes</tt> with memory from other allocators, see
--   <a>Bytes</a>.<tt><i>new_with_free_func</i></tt>().
--   
--   <i><tt>data</tt></i> may be <tt>NULL</tt> if <i><tt>size</tt></i> is
--   0.
--   
--   <i>Since: 2.32</i>
bytesNewTake :: (HasCallStack, MonadIO m) => Maybe ByteString -> m Bytes

-- | Increase the reference count on <i><tt>bytes</tt></i>.
--   
--   <i>Since: 2.32</i>
bytesRef :: (HasCallStack, MonadIO m) => Bytes -> m Bytes

-- | Releases a reference on <i><tt>bytes</tt></i>.
--   
--   This may result in the bytes being freed. If <i><tt>bytes</tt></i> is
--   <tt>NULL</tt>, it will return immediately.
--   
--   <i>Since: 2.32</i>
bytesUnref :: (HasCallStack, MonadIO m) => Maybe Bytes -> m ()

-- | Unreferences the bytes, and returns a new mutable <a>ByteArray</a>
--   containing the same byte data.
--   
--   As an optimization, the byte data is transferred to the array without
--   copying if this was the last reference to <i><tt>bytes</tt></i> and
--   <i><tt>bytes</tt></i> was created with <a>bytesNew</a>,
--   <a>bytesNewTake</a> or <a>byteArrayFreeToBytes</a> and the buffer was
--   larger than the size <a>Bytes</a> may internalize within its
--   allocation. In all other cases the data is copied.
--   
--   Do not use it if <i><tt>bytes</tt></i> contains more than
--   <tt><i>G_MAXUINT</i></tt> bytes. <a>ByteArray</a> stores the length of
--   its data in <tt>guint</tt>, which may be shorter than <tt>gsize</tt>,
--   that <i><tt>bytes</tt></i> is using.
--   
--   <i>Since: 2.32</i>
bytesUnrefToArray :: (HasCallStack, MonadIO m) => Bytes -> m ByteString

-- | Unreferences the bytes, and returns a pointer the same byte data
--   contents.
--   
--   As an optimization, the byte data is returned without copying if this
--   was the last reference to <i><tt>bytes</tt></i> and
--   <i><tt>bytes</tt></i> was created with <a>bytesNew</a>,
--   <a>bytesNewTake</a> or <a>byteArrayFreeToBytes</a> and the buffer was
--   larger than the size <a>Bytes</a> may internalize within its
--   allocation. In all other cases the data is copied.
--   
--   <i>Since: 2.32</i>
bytesUnrefToData :: (HasCallStack, MonadIO m) => Bytes -> m ByteString
instance GHC.Classes.Eq GI.GLib.Structs.Bytes.Bytes
instance Data.GI.Base.BasicTypes.GBoxed GI.GLib.Structs.Bytes.Bytes
instance Data.GI.Base.Overloading.HasParentTypes GI.GLib.Structs.Bytes.Bytes
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.GLib.Structs.Bytes.Bytes)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GLib.Structs.Bytes.Bytes
instance Data.GI.Base.BasicTypes.TypedObject GI.GLib.Structs.Bytes.Bytes


-- | GLib provides a generic API for computing checksums (or ‘digests’) for
--   a sequence of arbitrary bytes, using various hashing algorithms like
--   MD5, SHA-1 and SHA-256. Checksums are commonly used in various
--   environments and specifications.
--   
--   To create a new <tt>GChecksum</tt>, use <a>checksumNew</a>. To free a
--   <tt>GChecksum</tt>, use <a>checksumFree</a>.
--   
--   GLib supports incremental checksums using the <tt>GChecksum</tt> data
--   structure, by calling <a>checksumUpdate</a> as long as there’s data
--   available and then using <a>checksumGetString</a> or
--   <a>Checksum</a>.<tt><i>get_digest</i></tt>() to compute the checksum
--   and return it either as a string in hexadecimal form, or as a raw
--   sequence of bytes. To compute the checksum for binary blobs and
--   nul-terminated strings in one go, use the convenience functions
--   <a>computeChecksumForData</a> and <a>computeChecksumForString</a>,
--   respectively.
--   
--   <i>Since: 2.16</i>
module GI.GLib.Structs.Checksum

-- | Memory-managed wrapper type.
newtype Checksum
Checksum :: ManagedPtr Checksum -> Checksum

-- | Copies a <a>Checksum</a>. If <i><tt>checksum</tt></i> has been closed,
--   by calling <a>checksumGetString</a> or
--   <tt><i>g_checksum_get_digest()</i></tt>, the copied checksum will be
--   closed as well.
--   
--   <i>Since: 2.16</i>
checksumCopy :: (HasCallStack, MonadIO m) => Checksum -> m Checksum

-- | Frees the memory allocated for <i><tt>checksum</tt></i>.
--   
--   <i>Since: 2.16</i>
checksumFree :: (HasCallStack, MonadIO m) => Checksum -> m ()

-- | Gets the digest as a hexadecimal string.
--   
--   Once this function has been called the <a>Checksum</a> can no longer
--   be updated with <a>checksumUpdate</a>.
--   
--   The hexadecimal characters will be lower case.
--   
--   <i>Since: 2.16</i>
checksumGetString :: (HasCallStack, MonadIO m) => Checksum -> m Text

-- | Creates a new <a>Checksum</a>, using the checksum algorithm
--   <i><tt>checksumType</tt></i>. If the <i><tt>checksumType</tt></i> is
--   not known, <a>Nothing</a> is returned. A <a>Checksum</a> can be used
--   to compute the checksum, or digest, of an arbitrary binary blob, using
--   different hashing algorithms.
--   
--   A <a>Checksum</a> works by feeding a binary blob through
--   <a>checksumUpdate</a> until there is data to be checked; the digest
--   can then be extracted using <a>checksumGetString</a>, which will
--   return the checksum as a hexadecimal string; or
--   <tt><i>g_checksum_get_digest()</i></tt>, which will return a vector of
--   raw bytes. Once either <a>checksumGetString</a> or
--   <tt><i>g_checksum_get_digest()</i></tt> have been called on a
--   <a>Checksum</a>, the checksum will be closed and it won't be possible
--   to call <a>checksumUpdate</a> on it anymore.
--   
--   <i>Since: 2.16</i>
checksumNew :: (HasCallStack, MonadIO m) => ChecksumType -> m (Maybe Checksum)

-- | Resets the state of the <i><tt>checksum</tt></i> back to its initial
--   state.
--   
--   <i>Since: 2.18</i>
checksumReset :: (HasCallStack, MonadIO m) => Checksum -> m ()

-- | Gets the length in bytes of digests of type
--   <i><tt>checksumType</tt></i>
--   
--   <i>Since: 2.16</i>
checksumTypeGetLength :: (HasCallStack, MonadIO m) => ChecksumType -> m Int64

-- | Feeds <i><tt>data</tt></i> into an existing <a>Checksum</a>. The
--   checksum must still be open, that is <a>checksumGetString</a> or
--   <tt><i>g_checksum_get_digest()</i></tt> must not have been called on
--   <i><tt>checksum</tt></i>.
--   
--   <i>Since: 2.16</i>
checksumUpdate :: (HasCallStack, MonadIO m) => Checksum -> ByteString -> m ()
instance GHC.Classes.Eq GI.GLib.Structs.Checksum.Checksum
instance Data.GI.Base.BasicTypes.GBoxed GI.GLib.Structs.Checksum.Checksum
instance Data.GI.Base.Overloading.HasParentTypes GI.GLib.Structs.Checksum.Checksum
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.GLib.Structs.Checksum.Checksum)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GLib.Structs.Checksum.Checksum
instance Data.GI.Base.BasicTypes.TypedObject GI.GLib.Structs.Checksum.Checksum


-- | An opaque data structure that represents a keyed data list.
--   
--   See also: <a>Keyed data lists</a>.
module GI.GLib.Structs.Data

-- | Memory-managed wrapper type.
newtype Data
Data :: ManagedPtr Data -> Data
instance Data.GI.Base.BasicTypes.BoxedPtr GI.GLib.Structs.Data.Data
instance GHC.Classes.Eq GI.GLib.Structs.Data.Data
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GLib.Structs.Data.Data


-- | Associates a string with a bit flag. Used in <a>parseDebugString</a>.
module GI.GLib.Structs.DebugKey

-- | Memory-managed wrapper type.
newtype DebugKey
DebugKey :: ManagedPtr DebugKey -> DebugKey

-- | Construct a <a>DebugKey</a> struct initialized to zero.
newZeroDebugKey :: MonadIO m => m DebugKey

-- | Set the value of the “<tt>key</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #key
--   </pre>
clearDebugKeyKey :: MonadIO m => DebugKey -> m ()

-- | Get the value of the “<tt>key</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> debugKey #key
--   </pre>
getDebugKeyKey :: MonadIO m => DebugKey -> m (Maybe Text)

-- | Set the value of the “<tt>key</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> debugKey [ #key <a>:=</a> value ]
--   </pre>
setDebugKeyKey :: MonadIO m => DebugKey -> CString -> m ()

-- | Get the value of the “<tt>value</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> debugKey #value
--   </pre>
getDebugKeyValue :: MonadIO m => DebugKey -> m Word32

-- | Set the value of the “<tt>value</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> debugKey [ #value <a>:=</a> value ]
--   </pre>
setDebugKeyValue :: MonadIO m => DebugKey -> Word32 -> m ()
instance Data.GI.Base.BasicTypes.BoxedPtr GI.GLib.Structs.DebugKey.DebugKey
instance Data.GI.Base.BasicTypes.CallocPtr GI.GLib.Structs.DebugKey.DebugKey
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.GLib.Structs.DebugKey.DebugKey tag
instance GHC.Classes.Eq GI.GLib.Structs.DebugKey.DebugKey
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GLib.Structs.DebugKey.DebugKey


-- | An opaque structure representing an opened directory.
module GI.GLib.Structs.Dir

-- | Memory-managed wrapper type.
newtype Dir
Dir :: ManagedPtr Dir -> Dir

-- | Closes the directory immediately and decrements the reference count.
--   
--   Once the reference count reaches zero, the <tt>GDir</tt> structure
--   itself will be freed. Prior to GLib 2.80, <tt>GDir</tt> was not
--   reference counted.
--   
--   It is an error to call any of the <tt>GDir</tt> methods other than
--   <a>dirRef</a> and <a>dirUnref</a> on a <tt>GDir</tt> after calling
--   <a>dirClose</a> on it.
dirClose :: (HasCallStack, MonadIO m) => Dir -> m ()

-- | Creates a subdirectory in the preferred directory for temporary files
--   (as returned by <a>getTmpDir</a>).
--   
--   <i><tt>tmpl</tt></i> should be a string in the GLib file name encoding
--   containing a sequence of six 'X' characters, as the parameter to
--   <tt><i>g_mkstemp()</i></tt>. However, unlike these functions, the
--   template should only be a basename, no directory components are
--   allowed. If template is <a>Nothing</a>, a default template is used.
--   
--   Note that in contrast to <tt><i>g_mkdtemp()</i></tt> (and
--   <tt><i>mkdtemp()</i></tt>) <i><tt>tmpl</tt></i> is not modified, and
--   might thus be a read-only literal string.
--   
--   <i>Since: 2.30</i>
dirMakeTmp :: (HasCallStack, MonadIO m) => Maybe [Char] -> m [Char]

-- | Opens a directory for reading. The names of the files in the directory
--   can then be retrieved using <a>dirReadName</a>. Note that the ordering
--   is not defined.
dirOpen :: (HasCallStack, MonadIO m) => Text -> Word32 -> m Dir

-- | Retrieves the name of another entry in the directory, or
--   <a>Nothing</a>. The order of entries returned from this function is
--   not defined, and may vary by file system or other operating-system
--   dependent factors.
--   
--   <a>Nothing</a> may also be returned in case of errors. On Unix, you
--   can check <tt>errno</tt> to find out if <a>Nothing</a> was returned
--   because of an error.
--   
--   On Unix, the '.' and '..' entries are omitted, and the returned name
--   is in the on-disk encoding.
--   
--   On Windows, as is true of all GLib functions which operate on
--   filenames, the returned name is in UTF-8.
dirReadName :: (HasCallStack, MonadIO m) => Dir -> m [Char]

-- | Increment the reference count of <tt>dir</tt>.
--   
--   <i>Since: 2.80</i>
dirRef :: (HasCallStack, MonadIO m) => Dir -> m Dir

-- | Resets the given directory. The next call to <a>dirReadName</a> will
--   return the first entry again.
dirRewind :: (HasCallStack, MonadIO m) => Dir -> m ()

-- | Decrements the reference count of <tt>dir</tt>.
--   
--   Once the reference count reaches zero, the directory will be closed
--   and all resources associated with it will be freed. If <a>dirClose</a>
--   is called when the reference count is greater than zero, the directory
--   is closed but the <tt>GDir</tt> structure will not be freed until its
--   reference count reaches zero.
--   
--   It is an error to call any of the <tt>GDir</tt> methods other than
--   <a>dirRef</a> and <a>dirUnref</a> on a <tt>GDir</tt> after calling
--   <a>dirClose</a> on it.
--   
--   <i>Since: 2.80</i>
dirUnref :: (HasCallStack, MonadIO m) => Dir -> m ()
instance GHC.Classes.Eq GI.GLib.Structs.Dir.Dir
instance Data.GI.Base.BasicTypes.GBoxed GI.GLib.Structs.Dir.Dir
instance Data.GI.Base.Overloading.HasParentTypes GI.GLib.Structs.Dir.Dir
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.GLib.Structs.Dir.Dir)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GLib.Structs.Dir.Dir
instance Data.GI.Base.BasicTypes.TypedObject GI.GLib.Structs.Dir.Dir


-- | A GHashTableIter structure represents an iterator that can be used to
--   iterate over the elements of a <a>HashTable</a>. GHashTableIter
--   structures are typically allocated on the stack and then initialized
--   with <a>hashTableIterInit</a>.
--   
--   The iteration order of a <a>HashTableIter</a> over the keys/values in
--   a hash table is not defined.
module GI.GLib.Structs.HashTableIter

-- | Memory-managed wrapper type.
newtype HashTableIter
HashTableIter :: ManagedPtr HashTableIter -> HashTableIter

-- | Construct a <a>HashTableIter</a> struct initialized to zero.
newZeroHashTableIter :: MonadIO m => m HashTableIter

-- | Returns the <a>HashTable</a> associated with <i><tt>iter</tt></i>.
--   
--   <i>Since: 2.16</i>
hashTableIterGetHashTable :: (HasCallStack, MonadIO m) => HashTableIter -> m (Map (Ptr ()) (Ptr ()))

-- | Initializes a key/value pair iterator and associates it with
--   <i><tt>hashTable</tt></i>. Modifying the hash table after calling this
--   function invalidates the returned iterator.
--   
--   The iteration order of a <a>HashTableIter</a> over the keys/values in
--   a hash table is not defined.
--   
--   <h3><i>C code</i></h3>
--   
--   <pre>
--   GHashTableIter iter;
--   gpointer key, value;
--   
--   g_hash_table_iter_init (&amp;iter, hash_table);
--   while (g_hash_table_iter_next (&amp;iter, &amp;key, &amp;value))
--     {
--       // do something with key and value
--     }
--   </pre>
--   
--   <i>Since: 2.16</i>
hashTableIterInit :: (HasCallStack, MonadIO m) => HashTableIter -> Map (Ptr ()) (Ptr ()) -> m ()

-- | Advances <i><tt>iter</tt></i> and retrieves the key and/or value that
--   are now pointed to as a result of this advancement. If <a>False</a> is
--   returned, <i><tt>key</tt></i> and <i><tt>value</tt></i> are not set,
--   and the iterator becomes invalid.
--   
--   <i>Since: 2.16</i>
hashTableIterNext :: (HasCallStack, MonadIO m) => HashTableIter -> m (Bool, Ptr (), Ptr ())

-- | Removes the key/value pair currently pointed to by the iterator from
--   its associated <a>HashTable</a>. Can only be called after
--   <a>hashTableIterNext</a> returned <a>True</a>, and cannot be called
--   more than once for the same key/value pair.
--   
--   If the <a>HashTable</a> was created using
--   <tt><i>g_hash_table_new_full()</i></tt>, the key and value are freed
--   using the supplied destroy functions, otherwise you have to make sure
--   that any dynamically allocated values are freed yourself.
--   
--   It is safe to continue iterating the <a>HashTable</a> afterward:
--   
--   <h3><i>C code</i></h3>
--   
--   <pre>
--   while (g_hash_table_iter_next (&amp;iter, &amp;key, &amp;value))
--     {
--       if (condition)
--         g_hash_table_iter_remove (&amp;iter);
--     }
--   </pre>
--   
--   <i>Since: 2.16</i>
hashTableIterRemove :: (HasCallStack, MonadIO m) => HashTableIter -> m ()

-- | Replaces the value currently pointed to by the iterator from its
--   associated <a>HashTable</a>. Can only be called after
--   <a>hashTableIterNext</a> returned <a>True</a>.
--   
--   If you supplied a <i><tt>valueDestroyFunc</tt></i> when creating the
--   <a>HashTable</a>, the old value is freed using that function.
--   
--   <i>Since: 2.30</i>
hashTableIterReplace :: (HasCallStack, MonadIO m) => HashTableIter -> Ptr () -> m ()

-- | Removes the key/value pair currently pointed to by the iterator from
--   its associated <a>HashTable</a>, without calling the key and value
--   destroy functions. Can only be called after <a>hashTableIterNext</a>
--   returned <a>True</a>, and cannot be called more than once for the same
--   key/value pair.
--   
--   <i>Since: 2.16</i>
hashTableIterSteal :: (HasCallStack, MonadIO m) => HashTableIter -> m ()
instance Data.GI.Base.BasicTypes.BoxedPtr GI.GLib.Structs.HashTableIter.HashTableIter
instance Data.GI.Base.BasicTypes.CallocPtr GI.GLib.Structs.HashTableIter.HashTableIter
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.GLib.Structs.HashTableIter.HashTableIter tag
instance GHC.Classes.Eq GI.GLib.Structs.HashTableIter.HashTableIter
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GLib.Structs.HashTableIter.HashTableIter


-- | HMACs should be used when producing a cookie or hash based on data and
--   a key. Simple mechanisms for using SHA1 and other algorithms to digest
--   a key and data together are vulnerable to various security issues.
--   <a>HMAC</a> uses algorithms like SHA1 in a secure way to produce a
--   digest of a key and data.
--   
--   Both the key and data are arbitrary byte arrays of bytes or
--   characters.
--   
--   Support for HMAC Digests has been added in GLib 2.30, and support for
--   SHA-512 in GLib 2.42. Support for SHA-384 was added in GLib 2.52.
--   
--   To create a new <tt>GHmac</tt>, use <a>hmacNew</a>. To free a
--   <tt>GHmac</tt>, use <a>hmacUnref</a>.
--   
--   <i>Since: 2.30</i>
module GI.GLib.Structs.Hmac

-- | Memory-managed wrapper type.
newtype Hmac
Hmac :: ManagedPtr Hmac -> Hmac

-- | Copies a <a>Hmac</a>. If <i><tt>hmac</tt></i> has been closed, by
--   calling <a>hmacGetString</a> or <a>hmacGetDigest</a>, the copied HMAC
--   will be closed as well.
--   
--   <i>Since: 2.30</i>
hmacCopy :: (HasCallStack, MonadIO m) => Hmac -> m Hmac

-- | Gets the digest from <i><tt>checksum</tt></i> as a raw binary array
--   and places it into <i><tt>buffer</tt></i>. The size of the digest
--   depends on the type of checksum.
--   
--   Once this function has been called, the <a>Hmac</a> is closed and can
--   no longer be updated with <a>checksumUpdate</a>.
--   
--   <i>Since: 2.30</i>
hmacGetDigest :: (HasCallStack, MonadIO m) => Hmac -> ByteString -> m ()

-- | Gets the HMAC as a hexadecimal string.
--   
--   Once this function has been called the <a>Hmac</a> can no longer be
--   updated with <a>hmacUpdate</a>.
--   
--   The hexadecimal characters will be lower case.
--   
--   <i>Since: 2.30</i>
hmacGetString :: (HasCallStack, MonadIO m) => Hmac -> m Text

-- | Creates a new <a>Hmac</a>, using the digest algorithm
--   <i><tt>digestType</tt></i>. If the <i><tt>digestType</tt></i> is not
--   known, <a>Nothing</a> is returned. A <a>Hmac</a> can be used to
--   compute the HMAC of a key and an arbitrary binary blob, using
--   different hashing algorithms.
--   
--   A <a>Hmac</a> works by feeding a binary blob through <a>hmacUpdate</a>
--   until the data is complete; the digest can then be extracted using
--   <a>hmacGetString</a>, which will return the checksum as a hexadecimal
--   string; or <a>hmacGetDigest</a>, which will return a array of raw
--   bytes. Once either <a>hmacGetString</a> or <a>hmacGetDigest</a> have
--   been called on a <a>Hmac</a>, the HMAC will be closed and it won't be
--   possible to call <a>hmacUpdate</a> on it anymore.
--   
--   Support for digests of type <a>ChecksumTypeSha512</a> has been added
--   in GLib 2.42. Support for <a>ChecksumTypeSha384</a> was added in GLib
--   2.52.
--   
--   <i>Since: 2.30</i>
hmacNew :: (HasCallStack, MonadIO m) => ChecksumType -> ByteString -> m (Maybe Hmac)

-- | Atomically increments the reference count of <i><tt>hmac</tt></i> by
--   one.
--   
--   This function is MT-safe and may be called from any thread.
--   
--   <i>Since: 2.30</i>
hmacRef :: (HasCallStack, MonadIO m) => Hmac -> m Hmac

-- | Atomically decrements the reference count of <i><tt>hmac</tt></i> by
--   one.
--   
--   If the reference count drops to 0, all keys and values will be
--   destroyed, and all memory allocated by the hash table is released.
--   This function is MT-safe and may be called from any thread. Frees the
--   memory allocated for <i><tt>hmac</tt></i>.
--   
--   <i>Since: 2.30</i>
hmacUnref :: (HasCallStack, MonadIO m) => Hmac -> m ()

-- | Feeds <i><tt>data</tt></i> into an existing <a>Hmac</a>.
--   
--   The HMAC must still be open, that is <a>hmacGetString</a> or
--   <a>hmacGetDigest</a> must not have been called on
--   <i><tt>hmac</tt></i>.
--   
--   <i>Since: 2.30</i>
hmacUpdate :: (HasCallStack, MonadIO m) => Hmac -> ByteString -> m ()
instance GHC.Classes.Eq GI.GLib.Structs.Hmac.Hmac
instance Data.GI.Base.BasicTypes.GBoxed GI.GLib.Structs.Hmac.Hmac
instance Data.GI.Base.Overloading.HasParentTypes GI.GLib.Structs.Hmac.Hmac
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.GLib.Structs.Hmac.Hmac)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GLib.Structs.Hmac.Hmac
instance Data.GI.Base.BasicTypes.TypedObject GI.GLib.Structs.Hmac.Hmac


-- | The <tt>GIOChannel</tt> data type aims to provide a portable method
--   for using file descriptors, pipes, and sockets, and integrating them
--   into the main event loop (see <a>MainContext</a>). Currently, full
--   support is available on UNIX platforms; support for Windows is only
--   partially complete.
--   
--   To create a new <tt>GIOChannel</tt> on UNIX systems use
--   <a>iOChannelUnixNew</a>. This works for plain file descriptors, pipes
--   and sockets. Alternatively, a channel can be created for a file in a
--   system independent manner using <a>iOChannelNewFile</a>.
--   
--   Once a <tt>GIOChannel</tt> has been created, it can be used in a
--   generic manner with the functions <a>iOChannelReadChars</a>,
--   <a>iOChannelWriteChars</a>, <a>iOChannelSeekPosition</a>, and
--   <a>iOChannelShutdown</a>.
--   
--   To add a <tt>GIOChannel</tt> to the main event loop, use
--   <a>ioAddWatch</a> or <tt><i>GLib.io_add_watch_full</i></tt>. Here you
--   specify which events you are interested in on the <tt>GIOChannel</tt>,
--   and provide a function to be called whenever these events occur.
--   
--   <tt>GIOChannel</tt> instances are created with an initial reference
--   count of 1. <a>iOChannelRef</a> and <a>iOChannelUnref</a> can be used
--   to increment or decrement the reference count respectively. When the
--   reference count falls to 0, the <tt>GIOChannel</tt> is freed. (Though
--   it isn’t closed automatically, unless it was created using
--   <a>iOChannelNewFile</a>.) Using <a>ioAddWatch</a> or
--   <tt><i>GLib.io_add_watch_full</i></tt> increments a channel’s
--   reference count.
--   
--   The new functions <a>iOChannelReadChars</a>, <a>iOChannelReadLine</a>,
--   <a>IOChannel</a>.<tt><i>read_line_string</i></tt>(),
--   <a>iOChannelReadToEnd</a>, <a>iOChannelWriteChars</a>,
--   <a>iOChannelSeekPosition</a>, and <a>iOChannelFlush</a> should not be
--   mixed with the deprecated functions <a>iOChannelRead</a>,
--   <a>iOChannelWrite</a>, and <a>iOChannelSeek</a> on the same channel.
module GI.GLib.Structs.IOChannel

-- | Memory-managed wrapper type.
newtype IOChannel
IOChannel :: ManagedPtr IOChannel -> IOChannel

-- | Construct a <a>IOChannel</a> struct initialized to zero.
newZeroIOChannel :: MonadIO m => m IOChannel

-- | Close an IO channel. Any pending data to be written will be flushed,
--   ignoring errors. The channel will not be freed until the last
--   reference is dropped using <a>iOChannelUnref</a>.

-- | <i>Deprecated: (Since version 2.2)Use <a>iOChannelShutdown</a>
--   instead.</i>
iOChannelClose :: (HasCallStack, MonadIO m) => IOChannel -> m ()

-- | Converts an <tt>errno</tt> error number to a <a>IOChannelError</a>.
iOChannelErrorFromErrno :: (HasCallStack, MonadIO m) => Int32 -> m IOChannelError

-- | <i>No description available in the introspection data.</i>
iOChannelErrorQuark :: (HasCallStack, MonadIO m) => m Word32

-- | Flushes the write buffer for the GIOChannel.
iOChannelFlush :: (HasCallStack, MonadIO m) => IOChannel -> m IOStatus

-- | This function returns a <a>IOCondition</a> depending on whether there
--   is data to be read/space to write data in the internal buffers in the
--   <a>IOChannel</a>. Only the flags <a>IOConditionIn</a> and
--   <a>IOConditionOut</a> may be set.
iOChannelGetBufferCondition :: (HasCallStack, MonadIO m) => IOChannel -> m [IOCondition]

-- | Gets the buffer size.
iOChannelGetBufferSize :: (HasCallStack, MonadIO m) => IOChannel -> m CSize

-- | Returns whether <i><tt>channel</tt></i> is buffered.
iOChannelGetBuffered :: (HasCallStack, MonadIO m) => IOChannel -> m Bool

-- | Returns whether the file/socket/whatever associated with
--   <i><tt>channel</tt></i> will be closed when <i><tt>channel</tt></i>
--   receives its final unref and is destroyed. The default value of this
--   is <a>True</a> for channels created by g_io_channel_new_file (), and
--   <a>False</a> for all other channels.
iOChannelGetCloseOnUnref :: (HasCallStack, MonadIO m) => IOChannel -> m Bool

-- | Gets the encoding for the input/output of the channel. The internal
--   encoding is always UTF-8. The encoding <a>Nothing</a> makes the
--   channel safe for binary data.
iOChannelGetEncoding :: (HasCallStack, MonadIO m) => IOChannel -> m Text

-- | Gets the current flags for a <a>IOChannel</a>, including read-only
--   flags such as <a>IOFlagsIsReadable</a>.
--   
--   The values of the flags <a>IOFlagsIsReadable</a> and
--   <a>IOFlagsIsWritable</a> are cached for internal use by the channel
--   when it is created. If they should change at some later point (e.g.
--   partial shutdown of a socket with the UNIX <tt><i>shutdown()</i></tt>
--   function), the user should immediately call <a>iOChannelGetFlags</a>
--   to update the internal values of these flags.
iOChannelGetFlags :: (HasCallStack, MonadIO m) => IOChannel -> m [IOFlags]

-- | This returns the string that <a>IOChannel</a> uses to determine where
--   in the file a line break occurs. A value of <a>Nothing</a> indicates
--   autodetection. Since 2.84, the return value is always nul-terminated.
iOChannelGetLineTerm :: (HasCallStack, MonadIO m) => IOChannel -> m (Text, Int32)

-- | Initializes a <a>IOChannel</a> struct.
--   
--   This is called by each of the above functions when creating a
--   <a>IOChannel</a>, and so is not often needed by the application
--   programmer (unless you are creating a new type of <a>IOChannel</a>).
iOChannelInit :: (HasCallStack, MonadIO m) => IOChannel -> m ()

-- | Open a file <i><tt>filename</tt></i> as a <a>IOChannel</a> using mode
--   <i><tt>mode</tt></i>. This channel will be closed when the last
--   reference to it is dropped, so there is no need to call
--   <a>iOChannelClose</a> (though doing so will not cause problems, as
--   long as no attempt is made to access the channel after it is closed).
iOChannelNewFile :: (HasCallStack, MonadIO m) => [Char] -> Text -> m IOChannel

-- | Reads data from a <a>IOChannel</a>.

-- | <i>Deprecated: (Since version 2.2)Use <a>iOChannelReadChars</a>
--   instead.</i>
iOChannelRead :: (HasCallStack, MonadIO m) => IOChannel -> Text -> CSize -> CSize -> m IOError

-- | Replacement for <a>iOChannelRead</a> with the new API.
iOChannelReadChars :: (HasCallStack, MonadIO m) => IOChannel -> ByteString -> m (IOStatus, ByteString, CSize)

-- | Reads a line, including the terminating character(s), from a
--   <a>IOChannel</a> into a newly-allocated string.
--   <i><tt>strReturn</tt></i> will contain allocated memory if the return
--   is <a>IOStatusNormal</a>.
iOChannelReadLine :: (HasCallStack, MonadIO m) => IOChannel -> m (IOStatus, Text, CSize, CSize)

-- | Reads all the remaining data from the file.
iOChannelReadToEnd :: (HasCallStack, MonadIO m) => IOChannel -> m (IOStatus, ByteString)

-- | Reads a Unicode character from <i><tt>channel</tt></i>. This function
--   cannot be called on a channel with <a>Nothing</a> encoding.
iOChannelReadUnichar :: (HasCallStack, MonadIO m) => IOChannel -> m (IOStatus, Char)

-- | Increments the reference count of a <a>IOChannel</a>.
iOChannelRef :: (HasCallStack, MonadIO m) => IOChannel -> m IOChannel

-- | Sets the current position in the <a>IOChannel</a>, similar to the
--   standard library function <tt><i>fseek()</i></tt>.

-- | <i>Deprecated: (Since version 2.2)Use <a>iOChannelSeekPosition</a>
--   instead.</i>
iOChannelSeek :: (HasCallStack, MonadIO m) => IOChannel -> Int64 -> SeekType -> m IOError

-- | Replacement for <a>iOChannelSeek</a> with the new API.
iOChannelSeekPosition :: (HasCallStack, MonadIO m) => IOChannel -> Int64 -> SeekType -> m IOStatus

-- | Sets the buffer size.
iOChannelSetBufferSize :: (HasCallStack, MonadIO m) => IOChannel -> CSize -> m ()

-- | The buffering state can only be set if the channel's encoding is
--   <a>Nothing</a>. For any other encoding, the channel must be buffered.
--   
--   A buffered channel can only be set unbuffered if the channel's
--   internal buffers have been flushed. Newly created channels or channels
--   which have returned <a>IOStatusEof</a> not require such a flush. For
--   write-only channels, a call to g_io_channel_flush () is sufficient.
--   For all other channels, the buffers may be flushed by a call to
--   g_io_channel_seek_position (). This includes the possibility of
--   seeking with seek type <a>SeekTypeCur</a> and an offset of zero. Note
--   that this means that socket-based channels cannot be set unbuffered
--   once they have had data read from them.
--   
--   On unbuffered channels, it is safe to mix read and write calls from
--   the new and old APIs, if this is necessary for maintaining old code.
--   
--   The default state of the channel is buffered.
iOChannelSetBuffered :: (HasCallStack, MonadIO m) => IOChannel -> Bool -> m ()

-- | Whether to close the channel on the final unref of the
--   <a>IOChannel</a> data structure. The default value of this is
--   <a>True</a> for channels created by g_io_channel_new_file (), and
--   <a>False</a> for all other channels.
--   
--   Setting this flag to <a>True</a> for a channel you have already closed
--   can cause problems when the final reference to the <a>IOChannel</a> is
--   dropped.
iOChannelSetCloseOnUnref :: (HasCallStack, MonadIO m) => IOChannel -> Bool -> m ()

-- | Sets the encoding for the input/output of the channel. The internal
--   encoding is always UTF-8. The default encoding for the external file
--   is UTF-8.
--   
--   The encoding <a>Nothing</a> is safe to use with binary data.
--   
--   The encoding can only be set if one of the following conditions is
--   true:
--   
--   <ul>
--   <li>The channel was just created, and has not been written to or read
--   from yet.</li>
--   <li>The channel is write-only.</li>
--   <li>The channel is a file, and the file pointer was just repositioned
--   by a call to <a>iOChannelSeekPosition</a>. (This flushes all the
--   internal buffers.)</li>
--   <li>The current encoding is <a>Nothing</a> or UTF-8.</li>
--   <li>One of the (new API) read functions has just returned
--   <a>IOStatusEof</a> (or, in the case of <a>iOChannelReadToEnd</a>,
--   <a>IOStatusNormal</a>).</li>
--   <li>One of the functions <a>iOChannelReadChars</a> or
--   <a>iOChannelReadUnichar</a> has returned <a>IOStatusAgain</a> or
--   <a>IOStatusError</a>. This may be useful in the case of
--   <a>ConvertErrorIllegalSequence</a>. Returning one of these statuses
--   from <a>iOChannelReadLine</a>,
--   <tt><i>g_io_channel_read_line_string()</i></tt>, or
--   <a>iOChannelReadToEnd</a> does not guarantee that the encoding can be
--   changed.</li>
--   </ul>
--   
--   Channels which do not meet one of the above conditions cannot call
--   <a>iOChannelSeekPosition</a> with an offset of <a>SeekTypeCur</a>,
--   and, if they are "seekable", cannot call <a>iOChannelWriteChars</a>
--   after calling one of the API "read" functions.
iOChannelSetEncoding :: (HasCallStack, MonadIO m) => IOChannel -> Maybe Text -> m IOStatus

-- | Sets the (writeable) flags in <i><tt>channel</tt></i> to
--   (<i><tt>flags</tt></i> &amp; <a>IOFlagsSetMask</a>).
iOChannelSetFlags :: (HasCallStack, MonadIO m) => IOChannel -> [IOFlags] -> m IOStatus

-- | This sets the string that <a>IOChannel</a> uses to determine where in
--   the file a line break occurs.
iOChannelSetLineTerm :: (HasCallStack, MonadIO m) => IOChannel -> Maybe Text -> Int32 -> m ()

-- | Close an IO channel. Any pending data to be written will be flushed if
--   <i><tt>flush</tt></i> is <a>True</a>. The channel will not be freed
--   until the last reference is dropped using <a>iOChannelUnref</a>.
iOChannelShutdown :: (HasCallStack, MonadIO m) => IOChannel -> Bool -> m IOStatus

-- | Returns the file descriptor of the <a>IOChannel</a>.
--   
--   On Windows this function returns the file descriptor or socket of the
--   <a>IOChannel</a>.
iOChannelUnixGetFd :: (HasCallStack, MonadIO m) => IOChannel -> m Int32

-- | Creates a new <a>IOChannel</a> given a file descriptor. On UNIX
--   systems this works for plain files, pipes, and sockets.
--   
--   The returned <a>IOChannel</a> has a reference count of 1.
--   
--   The default encoding for <a>IOChannel</a> is UTF-8. If your
--   application is reading output from a command using via pipe, you may
--   need to set the encoding to the encoding of the current locale (see
--   <a>getCharset</a>) with the <a>iOChannelSetEncoding</a> function. By
--   default, the fd passed will not be closed when the final reference to
--   the <a>IOChannel</a> data structure is dropped.
--   
--   If you want to read raw binary data without interpretation, then call
--   the <a>iOChannelSetEncoding</a> function with <a>Nothing</a> for the
--   encoding argument.
--   
--   This function is available in GLib on Windows, too, but you should
--   avoid using it on Windows. The domain of file descriptors and sockets
--   overlap. There is no way for GLib to know which one you mean in case
--   the argument you pass to this function happens to be both a valid file
--   descriptor and socket. If that happens a warning is issued, and GLib
--   assumes that it is the file descriptor you mean.
iOChannelUnixNew :: (HasCallStack, MonadIO m) => Int32 -> m IOChannel

-- | Decrements the reference count of a <a>IOChannel</a>.
iOChannelUnref :: (HasCallStack, MonadIO m) => IOChannel -> m ()

-- | Writes data to a <a>IOChannel</a>.

-- | <i>Deprecated: (Since version 2.2)Use <a>iOChannelWriteChars</a>
--   instead.</i>
iOChannelWrite :: (HasCallStack, MonadIO m) => IOChannel -> Text -> CSize -> CSize -> m IOError

-- | Replacement for <a>iOChannelWrite</a> with the new API.
--   
--   On seekable channels with encodings other than <a>Nothing</a> or
--   UTF-8, generic mixing of reading and writing is not allowed. A call to
--   g_io_channel_write_chars () may only be made on a channel from which
--   data has been read in the cases described in the documentation for
--   g_io_channel_set_encoding ().
iOChannelWriteChars :: (HasCallStack, MonadIO m) => IOChannel -> Ptr Word8 -> Int64 -> m (IOStatus, CSize)

-- | Writes a Unicode character to <i><tt>channel</tt></i>. This function
--   cannot be called on a channel with <a>Nothing</a> encoding.
iOChannelWriteUnichar :: (HasCallStack, MonadIO m) => IOChannel -> Char -> m IOStatus
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.GLib.Structs.IOChannel.IOChannel tag
instance GHC.Classes.Eq GI.GLib.Structs.IOChannel.IOChannel
instance Data.GI.Base.BasicTypes.GBoxed GI.GLib.Structs.IOChannel.IOChannel
instance Data.GI.Base.Overloading.HasParentTypes GI.GLib.Structs.IOChannel.IOChannel
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.GLib.Structs.IOChannel.IOChannel)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GLib.Structs.IOChannel.IOChannel
instance Data.GI.Base.BasicTypes.TypedObject GI.GLib.Structs.IOChannel.IOChannel


-- | <tt>GKeyFile</tt> parses .ini-like config files.
--   
--   <tt>GKeyFile</tt> lets you parse, edit or create files containing
--   groups of key-value pairs, which we call ‘key files’ for lack of a
--   better name. Several freedesktop.org specifications use key files. For
--   example, the <a>Desktop Entry Specification</a> and the <a>Icon Theme
--   Specification</a>.
--   
--   The syntax of key files is described in detail in the <a>Desktop Entry
--   Specification</a>, here is a quick summary: Key files consists of
--   groups of key-value pairs, interspersed with comments.
--   
--   <h3><i>txt code</i></h3>
--   
--   <pre>
--   # this is just an example
--   # there can be comments before the first group
--   
--   [First Group]
--   
--   Name=Key File Example\tthis value shows\nescaping
--   
--   # localized strings are stored in multiple key-value pairs
--   Welcome=Hello
--   Welcome[de]=Hallo
--   Welcome[fr_FR]=Bonjour
--   Welcome[it]=Ciao
--   
--   [Another Group]
--   
--   Numbers=2;20;-200;0
--   
--   Booleans=true;false;true;true
--   </pre>
--   
--   Lines beginning with a <tt>#</tt> and blank lines are considered
--   comments.
--   
--   Groups are started by a header line containing the group name enclosed
--   in <tt>[</tt> and <tt>]</tt>, and ended implicitly by the start of the
--   next group or the end of the file. Each key-value pair must be
--   contained in a group.
--   
--   Key-value pairs generally have the form <tt>key=value</tt>, with the
--   exception of localized strings, which have the form
--   <tt>key[locale]=value</tt>, with a locale identifier of the form
--   <tt>lang_COUNTRY@MODIFIER</tt> where <tt>COUNTRY</tt> and
--   <tt>MODIFIER</tt> are optional. As a special case, the locale
--   <tt>C</tt> is associated with the untranslated pair <tt>key=value</tt>
--   (since GLib 2.84). Space before and after the <tt>=</tt> character is
--   ignored. Newline, tab, carriage return and backslash characters in
--   value are escaped as <tt>\n</tt>, <tt>\t</tt>, <tt>\r</tt>, and
--   <tt>\\\\</tt>, respectively. To preserve leading spaces in values,
--   these can also be escaped as <tt>\s</tt>.
--   
--   Key files can store strings (possibly with localized variants),
--   integers, booleans and lists of these. Lists are separated by a
--   separator character, typically <tt>;</tt> or <tt>,</tt>. To use the
--   list separator character in a value in a list, it has to be escaped by
--   prefixing it with a backslash.
--   
--   This syntax is obviously inspired by the .ini files commonly met on
--   Windows, but there are some important differences:
--   
--   <ul>
--   <li>.ini files use the <tt>;</tt> character to begin comments, key
--   files use the <tt>#</tt> character.</li>
--   <li>Key files do not allow for ungrouped keys meaning only comments
--   can precede the first group.</li>
--   <li>Key files are always encoded in UTF-8.</li>
--   <li>Key and Group names are case-sensitive. For example, a group
--   called <tt>[GROUP]</tt> is a different from <tt>[group]</tt>.</li>
--   <li>.ini files don’t have a strongly typed boolean entry type, they
--   only have <tt>GetProfileInt()</tt>. In key files, only <tt>true</tt>
--   and <tt>false</tt> (in lower case) are allowed.</li>
--   </ul>
--   
--   Note that in contrast to the <a>Desktop Entry Specification</a>,
--   groups in key files may contain the same key multiple times; the last
--   entry wins. Key files may also contain multiple groups with the same
--   name; they are merged together. Another difference is that keys and
--   group names in key files are not restricted to ASCII characters.
--   
--   Here is an example of loading a key file and reading a value:
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   g_autoptr(GError) error = NULL;
--   g_autoptr(GKeyFile) key_file = g_key_file_new ();
--   
--   if (!g_key_file_load_from_file (key_file, "key-file.ini", flags, &amp;error))
--     {
--       if (!g_error_matches (error, G_FILE_ERROR, G_FILE_ERROR_NOENT))
--         g_warning ("Error loading key file: %s", error-&gt;message);
--       return;
--     }
--   
--   g_autofree gchar *val = g_key_file_get_string (key_file, "Group Name", "SomeKey", &amp;error);
--   if (val == NULL &amp;&amp;
--       !g_error_matches (error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_KEY_NOT_FOUND))
--     {
--       g_warning ("Error finding key in key file: %s", error-&gt;message);
--       return;
--     }
--   else if (val == NULL)
--     {
--       // Fall back to a default value.
--       val = g_strdup ("default-value");
--     }
--   </pre>
--   
--   Here is an example of creating and saving a key file:
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   g_autoptr(GKeyFile) key_file = g_key_file_new ();
--   const gchar *val = …;
--   g_autoptr(GError) error = NULL;
--   
--   g_key_file_set_string (key_file, "Group Name", "SomeKey", val);
--   
--   // Save as a file.
--   if (!g_key_file_save_to_file (key_file, "key-file.ini", &amp;error))
--     {
--       g_warning ("Error saving key file: %s", error-&gt;message);
--       return;
--     }
--   
--   // Or store to a GBytes for use elsewhere.
--   gsize data_len;
--   g_autofree guint8 *data = (guint8 *) g_key_file_to_data (key_file, &amp;data_len, &amp;error);
--   if (data == NULL)
--     {
--       g_warning ("Error saving key file: %s", error-&gt;message);
--       return;
--     }
--   g_autoptr(GBytes) bytes = g_bytes_new_take (g_steal_pointer (&amp;data), data_len);
--   </pre>
module GI.GLib.Structs.KeyFile

-- | Memory-managed wrapper type.
newtype KeyFile
KeyFile :: ManagedPtr KeyFile -> KeyFile

-- | <i>No description available in the introspection data.</i>
keyFileErrorQuark :: (HasCallStack, MonadIO m) => m Word32

-- | Returns the value associated with <i><tt>key</tt></i> under
--   <i><tt>groupName</tt></i> as a boolean.
--   
--   If <i><tt>key</tt></i> cannot be found then
--   [error<i><tt>gLib</tt></i>.KeyFileError.KEY_NOT_FOUND] is returned.
--   Likewise, if the value associated with <i><tt>key</tt></i> cannot be
--   interpreted as a boolean then
--   [error<i><tt>gLib</tt></i>.KeyFileError.INVALID_VALUE] is returned.
--   
--   <i>Since: 2.6</i>
keyFileGetBoolean :: (HasCallStack, MonadIO m) => KeyFile -> Text -> Text -> m ()

-- | Returns the values associated with <i><tt>key</tt></i> under
--   <i><tt>groupName</tt></i> as booleans.
--   
--   If <i><tt>key</tt></i> cannot be found then
--   [error<i><tt>gLib</tt></i>.KeyFileError.KEY_NOT_FOUND] is returned.
--   Likewise, if the values associated with <i><tt>key</tt></i> cannot be
--   interpreted as booleans then
--   [error<i><tt>gLib</tt></i>.KeyFileError.INVALID_VALUE] is returned.
--   
--   <i>Since: 2.6</i>
keyFileGetBooleanList :: (HasCallStack, MonadIO m) => KeyFile -> Text -> Text -> m [Bool]

-- | Retrieves a comment above <i><tt>key</tt></i> from
--   <i><tt>groupName</tt></i>.
--   
--   If <i><tt>key</tt></i> is <tt>NULL</tt> then <i><tt>comment</tt></i>
--   will be read from above <i><tt>groupName</tt></i>. If both
--   <i><tt>key</tt></i> and <i><tt>groupName</tt></i> are <tt>NULL</tt>,
--   then <i><tt>comment</tt></i> will be read from above the first group
--   in the file.
--   
--   Note that the returned string does not include the <tt>#</tt> comment
--   markers, but does include any whitespace after them (on each line). It
--   includes the line breaks between lines, but does not include the final
--   line break.
--   
--   <i>Since: 2.6</i>
keyFileGetComment :: (HasCallStack, MonadIO m) => KeyFile -> Maybe Text -> Maybe Text -> m Text

-- | Returns the value associated with <i><tt>key</tt></i> under
--   <i><tt>groupName</tt></i> as a double.
--   
--   If <i><tt>key</tt></i> cannot be found then
--   [error<i><tt>gLib</tt></i>.KeyFileError.KEY_NOT_FOUND] is returned.
--   Likewise, if the value associated with <i><tt>key</tt></i> cannot be
--   interpreted as a double then
--   [error<i><tt>gLib</tt></i>.KeyFileError.INVALID_VALUE] is returned.
--   
--   <i>Since: 2.12</i>
keyFileGetDouble :: (HasCallStack, MonadIO m) => KeyFile -> Text -> Text -> m Double

-- | Returns the values associated with <i><tt>key</tt></i> under
--   <i><tt>groupName</tt></i> as doubles.
--   
--   If <i><tt>key</tt></i> cannot be found then
--   [error<i><tt>gLib</tt></i>.KeyFileError.KEY_NOT_FOUND] is returned.
--   Likewise, if the values associated with <i><tt>key</tt></i> cannot be
--   interpreted as doubles then
--   [error<i><tt>gLib</tt></i>.KeyFileError.INVALID_VALUE] is returned.
--   
--   <i>Since: 2.12</i>
keyFileGetDoubleList :: (HasCallStack, MonadIO m) => KeyFile -> Text -> Text -> m [Double]

-- | Returns all groups in the key file loaded with
--   <i><tt>keyFile</tt></i>.
--   
--   The array of returned groups will be <tt>NULL</tt>-terminated, so
--   <i><tt>length</tt></i> may optionally be <tt>NULL</tt>.
--   
--   <i>Since: 2.6</i>
keyFileGetGroups :: (HasCallStack, MonadIO m) => KeyFile -> m ([Text], CSize)

-- | Returns the value associated with <i><tt>key</tt></i> under
--   <i><tt>groupName</tt></i> as a signed 64-bit integer.
--   
--   This is similar to <a>keyFileGetInteger</a> but can return 64-bit
--   results without truncation.
--   
--   <i>Since: 2.26</i>
keyFileGetInt64 :: (HasCallStack, MonadIO m) => KeyFile -> Text -> Text -> m Int64

-- | Returns the value associated with <i><tt>key</tt></i> under
--   <i><tt>groupName</tt></i> as an integer.
--   
--   If <i><tt>key</tt></i> cannot be found then
--   [error<i><tt>gLib</tt></i>.KeyFileError.KEY_NOT_FOUND] is returned.
--   Likewise, if the value associated with <i><tt>key</tt></i> cannot be
--   interpreted as an integer, or is out of range for a <tt>gint</tt>,
--   then [error<i><tt>gLib</tt></i>.KeyFileError.INVALID_VALUE] is
--   returned.
--   
--   <i>Since: 2.6</i>
keyFileGetInteger :: (HasCallStack, MonadIO m) => KeyFile -> Text -> Text -> m Int32

-- | Returns the values associated with <i><tt>key</tt></i> under
--   <i><tt>groupName</tt></i> as integers.
--   
--   If <i><tt>key</tt></i> cannot be found then
--   [error<i><tt>gLib</tt></i>.KeyFileError.KEY_NOT_FOUND] is returned.
--   Likewise, if the values associated with <i><tt>key</tt></i> cannot be
--   interpreted as integers, or are out of range for <tt>gint</tt>, then
--   [error<i><tt>gLib</tt></i>.KeyFileError.INVALID_VALUE] is returned.
--   
--   <i>Since: 2.6</i>
keyFileGetIntegerList :: (HasCallStack, MonadIO m) => KeyFile -> Text -> Text -> m [Int32]

-- | Returns all keys for the group name <i><tt>groupName</tt></i>.
--   
--   The array of returned keys will be <tt>NULL</tt>-terminated, so
--   <i><tt>length</tt></i> may optionally be <tt>NULL</tt>. If the
--   <i><tt>groupName</tt></i> cannot be found,
--   [error<i><tt>gLib</tt></i>.KeyFileError.GROUP_NOT_FOUND] is returned.
--   
--   <i>Since: 2.6</i>
keyFileGetKeys :: (HasCallStack, MonadIO m) => KeyFile -> Text -> m ([Text], CSize)

-- | Returns the actual locale which the result of
--   <a>keyFileGetLocaleString</a> or <a>keyFileGetLocaleStringList</a>
--   came from.
--   
--   If calling <a>keyFileGetLocaleString</a> or
--   <a>keyFileGetLocaleStringList</a> with exactly the same
--   <i><tt>keyFile</tt></i>, <i><tt>groupName</tt></i>,
--   <i><tt>key</tt></i> and <i><tt>locale</tt></i>, the result of those
--   functions will have originally been tagged with the locale that is the
--   result of this function.
--   
--   <i>Since: 2.56</i>
keyFileGetLocaleForKey :: (HasCallStack, MonadIO m) => KeyFile -> Text -> Text -> Maybe Text -> m (Maybe Text)

-- | Returns the value associated with <i><tt>key</tt></i> under
--   <i><tt>groupName</tt></i> translated in the given
--   <i><tt>locale</tt></i> if available.
--   
--   If <i><tt>locale</tt></i> is <tt>C</tt> then the untranslated value is
--   returned (since GLib 2.84).
--   
--   If <i><tt>locale</tt></i> is <tt>NULL</tt> then the current locale is
--   assumed.
--   
--   If <i><tt>locale</tt></i> is to be non-<tt>NULL</tt>, or if the
--   current locale will change over the lifetime of the <a>KeyFile</a>, it
--   must be loaded with
--   [flags<i><tt>gLib</tt></i>.KeyFileFlags.KEEP_TRANSLATIONS] in order to
--   load strings for all locales.
--   
--   If <i><tt>key</tt></i> cannot be found then
--   [error<i><tt>gLib</tt></i>.KeyFileError.KEY_NOT_FOUND] is returned. If
--   the value associated with <i><tt>key</tt></i> cannot be interpreted or
--   no suitable translation can be found then the untranslated value is
--   returned.
--   
--   <i>Since: 2.6</i>
keyFileGetLocaleString :: (HasCallStack, MonadIO m) => KeyFile -> Text -> Text -> Maybe Text -> m Text

-- | Returns the values associated with <i><tt>key</tt></i> under
--   <i><tt>groupName</tt></i> translated in the given
--   <i><tt>locale</tt></i> if available.
--   
--   If <i><tt>locale</tt></i> is <tt>C</tt> then the untranslated value is
--   returned (since GLib 2.84).
--   
--   If <i><tt>locale</tt></i> is <tt>NULL</tt> then the current locale is
--   assumed.
--   
--   If <i><tt>locale</tt></i> is to be non-<tt>NULL</tt>, or if the
--   current locale will change over the lifetime of the <a>KeyFile</a>, it
--   must be loaded with
--   [flags<i><tt>gLib</tt></i>.KeyFileFlags.KEEP_TRANSLATIONS] in order to
--   load strings for all locales.
--   
--   If <i><tt>key</tt></i> cannot be found then
--   [error<i><tt>gLib</tt></i>.KeyFileError.KEY_NOT_FOUND] is returned. If
--   the values associated with <i><tt>key</tt></i> cannot be interpreted
--   or no suitable translations can be found then the untranslated values
--   are returned. The returned array is <tt>NULL</tt>-terminated, so
--   <i><tt>length</tt></i> may optionally be <tt>NULL</tt>.
--   
--   <i>Since: 2.6</i>
keyFileGetLocaleStringList :: (HasCallStack, MonadIO m) => KeyFile -> Text -> Text -> Maybe Text -> m ([Text], CSize)

-- | Returns the name of the start group of the file.
--   
--   <i>Since: 2.6</i>
keyFileGetStartGroup :: (HasCallStack, MonadIO m) => KeyFile -> m (Maybe Text)

-- | Returns the string value associated with <i><tt>key</tt></i> under
--   <i><tt>groupName</tt></i>.
--   
--   Unlike <a>keyFileGetValue</a>, this function handles escape sequences
--   like <tt>\s</tt>.
--   
--   If the key cannot be found,
--   [error<i><tt>gLib</tt></i>.KeyFileError.KEY_NOT_FOUND] is returned. If
--   the <i><tt>groupName</tt></i> cannot be found,
--   [error<i><tt>gLib</tt></i>.KeyFileError.GROUP_NOT_FOUND] is returned.
--   
--   <i>Since: 2.6</i>
keyFileGetString :: (HasCallStack, MonadIO m) => KeyFile -> Text -> Text -> m Text

-- | Returns the values associated with <i><tt>key</tt></i> under
--   <i><tt>groupName</tt></i>.
--   
--   If the key cannot be found,
--   [error<i><tt>gLib</tt></i>.KeyFileError.KEY_NOT_FOUND] is returned. If
--   the <i><tt>groupName</tt></i> cannot be found,
--   [error<i><tt>gLib</tt></i>.KeyFileError.GROUP_NOT_FOUND] is returned.
--   
--   <i>Since: 2.6</i>
keyFileGetStringList :: (HasCallStack, MonadIO m) => KeyFile -> Text -> Text -> m ([Text], CSize)

-- | Returns the value associated with <i><tt>key</tt></i> under
--   <i><tt>groupName</tt></i> as an unsigned 64-bit integer.
--   
--   This is similar to <a>keyFileGetInteger</a> but can return large
--   positive results without truncation.
--   
--   <i>Since: 2.26</i>
keyFileGetUint64 :: (HasCallStack, MonadIO m) => KeyFile -> Text -> Text -> m Word64

-- | Returns the raw value associated with <i><tt>key</tt></i> under
--   <i><tt>groupName</tt></i>.
--   
--   Use <a>keyFileGetString</a> to retrieve an unescaped UTF-8 string.
--   
--   If the key cannot be found,
--   [error<i><tt>gLib</tt></i>.KeyFileError.KEY_NOT_FOUND] is returned. If
--   the <i><tt>groupName</tt></i> cannot be found,
--   [error<i><tt>gLib</tt></i>.KeyFileError.GROUP_NOT_FOUND] is returned.
--   
--   <i>Since: 2.6</i>
keyFileGetValue :: (HasCallStack, MonadIO m) => KeyFile -> Text -> Text -> m Text

-- | Looks whether the key file has the group <i><tt>groupName</tt></i>.
--   
--   <i>Since: 2.6</i>
keyFileHasGroup :: (HasCallStack, MonadIO m) => KeyFile -> Text -> m Bool

-- | Loads a key file from the data in <i><tt>bytes</tt></i> into an empty
--   <a>KeyFile</a> structure.
--   
--   If the object cannot be created then a
--   [error<i><tt>gLib</tt></i>.KeyFileError] is returned.
--   
--   <i>Since: 2.50</i>
keyFileLoadFromBytes :: (HasCallStack, MonadIO m) => KeyFile -> Bytes -> [KeyFileFlags] -> m ()

-- | Loads a key file from memory into an empty <a>KeyFile</a> structure.
--   
--   If the object cannot be created then a
--   [error<i><tt>gLib</tt></i>.KeyFileError is returned.
--   
--   <i>Since: 2.6</i>
keyFileLoadFromData :: (HasCallStack, MonadIO m) => KeyFile -> Text -> CSize -> [KeyFileFlags] -> m ()

-- | Looks for a key file named <i><tt>file</tt></i> in the paths returned
--   from <a>getUserDataDir</a> and <a>getSystemDataDirs</a>.
--   
--   The search algorithm from <a>keyFileLoadFromDirs</a> is used. If
--   <i><tt>file</tt></i> is found, it’s loaded into
--   <i><tt>keyFile</tt></i> and its full path is returned in
--   <i><tt>fullPath</tt></i>.
--   
--   If the file could not be loaded then either a
--   [error<i><tt>gLib</tt></i>.FileError] or
--   [error<i><tt>gLib</tt></i>.KeyFileError] is returned.
--   
--   <i>Since: 2.6</i>
keyFileLoadFromDataDirs :: (HasCallStack, MonadIO m) => KeyFile -> [Char] -> [KeyFileFlags] -> m [Char]

-- | Looks for a key file named <i><tt>file</tt></i> in the paths specified
--   in <i><tt>searchDirs</tt></i>, loads the file into
--   <i><tt>keyFile</tt></i> and returns the file’s full path in
--   <i><tt>fullPath</tt></i>.
--   
--   <i><tt>searchDirs</tt></i> are checked in the order listed in the
--   array, with the highest priority directory listed first. Within each
--   directory, <i><tt>file</tt></i> is looked for. If it’s not found,
--   <tt>-</tt> characters in <i><tt>file</tt></i> are progressively
--   replaced with directory separators to search subdirectories of the
--   search directory. If the file has not been found after all <tt>-</tt>
--   characters have been replaced, the next search directory in
--   <i><tt>searchDirs</tt></i> is checked.
--   
--   If the file could not be found in any of the
--   <i><tt>searchDirs</tt></i>,
--   [error<i><tt>gLib</tt></i>.KeyFileError.NOT_FOUND] is returned. If the
--   file is found but the OS returns an error when opening or reading the
--   file, a [error<i><tt>gLib</tt></i>.FileError] is returned. If there is
--   a problem parsing the file, a [error<i><tt>gLib</tt></i>.KeyFileError]
--   is returned.
--   
--   <i>Since: 2.14</i>
keyFileLoadFromDirs :: (HasCallStack, MonadIO m) => KeyFile -> [Char] -> [[Char]] -> [KeyFileFlags] -> m [Char]

-- | Loads a key file into an empty <a>KeyFile</a> structure.
--   
--   If the OS returns an error when opening or reading the file, a
--   [error<i><tt>gLib</tt></i>.FileError] is returned. If there is a
--   problem parsing the file, a [error<i><tt>gLib</tt></i>.KeyFileError]
--   is returned.
--   
--   This function will never return a
--   [error<i><tt>gLib</tt></i>.KeyFileError.NOT_FOUND] error. If the
--   <i><tt>file</tt></i> is not found,
--   [error<i><tt>gLib</tt></i>.FileError.NOENT] is returned.
--   
--   <i>Since: 2.6</i>
keyFileLoadFromFile :: (HasCallStack, MonadIO m) => KeyFile -> [Char] -> [KeyFileFlags] -> m ()

-- | Creates a new empty <a>KeyFile</a> object.
--   
--   Use <a>keyFileLoadFromFile</a>, <a>keyFileLoadFromData</a>,
--   <a>keyFileLoadFromDirs</a> or <a>keyFileLoadFromDataDirs</a> to read
--   an existing key file.
--   
--   <i>Since: 2.6</i>
keyFileNew :: (HasCallStack, MonadIO m) => m KeyFile

-- | Removes a comment above <i><tt>key</tt></i> from
--   <i><tt>groupName</tt></i>.
--   
--   If <i><tt>key</tt></i> is <tt>NULL</tt> then <i><tt>comment</tt></i>
--   will be removed above <i><tt>groupName</tt></i>. If both
--   <i><tt>key</tt></i> and <i><tt>groupName</tt></i> are <tt>NULL</tt>,
--   then <i><tt>comment</tt></i> will be removed above the first group in
--   the file.
--   
--   <i>Since: 2.6</i>
keyFileRemoveComment :: (HasCallStack, MonadIO m) => KeyFile -> Maybe Text -> Maybe Text -> m ()

-- | Removes the specified group, <i><tt>groupName</tt></i>, from the key
--   file.
--   
--   <i>Since: 2.6</i>
keyFileRemoveGroup :: (HasCallStack, MonadIO m) => KeyFile -> Text -> m ()

-- | Removes <i><tt>key</tt></i> in <i><tt>groupName</tt></i> from the key
--   file.
--   
--   <i>Since: 2.6</i>
keyFileRemoveKey :: (HasCallStack, MonadIO m) => KeyFile -> Text -> Text -> m ()

-- | Writes the contents of <i><tt>keyFile</tt></i> to
--   <i><tt>filename</tt></i> using <a>fileSetContents</a>.
--   
--   If you need stricter guarantees about durability of the written file
--   than are provided by <a>fileSetContents</a>, use
--   <a>fileSetContentsFull</a> with the return value of
--   <a>keyFileToData</a>.
--   
--   This function can fail for any of the reasons that
--   <a>fileSetContents</a> may fail.
--   
--   <i>Since: 2.40</i>
keyFileSaveToFile :: (HasCallStack, MonadIO m) => KeyFile -> Text -> m ()

-- | Associates a new boolean value with <i><tt>key</tt></i> under
--   <i><tt>groupName</tt></i>.
--   
--   If <i><tt>key</tt></i> cannot be found then it is created.
--   
--   <i>Since: 2.6</i>
keyFileSetBoolean :: (HasCallStack, MonadIO m) => KeyFile -> Text -> Text -> Bool -> m ()

-- | Associates a list of boolean values with <i><tt>key</tt></i> under
--   <i><tt>groupName</tt></i>.
--   
--   If <i><tt>key</tt></i> cannot be found then it is created.
--   
--   <i>Since: 2.6</i>
keyFileSetBooleanList :: (HasCallStack, MonadIO m) => KeyFile -> Text -> Text -> [Bool] -> m ()

-- | Places a comment above <i><tt>key</tt></i> from
--   <i><tt>groupName</tt></i>.
--   
--   If <i><tt>key</tt></i> is <tt>NULL</tt> then <i><tt>comment</tt></i>
--   will be written above <i><tt>groupName</tt></i>. If both
--   <i><tt>key</tt></i> and <i><tt>groupName</tt></i> are <tt>NULL</tt>,
--   then <i><tt>comment</tt></i> will be written above the first group in
--   the file.
--   
--   Passing a non-existent <i><tt>groupName</tt></i> or
--   <i><tt>key</tt></i> to this function returns false and populates
--   <i><tt>error</tt></i>. (In contrast, passing a non-existent
--   <tt>group_name</tt> or <tt>key</tt> to <a>keyFileSetString</a> creates
--   the associated group name and key.)
--   
--   Note that this function prepends a <tt>#</tt> comment marker to each
--   line of <i><tt>comment</tt></i>.
--   
--   <i>Since: 2.6</i>
keyFileSetComment :: (HasCallStack, MonadIO m) => KeyFile -> Maybe Text -> Maybe Text -> Text -> m ()

-- | Associates a new double value with <i><tt>key</tt></i> under
--   <i><tt>groupName</tt></i>.
--   
--   If <i><tt>key</tt></i> cannot be found then it is created.
--   
--   <i>Since: 2.12</i>
keyFileSetDouble :: (HasCallStack, MonadIO m) => KeyFile -> Text -> Text -> Double -> m ()

-- | Associates a list of double values with <i><tt>key</tt></i> under
--   <i><tt>groupName</tt></i>.
--   
--   If <i><tt>key</tt></i> cannot be found then it is created.
--   
--   <i>Since: 2.12</i>
keyFileSetDoubleList :: (HasCallStack, MonadIO m) => KeyFile -> Text -> Text -> [Double] -> m ()

-- | Associates a new integer value with <i><tt>key</tt></i> under
--   <i><tt>groupName</tt></i>.
--   
--   If <i><tt>key</tt></i> cannot be found then it is created.
--   
--   <i>Since: 2.26</i>
keyFileSetInt64 :: (HasCallStack, MonadIO m) => KeyFile -> Text -> Text -> Int64 -> m ()

-- | Associates a new integer value with <i><tt>key</tt></i> under
--   <i><tt>groupName</tt></i>.
--   
--   If <i><tt>key</tt></i> cannot be found then it is created.
--   
--   <i>Since: 2.6</i>
keyFileSetInteger :: (HasCallStack, MonadIO m) => KeyFile -> Text -> Text -> Int32 -> m ()

-- | Associates a list of integer values with <i><tt>key</tt></i> under
--   <i><tt>groupName</tt></i>.
--   
--   If <i><tt>key</tt></i> cannot be found then it is created.
--   
--   <i>Since: 2.6</i>
keyFileSetIntegerList :: (HasCallStack, MonadIO m) => KeyFile -> Text -> Text -> [Int32] -> m ()

-- | Sets the character which is used to separate values in lists.
--   
--   Typically <tt>;</tt> or <tt>,</tt> are used as separators. The default
--   list separator is <tt>;</tt>.
--   
--   <i>Since: 2.6</i>
keyFileSetListSeparator :: (HasCallStack, MonadIO m) => KeyFile -> Int8 -> m ()

-- | Associates a string value for <i><tt>key</tt></i> and
--   <i><tt>locale</tt></i> under <i><tt>groupName</tt></i>.
--   
--   If the translation for <i><tt>key</tt></i> cannot be found then it is
--   created.
--   
--   If <i><tt>locale</tt></i> is <tt>C</tt> then the untranslated value is
--   set (since GLib 2.84).
--   
--   <i>Since: 2.6</i>
keyFileSetLocaleString :: (HasCallStack, MonadIO m) => KeyFile -> Text -> Text -> Text -> Text -> m ()

-- | Associates a list of string values for <i><tt>key</tt></i> and
--   <i><tt>locale</tt></i> under <i><tt>groupName</tt></i>.
--   
--   If <i><tt>locale</tt></i> is <tt>C</tt> then the untranslated value is
--   set (since GLib 2.84).
--   
--   If the translation for <i><tt>key</tt></i> cannot be found then it is
--   created.
--   
--   <i>Since: 2.6</i>
keyFileSetLocaleStringList :: (HasCallStack, MonadIO m) => KeyFile -> Text -> Text -> Text -> [Text] -> CSize -> m ()

-- | Associates a new string value with <i><tt>key</tt></i> under
--   <i><tt>groupName</tt></i>.
--   
--   If <i><tt>key</tt></i> cannot be found then it is created. If
--   <i><tt>groupName</tt></i> cannot be found then it is created. Unlike
--   <a>keyFileSetValue</a>, this function handles characters that need
--   escaping, such as newlines.
--   
--   <i>Since: 2.6</i>
keyFileSetString :: (HasCallStack, MonadIO m) => KeyFile -> Text -> Text -> Text -> m ()

-- | Associates a list of string values for <i><tt>key</tt></i> under
--   <i><tt>groupName</tt></i>.
--   
--   If <i><tt>key</tt></i> cannot be found then it is created. If
--   <i><tt>groupName</tt></i> cannot be found then it is created.
--   
--   <i>Since: 2.6</i>
keyFileSetStringList :: (HasCallStack, MonadIO m) => KeyFile -> Text -> Text -> [Text] -> CSize -> m ()

-- | Associates a new integer value with <i><tt>key</tt></i> under
--   <i><tt>groupName</tt></i>.
--   
--   If <i><tt>key</tt></i> cannot be found then it is created.
--   
--   <i>Since: 2.26</i>
keyFileSetUint64 :: (HasCallStack, MonadIO m) => KeyFile -> Text -> Text -> Word64 -> m ()

-- | Associates a new value with <i><tt>key</tt></i> under
--   <i><tt>groupName</tt></i>.
--   
--   If <i><tt>key</tt></i> cannot be found then it is created. If
--   <i><tt>groupName</tt></i> cannot be found then it is created. To set
--   an UTF-8 string which may contain characters that need escaping (such
--   as newlines or spaces), use <a>keyFileSetString</a>.
--   
--   <i>Since: 2.6</i>
keyFileSetValue :: (HasCallStack, MonadIO m) => KeyFile -> Text -> Text -> Text -> m ()

-- | Outputs <i><tt>keyFile</tt></i> as a string.
--   
--   Note that this function never reports an error.
--   
--   <i>Since: 2.6</i>
keyFileToData :: (HasCallStack, MonadIO m) => KeyFile -> m (Text, CSize)

-- | Decreases the reference count of <i><tt>keyFile</tt></i> by 1.
--   
--   If the reference count reaches zero, frees the key file and all its
--   allocated memory.
--   
--   <i>Since: 2.32</i>
keyFileUnref :: (HasCallStack, MonadIO m) => KeyFile -> m ()
instance GHC.Classes.Eq GI.GLib.Structs.KeyFile.KeyFile
instance Data.GI.Base.BasicTypes.GBoxed GI.GLib.Structs.KeyFile.KeyFile
instance Data.GI.Base.Overloading.HasParentTypes GI.GLib.Structs.KeyFile.KeyFile
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.GLib.Structs.KeyFile.KeyFile)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GLib.Structs.KeyFile.KeyFile
instance Data.GI.Base.BasicTypes.TypedObject GI.GLib.Structs.KeyFile.KeyFile


-- | Structure representing a single field in a structured log entry. See
--   <tt><i>g_log_structured()</i></tt> for details.
--   
--   Log fields may contain arbitrary values, including binary with
--   embedded nul bytes. If the field contains a string, the string must be
--   UTF-8 encoded and have a trailing nul byte. Otherwise,
--   <i><tt>length</tt></i> must be set to a non-negative value.
--   
--   <i>Since: 2.50</i>
module GI.GLib.Structs.LogField

-- | Memory-managed wrapper type.
newtype LogField
LogField :: ManagedPtr LogField -> LogField

-- | Construct a <a>LogField</a> struct initialized to zero.
newZeroLogField :: MonadIO m => m LogField

-- | Set the value of the “<tt>key</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #key
--   </pre>
clearLogFieldKey :: MonadIO m => LogField -> m ()

-- | Get the value of the “<tt>key</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> logField #key
--   </pre>
getLogFieldKey :: MonadIO m => LogField -> m (Maybe Text)

-- | Set the value of the “<tt>key</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> logField [ #key <a>:=</a> value ]
--   </pre>
setLogFieldKey :: MonadIO m => LogField -> CString -> m ()

-- | Get the value of the “<tt>length</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> logField #length
--   </pre>
getLogFieldLength :: MonadIO m => LogField -> m Int64

-- | Set the value of the “<tt>length</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> logField [ #length <a>:=</a> value ]
--   </pre>
setLogFieldLength :: MonadIO m => LogField -> Int64 -> m ()

-- | Set the value of the “<tt>value</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #value
--   </pre>
clearLogFieldValue :: MonadIO m => LogField -> m ()

-- | Get the value of the “<tt>value</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> logField #value
--   </pre>
getLogFieldValue :: MonadIO m => LogField -> m (Ptr ())

-- | Set the value of the “<tt>value</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> logField [ #value <a>:=</a> value ]
--   </pre>
setLogFieldValue :: MonadIO m => LogField -> Ptr () -> m ()
instance Data.GI.Base.BasicTypes.BoxedPtr GI.GLib.Structs.LogField.LogField
instance Data.GI.Base.BasicTypes.CallocPtr GI.GLib.Structs.LogField.LogField
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.GLib.Structs.LogField.LogField tag
instance GHC.Classes.Eq GI.GLib.Structs.LogField.LogField
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GLib.Structs.LogField.LogField


-- | The <a>MappedFile</a> represents a file mapping created with
--   <a>mappedFileNew</a>. It has only private members and should not be
--   accessed directly.
module GI.GLib.Structs.MappedFile

-- | Memory-managed wrapper type.
newtype MappedFile
MappedFile :: ManagedPtr MappedFile -> MappedFile

-- | This call existed before <a>MappedFile</a> had refcounting and is
--   currently exactly the same as <a>mappedFileUnref</a>.
--   
--   <i>Since: 2.8</i>

-- | <i>Deprecated: (Since version 2.22)Use <a>mappedFileUnref</a>
--   instead.</i>
mappedFileFree :: (HasCallStack, MonadIO m) => MappedFile -> m ()

-- | Creates a new <a>Bytes</a> which references the data mapped from
--   <i><tt>file</tt></i>. The mapped contents of the file must not be
--   modified after creating this bytes object, because a <a>Bytes</a>
--   should be immutable.
--   
--   <i>Since: 2.34</i>
mappedFileGetBytes :: (HasCallStack, MonadIO m) => MappedFile -> m Bytes

-- | Returns the contents of a <a>MappedFile</a>.
--   
--   Note that the contents may not be zero-terminated, even if the
--   <a>MappedFile</a> is backed by a text file.
--   
--   If the file is empty then <a>Nothing</a> is returned.
--   
--   <i>Since: 2.8</i>
mappedFileGetContents :: (HasCallStack, MonadIO m) => MappedFile -> m (Maybe Text)

-- | Returns the length of the contents of a <a>MappedFile</a>.
--   
--   <i>Since: 2.8</i>
mappedFileGetLength :: (HasCallStack, MonadIO m) => MappedFile -> m CSize

-- | Maps a file into memory. On UNIX, this is using the
--   <tt><i>mmap()</i></tt> function.
--   
--   If <i><tt>writable</tt></i> is <a>True</a>, the mapped buffer may be
--   modified, otherwise it is an error to modify the mapped buffer.
--   Modifications to the buffer are not visible to other processes mapping
--   the same file, and are not written back to the file.
--   
--   Note that modifications of the underlying file might affect the
--   contents of the <a>MappedFile</a>. Therefore, mapping should only be
--   used if the file will not be modified, or if all modifications of the
--   file are done atomically (e.g. using <a>fileSetContents</a>).
--   
--   If <i><tt>filename</tt></i> is the name of an empty, regular file, the
--   function will successfully return an empty <a>MappedFile</a>. In other
--   cases of size 0 (e.g. device files such as /dev/null),
--   <i><tt>error</tt></i> will be set to the <a>FileError</a> value
--   <a>FileErrorInval</a>.
--   
--   <i>Since: 2.8</i>
mappedFileNew :: (HasCallStack, MonadIO m) => [Char] -> Bool -> m MappedFile

-- | Maps a file into memory. On UNIX, this is using the
--   <tt><i>mmap()</i></tt> function.
--   
--   If <i><tt>writable</tt></i> is <a>True</a>, the mapped buffer may be
--   modified, otherwise it is an error to modify the mapped buffer.
--   Modifications to the buffer are not visible to other processes mapping
--   the same file, and are not written back to the file.
--   
--   Note that modifications of the underlying file might affect the
--   contents of the <a>MappedFile</a>. Therefore, mapping should only be
--   used if the file will not be modified, or if all modifications of the
--   file are done atomically (e.g. using <a>fileSetContents</a>).
--   
--   <i>Since: 2.32</i>
mappedFileNewFromFd :: (HasCallStack, MonadIO m) => Int32 -> Bool -> m MappedFile

-- | Increments the reference count of <i><tt>file</tt></i> by one. It is
--   safe to call this function from any thread.
--   
--   <i>Since: 2.22</i>
mappedFileRef :: (HasCallStack, MonadIO m) => MappedFile -> m MappedFile

-- | Decrements the reference count of <i><tt>file</tt></i> by one. If the
--   reference count drops to 0, unmaps the buffer of <i><tt>file</tt></i>
--   and frees it.
--   
--   It is safe to call this function from any thread.
--   
--   Since 2.22
mappedFileUnref :: (HasCallStack, MonadIO m) => MappedFile -> m ()
instance GHC.Classes.Eq GI.GLib.Structs.MappedFile.MappedFile
instance Data.GI.Base.BasicTypes.GBoxed GI.GLib.Structs.MappedFile.MappedFile
instance Data.GI.Base.Overloading.HasParentTypes GI.GLib.Structs.MappedFile.MappedFile
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.GLib.Structs.MappedFile.MappedFile)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GLib.Structs.MappedFile.MappedFile
instance Data.GI.Base.BasicTypes.TypedObject GI.GLib.Structs.MappedFile.MappedFile


-- | <i>No description available in the introspection data.</i>
module GI.GLib.Structs.MemChunk

-- | Memory-managed wrapper type.
newtype MemChunk
MemChunk :: ManagedPtr MemChunk -> MemChunk

-- | <i>No description available in the introspection data.</i>

-- | <i>Deprecated: (Since version 2.10)</i>
memChunkAlloc :: (HasCallStack, MonadIO m) => MemChunk -> m (Ptr ())

-- | <i>No description available in the introspection data.</i>

-- | <i>Deprecated: (Since version 2.10)</i>
memChunkAlloc0 :: (HasCallStack, MonadIO m) => MemChunk -> m (Ptr ())

-- | <i>No description available in the introspection data.</i>

-- | <i>Deprecated: (Since version 2.10)</i>
memChunkClean :: (HasCallStack, MonadIO m) => MemChunk -> m ()

-- | <i>No description available in the introspection data.</i>

-- | <i>Deprecated: (Since version 2.10)</i>
memChunkDestroy :: (HasCallStack, MonadIO m) => MemChunk -> m ()

-- | <i>No description available in the introspection data.</i>

-- | <i>Deprecated: (Since version 2.10)</i>
memChunkFree :: (HasCallStack, MonadIO m) => MemChunk -> Ptr () -> m ()

-- | <i>No description available in the introspection data.</i>

-- | <i>Deprecated: (Since version 2.10)</i>
memChunkInfo :: (HasCallStack, MonadIO m) => m ()

-- | <i>No description available in the introspection data.</i>

-- | <i>Deprecated: (Since version 2.10)</i>
memChunkPrint :: (HasCallStack, MonadIO m) => MemChunk -> m ()

-- | <i>No description available in the introspection data.</i>

-- | <i>Deprecated: (Since version 2.10)</i>
memChunkReset :: (HasCallStack, MonadIO m) => MemChunk -> m ()
instance Data.GI.Base.BasicTypes.BoxedPtr GI.GLib.Structs.MemChunk.MemChunk
instance GHC.Classes.Eq GI.GLib.Structs.MemChunk.MemChunk
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GLib.Structs.MemChunk.MemChunk


-- | A <a>Once</a> struct controls a one-time initialization function. Any
--   one-time initialization function must have its own unique <a>Once</a>
--   struct.
--   
--   <i>Since: 2.4</i>
module GI.GLib.Structs.Once

-- | Memory-managed wrapper type.
newtype Once
Once :: ManagedPtr Once -> Once

-- | Construct a <a>Once</a> struct initialized to zero.
newZeroOnce :: MonadIO m => m Once

-- | Function to be called when starting a critical initialization section.
--   The argument <i><tt>location</tt></i> must point to a static
--   0-initialized variable that will be set to a value other than 0 at the
--   end of the initialization section. In combination with
--   <a>onceInitLeave</a> and the unique address
--   <i><tt>valueLocation</tt></i>, it can be ensured that an
--   initialization section will be executed only once during a program's
--   life time, and that concurrent threads are blocked until
--   initialization completed. To be used in constructs like this:
--   
--   <h3><i>C code</i></h3>
--   
--   <pre>
--   static gsize initialization_value = 0;
--   
--   if (g_once_init_enter (&amp;initialization_value))
--     {
--       gsize setup_value = 42; // initialization code here
--   
--       g_once_init_leave (&amp;initialization_value, setup_value);
--     }
--   
--   // use initialization_value here
--   </pre>
--   
--   While <i><tt>location</tt></i> has a <tt>volatile</tt> qualifier, this
--   is a historical artifact and the pointer passed to it should not be
--   <tt>volatile</tt>.
--   
--   <i>Since: 2.14</i>
onceInitEnter :: (HasCallStack, MonadIO m) => Ptr () -> m (Bool, Ptr ())

-- | <i>No description available in the introspection data.</i>
onceInitEnterImpl :: (HasCallStack, MonadIO m) => CSize -> m Bool

-- | This functions behaves in the same way as <a>onceInitEnter</a>, but
--   can can be used to initialize pointers (or <tt><i>guintptr</i></tt>)
--   instead of <tt><i>gsize</i></tt>.
--   
--   <h3><i>C code</i></h3>
--   
--   <pre>
--   static MyStruct *interesting_struct = NULL;
--   
--   if (g_once_init_enter_pointer (&amp;interesting_struct))
--     {
--       MyStruct *setup_value = allocate_my_struct (); // initialization code here
--   
--       g_once_init_leave_pointer (&amp;interesting_struct, g_steal_pointer (&amp;setup_value));
--     }
--   
--   // use interesting_struct here
--   </pre>
--   
--   <i>Since: 2.80</i>
onceInitEnterPointer :: (HasCallStack, MonadIO m) => Ptr () -> m Bool

-- | Counterpart to <a>onceInitEnter</a>. Expects a location of a static
--   0-initialized initialization variable, and an initialization value
--   other than 0. Sets the variable to the initialization value, and
--   releases concurrent threads blocking in <a>onceInitEnter</a> on this
--   initialization variable.
--   
--   While <i><tt>location</tt></i> has a <tt>volatile</tt> qualifier, this
--   is a historical artifact and the pointer passed to it should not be
--   <tt>volatile</tt>.
--   
--   <i>Since: 2.14</i>
onceInitLeave :: (HasCallStack, MonadIO m) => Ptr () -> CSize -> m (Ptr ())

-- | Counterpart to <a>onceInitEnterPointer</a>. Expects a location of a
--   static <tt>NULL</tt>-initialized initialization variable, and an
--   initialization value other than <tt>NULL</tt>. Sets the variable to
--   the initialization value, and releases concurrent threads blocking in
--   <a>onceInitEnterPointer</a> on this initialization variable.
--   
--   This functions behaves in the same way as <a>onceInitLeave</a>, but
--   can be used to initialize pointers (or <tt><i>guintptr</i></tt>)
--   instead of <tt><i>gsize</i></tt>.
--   
--   <i>Since: 2.80</i>
onceInitLeavePointer :: (HasCallStack, MonadIO m) => Ptr () -> Ptr () -> m ()

-- | Set the value of the “<tt>retval</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #retval
--   </pre>
clearOnceRetval :: MonadIO m => Once -> m ()

-- | Get the value of the “<tt>retval</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> once #retval
--   </pre>
getOnceRetval :: MonadIO m => Once -> m (Ptr ())

-- | Set the value of the “<tt>retval</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> once [ #retval <a>:=</a> value ]
--   </pre>
setOnceRetval :: MonadIO m => Once -> Ptr () -> m ()

-- | Get the value of the “<tt>status</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> once #status
--   </pre>
getOnceStatus :: MonadIO m => Once -> m OnceStatus

-- | Set the value of the “<tt>status</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> once [ #status <a>:=</a> value ]
--   </pre>
setOnceStatus :: MonadIO m => Once -> OnceStatus -> m ()
instance Data.GI.Base.BasicTypes.BoxedPtr GI.GLib.Structs.Once.Once
instance Data.GI.Base.BasicTypes.CallocPtr GI.GLib.Structs.Once.Once
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.GLib.Structs.Once.Once tag
instance GHC.Classes.Eq GI.GLib.Structs.Once.Once
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GLib.Structs.Once.Once


-- | <ul>
--   <li><a>OptionArgNone</a>: <tt><i>gboolean</i></tt></li>
--   <li><a>OptionArgString</a>: <tt><i>gchar</i></tt>*</li>
--   <li><a>OptionArgInt</a>: <tt><i>gint</i></tt></li>
--   <li><a>OptionArgFilename</a>: <tt><i>gchar</i></tt>*</li>
--   <li><a>OptionArgStringArray</a>: <tt><i>gchar</i></tt>__</li>
--   <li><a>OptionArgFilenameArray</a>: <tt><i>gchar</i></tt>__</li>
--   <li><a>OptionArgDouble</a>: <tt><i>gdouble</i></tt></li>
--   </ul>
--   
--   If <i><tt>arg</tt></i> type is <a>OptionArgString</a> or
--   <a>OptionArgFilename</a>, the location will contain a newly allocated
--   string if the option was given. That string needs to be freed by the
--   callee using <a>free</a>. Likewise if <i><tt>arg</tt></i> type is
--   <a>OptionArgStringArray</a> or <a>OptionArgFilenameArray</a>, the data
--   should be freed using <a>strfreev</a>.
--   
--   A GOptionEntry struct defines a single option. To have an effect, they
--   must be added to a <a>OptionGroup</a> with
--   <a>optionContextAddMainEntries</a> or <a>optionGroupAddEntries</a>.
module GI.GLib.Structs.OptionEntry

-- | Memory-managed wrapper type.
newtype OptionEntry
OptionEntry :: ManagedPtr OptionEntry -> OptionEntry

-- | Construct a <a>OptionEntry</a> struct initialized to zero.
newZeroOptionEntry :: MonadIO m => m OptionEntry

-- | Get the value of the “<tt>arg</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> optionEntry #arg
--   </pre>
getOptionEntryArg :: MonadIO m => OptionEntry -> m OptionArg

-- | Set the value of the “<tt>arg</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> optionEntry [ #arg <a>:=</a> value ]
--   </pre>
setOptionEntryArg :: MonadIO m => OptionEntry -> OptionArg -> m ()

-- | Set the value of the “<tt>arg_data</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #argData
--   </pre>
clearOptionEntryArgData :: MonadIO m => OptionEntry -> m ()

-- | Get the value of the “<tt>arg_data</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> optionEntry #argData
--   </pre>
getOptionEntryArgData :: MonadIO m => OptionEntry -> m (Ptr ())

-- | Set the value of the “<tt>arg_data</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> optionEntry [ #argData <a>:=</a> value ]
--   </pre>
setOptionEntryArgData :: MonadIO m => OptionEntry -> Ptr () -> m ()

-- | Set the value of the “<tt>arg_description</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #argDescription
--   </pre>
clearOptionEntryArgDescription :: MonadIO m => OptionEntry -> m ()

-- | Get the value of the “<tt>arg_description</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> optionEntry #argDescription
--   </pre>
getOptionEntryArgDescription :: MonadIO m => OptionEntry -> m (Maybe Text)

-- | Set the value of the “<tt>arg_description</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> optionEntry [ #argDescription <a>:=</a> value ]
--   </pre>
setOptionEntryArgDescription :: MonadIO m => OptionEntry -> CString -> m ()

-- | Set the value of the “<tt>description</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #description
--   </pre>
clearOptionEntryDescription :: MonadIO m => OptionEntry -> m ()

-- | Get the value of the “<tt>description</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> optionEntry #description
--   </pre>
getOptionEntryDescription :: MonadIO m => OptionEntry -> m (Maybe Text)

-- | Set the value of the “<tt>description</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> optionEntry [ #description <a>:=</a> value ]
--   </pre>
setOptionEntryDescription :: MonadIO m => OptionEntry -> CString -> m ()

-- | Get the value of the “<tt>flags</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> optionEntry #flags
--   </pre>
getOptionEntryFlags :: MonadIO m => OptionEntry -> m Int32

-- | Set the value of the “<tt>flags</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> optionEntry [ #flags <a>:=</a> value ]
--   </pre>
setOptionEntryFlags :: MonadIO m => OptionEntry -> Int32 -> m ()

-- | Set the value of the “<tt>long_name</tt>” field to <a>Nothing</a>.
--   When <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #longName
--   </pre>
clearOptionEntryLongName :: MonadIO m => OptionEntry -> m ()

-- | Get the value of the “<tt>long_name</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> optionEntry #longName
--   </pre>
getOptionEntryLongName :: MonadIO m => OptionEntry -> m (Maybe Text)

-- | Set the value of the “<tt>long_name</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> optionEntry [ #longName <a>:=</a> value ]
--   </pre>
setOptionEntryLongName :: MonadIO m => OptionEntry -> CString -> m ()

-- | Get the value of the “<tt>short_name</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> optionEntry #shortName
--   </pre>
getOptionEntryShortName :: MonadIO m => OptionEntry -> m Int8

-- | Set the value of the “<tt>short_name</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> optionEntry [ #shortName <a>:=</a> value ]
--   </pre>
setOptionEntryShortName :: MonadIO m => OptionEntry -> Int8 -> m ()
instance Data.GI.Base.BasicTypes.BoxedPtr GI.GLib.Structs.OptionEntry.OptionEntry
instance Data.GI.Base.BasicTypes.CallocPtr GI.GLib.Structs.OptionEntry.OptionEntry
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.GLib.Structs.OptionEntry.OptionEntry tag
instance GHC.Classes.Eq GI.GLib.Structs.OptionEntry.OptionEntry
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GLib.Structs.OptionEntry.OptionEntry


-- | <tt>GPathBuf</tt> is a helper type that allows you to easily build
--   paths from individual elements, using the platform specific
--   conventions for path separators.
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   g_auto (GPathBuf) path;
--   
--   g_path_buf_init (&amp;path);
--   
--   g_path_buf_push (&amp;path, "usr");
--   g_path_buf_push (&amp;path, "bin");
--   g_path_buf_push (&amp;path, "echo");
--   
--   g_autofree char *echo = g_path_buf_to_path (&amp;path);
--   g_assert_cmpstr (echo, ==, "/usr/bin/echo");
--   </pre>
--   
--   You can also load a full path and then operate on its components:
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   g_auto (GPathBuf) path;
--   
--   g_path_buf_init_from_path (&amp;path, "/usr/bin/echo");
--   
--   g_path_buf_pop (&amp;path);
--   g_path_buf_push (&amp;path, "sh");
--   
--   g_autofree char *sh = g_path_buf_to_path (&amp;path);
--   g_assert_cmpstr (sh, ==, "/usr/bin/sh");
--   </pre>
--   
--   <i>Since: 2.76</i>
module GI.GLib.Structs.PathBuf

-- | Memory-managed wrapper type.
newtype PathBuf
PathBuf :: ManagedPtr PathBuf -> PathBuf

-- | Construct a <a>PathBuf</a> struct initialized to zero.
newZeroPathBuf :: MonadIO m => m PathBuf

-- | Clears the contents of the path buffer.
--   
--   This function should be use to free the resources in a stack-allocated
--   <tt>GPathBuf</tt> initialized using <a>pathBufInit</a> or
--   <a>pathBufInitFromPath</a>.
--   
--   <i>Since: 2.76</i>
pathBufClear :: (HasCallStack, MonadIO m) => PathBuf -> m ()

-- | Clears the contents of the path buffer and returns the built path.
--   
--   This function returns <tt>NULL</tt> if the <tt>GPathBuf</tt> is empty.
--   
--   See also: <a>pathBufToPath</a>
--   
--   <i>Since: 2.76</i>
pathBufClearToPath :: (HasCallStack, MonadIO m) => PathBuf -> m (Maybe [Char])

-- | Compares two path buffers for equality and returns <tt>TRUE</tt> if
--   they are equal.
--   
--   The paths inside the path buffers are not going to be normalized, so
--   <tt>X/Y/Z/A/..</tt>, <tt>X/./Y/Z</tt> and <tt>X/Y/Z</tt> are not going
--   to be considered equal.
--   
--   This function can be passed to <tt><i>g_hash_table_new()</i></tt> as
--   the <tt>key_equal_func</tt> parameter.
--   
--   <i>Since: 2.76</i>
pathBufEqual :: (HasCallStack, MonadIO m) => Ptr () -> Ptr () -> m Bool

-- | Frees a <tt>GPathBuf</tt> allocated by
--   <tt><i>g_path_buf_new()</i></tt>.
--   
--   <i>Since: 2.76</i>
pathBufFree :: (HasCallStack, MonadIO m) => PathBuf -> m ()

-- | Frees a <tt>GPathBuf</tt> allocated by
--   <tt><i>g_path_buf_new()</i></tt>, and returns the path inside the
--   buffer.
--   
--   This function returns <tt>NULL</tt> if the <tt>GPathBuf</tt> is empty.
--   
--   See also: <a>pathBufToPath</a>
--   
--   <i>Since: 2.76</i>
pathBufFreeToPath :: (HasCallStack, MonadIO m) => PathBuf -> m (Maybe [Char])

-- | Initializes a <tt>GPathBuf</tt> instance.
--   
--   <i>Since: 2.76</i>
pathBufInit :: (HasCallStack, MonadIO m) => PathBuf -> m PathBuf

-- | Initializes a <tt>GPathBuf</tt> instance with the given path.
--   
--   <i>Since: 2.76</i>
pathBufInitFromPath :: (HasCallStack, MonadIO m) => PathBuf -> Maybe [Char] -> m PathBuf

-- | Removes the last element of the path buffer.
--   
--   If there is only one element in the path buffer (for example,
--   <tt>/</tt> on Unix-like operating systems or the drive on Windows
--   systems), it will not be removed and <a>False</a> will be returned
--   instead.
--   
--   <h3><i>C code</i></h3>
--   
--   <pre>
--   GPathBuf buf, cmp;
--   
--   g_path_buf_init_from_path (&amp;buf, "/bin/sh");
--   
--   g_path_buf_pop (&amp;buf);
--   g_path_buf_init_from_path (&amp;cmp, "/bin");
--   g_assert_true (g_path_buf_equal (&amp;buf, &amp;cmp));
--   g_path_buf_clear (&amp;cmp);
--   
--   g_path_buf_pop (&amp;buf);
--   g_path_buf_init_from_path (&amp;cmp, "/");
--   g_assert_true (g_path_buf_equal (&amp;buf, &amp;cmp));
--   g_path_buf_clear (&amp;cmp);
--   
--   g_path_buf_clear (&amp;buf);
--   </pre>
--   
--   <i>Since: 2.76</i>
pathBufPop :: (HasCallStack, MonadIO m) => PathBuf -> m Bool

-- | Extends the given path buffer with <i><tt>path</tt></i>.
--   
--   If <i><tt>path</tt></i> is absolute, it replaces the current path.
--   
--   If <i><tt>path</tt></i> contains a directory separator, the buffer is
--   extended by as many elements the path provides.
--   
--   On Windows, both forward slashes and backslashes are treated as
--   directory separators. On other platforms, <a>DIR_SEPARATOR_S</a> is
--   the only directory separator.
--   
--   <h3><i>C code</i></h3>
--   
--   <pre>
--   GPathBuf buf, cmp;
--   
--   g_path_buf_init_from_path (&amp;buf, "/tmp");
--   g_path_buf_push (&amp;buf, ".X11-unix/X0");
--   g_path_buf_init_from_path (&amp;cmp, "/tmp/.X11-unix/X0");
--   g_assert_true (g_path_buf_equal (&amp;buf, &amp;cmp));
--   g_path_buf_clear (&amp;cmp);
--   
--   g_path_buf_push (&amp;buf, "/etc/locale.conf");
--   g_path_buf_init_from_path (&amp;cmp, "/etc/locale.conf");
--   g_assert_true (g_path_buf_equal (&amp;buf, &amp;cmp));
--   g_path_buf_clear (&amp;cmp);
--   
--   g_path_buf_clear (&amp;buf);
--   </pre>
--   
--   <i>Since: 2.76</i>
pathBufPush :: (HasCallStack, MonadIO m) => PathBuf -> [Char] -> m PathBuf

-- | Adds an extension to the file name in the path buffer.
--   
--   If <i><tt>extension</tt></i> is <tt>NULL</tt>, the extension will be
--   unset.
--   
--   If the path buffer does not have a file name set, this function
--   returns <tt>FALSE</tt> and leaves the path buffer unmodified.
--   
--   <i>Since: 2.76</i>
pathBufSetExtension :: (HasCallStack, MonadIO m) => PathBuf -> Maybe [Char] -> m Bool

-- | Sets the file name of the path.
--   
--   If the path buffer is empty, the filename is left unset and this
--   function returns <tt>FALSE</tt>.
--   
--   If the path buffer only contains the root element (on Unix-like
--   operating systems) or the drive (on Windows), this is the equivalent
--   of pushing the new <i><tt>fileName</tt></i>.
--   
--   If the path buffer contains a path, this is the equivalent of popping
--   the path buffer and pushing <i><tt>fileName</tt></i>, creating a
--   sibling of the original path.
--   
--   <h3><i>C code</i></h3>
--   
--   <pre>
--   GPathBuf buf, cmp;
--   
--   g_path_buf_init_from_path (&amp;buf, "/");
--   
--   g_path_buf_set_filename (&amp;buf, "bar");
--   g_path_buf_init_from_path (&amp;cmp, "/bar");
--   g_assert_true (g_path_buf_equal (&amp;buf, &amp;cmp));
--   g_path_buf_clear (&amp;cmp);
--   
--   g_path_buf_set_filename (&amp;buf, "baz.txt");
--   g_path_buf_init_from_path (&amp;cmp, "/baz.txt");
--   g_assert_true (g_path_buf_equal (&amp;buf, &amp;cmp);
--   g_path_buf_clear (&amp;cmp);
--   
--   g_path_buf_clear (&amp;buf);
--   </pre>
--   
--   <i>Since: 2.76</i>
pathBufSetFilename :: (HasCallStack, MonadIO m) => PathBuf -> [Char] -> m Bool

-- | Retrieves the built path from the path buffer.
--   
--   On Windows, the result contains backslashes as directory separators,
--   even if forward slashes were used in input.
--   
--   If the path buffer is empty, this function returns <tt>NULL</tt>.
--   
--   <i>Since: 2.76</i>
pathBufToPath :: (HasCallStack, MonadIO m) => PathBuf -> m (Maybe [Char])
instance Data.GI.Base.BasicTypes.BoxedPtr GI.GLib.Structs.PathBuf.PathBuf
instance Data.GI.Base.BasicTypes.CallocPtr GI.GLib.Structs.PathBuf.PathBuf
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.GLib.Structs.PathBuf.PathBuf tag
instance GHC.Classes.Eq GI.GLib.Structs.PathBuf.PathBuf
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GLib.Structs.PathBuf.PathBuf


-- | A <tt>GPatternSpec</tt> struct is the ‘compiled’ form of a glob-style
--   pattern.
--   
--   The <a>patternMatchSimple</a> and <a>patternSpecMatch</a> functions
--   match a string against a pattern containing <tt>*</tt> and <tt>?</tt>
--   wildcards with similar semantics as the standard <tt>glob()</tt>
--   function: <tt>*</tt> matches an arbitrary, possibly empty, string,
--   <tt>?</tt> matches an arbitrary character.
--   
--   Note that in contrast to <a>`glob()`</a>), the <tt>/</tt> character
--   can be matched by the wildcards, there are no <tt>[…]</tt> character
--   ranges and <tt>*</tt> and <tt>?</tt> can not be escaped to include
--   them literally in a pattern.
--   
--   When multiple strings must be matched against the same pattern, it is
--   better to compile the pattern to a <a>PatternSpec</a> using
--   <a>patternSpecNew</a> and use <a>patternSpecMatchString</a> instead of
--   <a>patternMatchSimple</a>. This avoids the overhead of repeated
--   pattern compilation.
module GI.GLib.Structs.PatternSpec

-- | Memory-managed wrapper type.
newtype PatternSpec
PatternSpec :: ManagedPtr PatternSpec -> PatternSpec

-- | Copies <i><tt>pspec</tt></i> in a new
--   [type<i><tt>gLib</tt></i>.PatternSpec].
--   
--   <i>Since: 2.70</i>
patternSpecCopy :: (HasCallStack, MonadIO m) => PatternSpec -> m PatternSpec

-- | Compares two compiled pattern specs and returns whether they will
--   match the same set of strings.
patternSpecEqual :: (HasCallStack, MonadIO m) => PatternSpec -> PatternSpec -> m Bool

-- | Frees the memory allocated for the
--   [type<i><tt>gLib</tt></i>.PatternSpec].
patternSpecFree :: (HasCallStack, MonadIO m) => PatternSpec -> m ()

-- | Matches a string against a compiled pattern.
--   
--   Passing the correct length of the string given is mandatory. The
--   reversed string can be omitted by passing <tt>NULL</tt>, this is more
--   efficient if the reversed version of the string to be matched is not
--   at hand, as <a>patternSpecMatch</a> will only construct it if the
--   compiled pattern requires reverse matches.
--   
--   Note that, if the user code will (possibly) match a string against a
--   multitude of patterns containing wildcards, chances are high that some
--   patterns will require a reversed string. In this case, it’s more
--   efficient to provide the reversed string to avoid multiple
--   constructions thereof in the various calls to <a>patternSpecMatch</a>.
--   
--   Note also that the reverse of a UTF-8 encoded string can in general
--   not be obtained by <a>strreverse</a>. This works only if the string
--   does not contain any multibyte characters. GLib offers the
--   <a>utf8Strreverse</a> function to reverse UTF-8 encoded strings.
--   
--   <i>Since: 2.70</i>
patternSpecMatch :: (HasCallStack, MonadIO m) => PatternSpec -> CSize -> Text -> Maybe Text -> m Bool

-- | Matches a string against a compiled pattern.
--   
--   If the string is to be matched against more than one pattern, consider
--   using <a>patternSpecMatch</a> instead while supplying the reversed
--   string.
--   
--   <i>Since: 2.70</i>
patternSpecMatchString :: (HasCallStack, MonadIO m) => PatternSpec -> Text -> m Bool

-- | Compiles a pattern to a [type<i><tt>gLib</tt></i>.PatternSpec].
patternSpecNew :: (HasCallStack, MonadIO m) => Text -> m PatternSpec
instance GHC.Classes.Eq GI.GLib.Structs.PatternSpec.PatternSpec
instance Data.GI.Base.BasicTypes.GBoxed GI.GLib.Structs.PatternSpec.PatternSpec
instance Data.GI.Base.Overloading.HasParentTypes GI.GLib.Structs.PatternSpec.PatternSpec
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.GLib.Structs.PatternSpec.PatternSpec)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GLib.Structs.PatternSpec.PatternSpec
instance Data.GI.Base.BasicTypes.TypedObject GI.GLib.Structs.PatternSpec.PatternSpec


-- | Represents a file descriptor, which events to poll for, and which
--   events occurred.
module GI.GLib.Structs.PollFD

-- | Memory-managed wrapper type.
newtype PollFD
PollFD :: ManagedPtr PollFD -> PollFD

-- | Construct a <a>PollFD</a> struct initialized to zero.
newZeroPollFD :: MonadIO m => m PollFD

-- | Get the value of the “<tt>events</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> pollFD #events
--   </pre>
getPollFDEvents :: MonadIO m => PollFD -> m CUShort

-- | Set the value of the “<tt>events</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> pollFD [ #events <a>:=</a> value ]
--   </pre>
setPollFDEvents :: MonadIO m => PollFD -> CUShort -> m ()

-- | Get the value of the “<tt>fd</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> pollFD #fd
--   </pre>
getPollFDFd :: MonadIO m => PollFD -> m Int32

-- | Set the value of the “<tt>fd</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> pollFD [ #fd <a>:=</a> value ]
--   </pre>
setPollFDFd :: MonadIO m => PollFD -> Int32 -> m ()

-- | Get the value of the “<tt>revents</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> pollFD #revents
--   </pre>
getPollFDRevents :: MonadIO m => PollFD -> m CUShort

-- | Set the value of the “<tt>revents</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> pollFD [ #revents <a>:=</a> value ]
--   </pre>
setPollFDRevents :: MonadIO m => PollFD -> CUShort -> m ()
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.GLib.Structs.PollFD.PollFD tag
instance GHC.Classes.Eq GI.GLib.Structs.PollFD.PollFD
instance Data.GI.Base.BasicTypes.GBoxed GI.GLib.Structs.PollFD.PollFD
instance Data.GI.Base.Overloading.HasParentTypes GI.GLib.Structs.PollFD.PollFD
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.GLib.Structs.PollFD.PollFD)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GLib.Structs.PollFD.PollFD
instance Data.GI.Base.BasicTypes.TypedObject GI.GLib.Structs.PollFD.PollFD


-- | Contains the public fields of a <tt>GPtrArray</tt>.
module GI.GLib.Structs.PtrArray

-- | Memory-managed wrapper type.
newtype PtrArray
PtrArray :: ManagedPtr PtrArray -> PtrArray

-- | Construct a <a>PtrArray</a> struct initialized to zero.
newZeroPtrArray :: MonadIO m => m PtrArray

-- | Get the value of the “<tt>len</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> ptrArray #len
--   </pre>
getPtrArrayLen :: MonadIO m => PtrArray -> m Word32

-- | Set the value of the “<tt>len</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> ptrArray [ #len <a>:=</a> value ]
--   </pre>
setPtrArrayLen :: MonadIO m => PtrArray -> Word32 -> m ()

-- | Set the value of the “<tt>pdata</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #pdata
--   </pre>
clearPtrArrayPdata :: MonadIO m => PtrArray -> m ()

-- | Get the value of the “<tt>pdata</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> ptrArray #pdata
--   </pre>
getPtrArrayPdata :: MonadIO m => PtrArray -> m (Ptr ())

-- | Set the value of the “<tt>pdata</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> ptrArray [ #pdata <a>:=</a> value ]
--   </pre>
setPtrArrayPdata :: MonadIO m => PtrArray -> Ptr () -> m ()
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.GLib.Structs.PtrArray.PtrArray tag
instance GHC.Classes.Eq GI.GLib.Structs.PtrArray.PtrArray
instance Data.GI.Base.BasicTypes.GBoxed GI.GLib.Structs.PtrArray.PtrArray
instance Data.GI.Base.Overloading.HasParentTypes GI.GLib.Structs.PtrArray.PtrArray
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.GLib.Structs.PtrArray.PtrArray)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GLib.Structs.PtrArray.PtrArray
instance Data.GI.Base.BasicTypes.TypedObject GI.GLib.Structs.PtrArray.PtrArray


-- | The GRWLock struct is an opaque data structure to represent a
--   reader-writer lock. It is similar to a <a>Mutex</a> in that it allows
--   multiple threads to coordinate access to a shared resource.
--   
--   The difference to a mutex is that a reader-writer lock discriminates
--   between read-only ('reader') and full ('writer') access. While only
--   one thread at a time is allowed write access (by holding the 'writer'
--   lock via <a>rWLockWriterLock</a>), multiple threads can gain
--   simultaneous read-only access (by holding the 'reader' lock via
--   <a>rWLockReaderLock</a>).
--   
--   It is unspecified whether readers or writers have priority in
--   acquiring the lock when a reader already holds the lock and a writer
--   is queued to acquire it.
--   
--   Here is an example for an array with access functions:
--   
--   <h3><i>C code</i></h3>
--   
--   <pre>
--   GRWLock lock;
--   GPtrArray *array;
--   
--   gpointer
--   my_array_get (guint index)
--   {
--     gpointer retval = NULL;
--   
--     if (!array)
--       return NULL;
--   
--     g_rw_lock_reader_lock (&amp;lock);
--     if (index &lt; array-&gt;len)
--       retval = g_ptr_array_index (array, index);
--     g_rw_lock_reader_unlock (&amp;lock);
--   
--     return retval;
--   }
--   
--   void
--   my_array_set (guint index, gpointer data)
--   {
--     g_rw_lock_writer_lock (&amp;lock);
--   
--     if (!array)
--       array = g_ptr_array_new ();
--   
--     if (index &gt;= array-&gt;len)
--       g_ptr_array_set_size (array, index+1);
--     g_ptr_array_index (array, index) = data;
--   
--     g_rw_lock_writer_unlock (&amp;lock);
--   }
--   </pre>
--   
--   This example shows an array which can be accessed by many readers (the
--   <tt><i>my_array_get()</i></tt> function) simultaneously, whereas the
--   writers (the <tt><i>my_array_set()</i></tt> function) will only be
--   allowed one at a time and only if no readers currently access the
--   array. This is because of the potentially dangerous resizing of the
--   array. Using these functions is fully multi-thread safe now.
--   
--   If a <a>RWLock</a> is allocated in static storage then it can be used
--   without initialisation. Otherwise, you should call <a>rWLockInit</a>
--   on it and <a>rWLockClear</a> when done.
--   
--   A GRWLock should only be accessed with the g_rw_lock_ functions.
--   
--   <i>Since: 2.32</i>
module GI.GLib.Structs.RWLock

-- | Memory-managed wrapper type.
newtype RWLock
RWLock :: ManagedPtr RWLock -> RWLock

-- | Construct a <a>RWLock</a> struct initialized to zero.
newZeroRWLock :: MonadIO m => m RWLock

-- | Frees the resources allocated to a lock with <a>rWLockInit</a>.
--   
--   This function should not be used with a <a>RWLock</a> that has been
--   statically allocated.
--   
--   Calling <a>rWLockClear</a> when any thread holds the lock leads to
--   undefined behaviour.
--   
--   <i>Since: 2.32</i>
rWLockClear :: (HasCallStack, MonadIO m) => RWLock -> m ()

-- | Initializes a <a>RWLock</a> so that it can be used.
--   
--   This function is useful to initialize a lock that has been allocated
--   on the stack, or as part of a larger structure. It is not necessary to
--   initialise a reader-writer lock that has been statically allocated.
--   
--   <h3><i>C code</i></h3>
--   
--   <pre>
--     typedef struct {
--       GRWLock l;
--       ...
--     } Blob;
--   
--   Blob *b;
--   
--   b = g_new (Blob, 1);
--   g_rw_lock_init (&amp;b-&gt;l);
--   </pre>
--   
--   To undo the effect of <a>rWLockInit</a> when a lock is no longer
--   needed, use <a>rWLockClear</a>.
--   
--   Calling <a>rWLockInit</a> on an already initialized <a>RWLock</a>
--   leads to undefined behaviour.
--   
--   <i>Since: 2.32</i>
rWLockInit :: (HasCallStack, MonadIO m) => RWLock -> m ()

-- | Obtain a read lock on <i><tt>rwLock</tt></i>. If another thread
--   currently holds the write lock on <i><tt>rwLock</tt></i>, the current
--   thread will block until the write lock was (held and) released. If
--   another thread does not hold the write lock, but is waiting for it, it
--   is implementation defined whether the reader or writer will block.
--   Read locks can be taken recursively.
--   
--   Calling <a>rWLockReaderLock</a> while the current thread already owns
--   a write lock leads to undefined behaviour. Read locks however can be
--   taken recursively, in which case you need to make sure to call
--   <a>rWLockReaderUnlock</a> the same amount of times.
--   
--   It is implementation-defined how many read locks are allowed to be
--   held on the same lock simultaneously. If the limit is hit, or if a
--   deadlock is detected, a critical warning will be emitted.
--   
--   <i>Since: 2.32</i>
rWLockReaderLock :: (HasCallStack, MonadIO m) => RWLock -> m ()

-- | Tries to obtain a read lock on <i><tt>rwLock</tt></i> and returns
--   <a>True</a> if the read lock was successfully obtained. Otherwise it
--   returns <a>False</a>.
--   
--   <i>Since: 2.32</i>
rWLockReaderTrylock :: (HasCallStack, MonadIO m) => RWLock -> m Bool

-- | Release a read lock on <i><tt>rwLock</tt></i>.
--   
--   Calling <a>rWLockReaderUnlock</a> on a lock that is not held by the
--   current thread leads to undefined behaviour.
--   
--   <i>Since: 2.32</i>
rWLockReaderUnlock :: (HasCallStack, MonadIO m) => RWLock -> m ()

-- | Obtain a write lock on <i><tt>rwLock</tt></i>. If another thread
--   currently holds a read or write lock on <i><tt>rwLock</tt></i>, the
--   current thread will block until all other threads have dropped their
--   locks on <i><tt>rwLock</tt></i>.
--   
--   Calling <a>rWLockWriterLock</a> while the current thread already owns
--   a read or write lock on <i><tt>rwLock</tt></i> leads to undefined
--   behaviour.
--   
--   <i>Since: 2.32</i>
rWLockWriterLock :: (HasCallStack, MonadIO m) => RWLock -> m ()

-- | Tries to obtain a write lock on <i><tt>rwLock</tt></i>. If another
--   thread currently holds a read or write lock on <i><tt>rwLock</tt></i>,
--   it immediately returns <a>False</a>. Otherwise it locks
--   <i><tt>rwLock</tt></i> and returns <a>True</a>.
--   
--   <i>Since: 2.32</i>
rWLockWriterTrylock :: (HasCallStack, MonadIO m) => RWLock -> m Bool

-- | Release a write lock on <i><tt>rwLock</tt></i>.
--   
--   Calling <a>rWLockWriterUnlock</a> on a lock that is not held by the
--   current thread leads to undefined behaviour.
--   
--   <i>Since: 2.32</i>
rWLockWriterUnlock :: (HasCallStack, MonadIO m) => RWLock -> m ()
instance Data.GI.Base.BasicTypes.BoxedPtr GI.GLib.Structs.RWLock.RWLock
instance Data.GI.Base.BasicTypes.CallocPtr GI.GLib.Structs.RWLock.RWLock
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.GLib.Structs.RWLock.RWLock tag
instance GHC.Classes.Eq GI.GLib.Structs.RWLock.RWLock
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GLib.Structs.RWLock.RWLock


-- | The GRand struct is an opaque data structure. It should only be
--   accessed through the g_rand_* functions.
module GI.GLib.Structs.Rand

-- | Memory-managed wrapper type.
newtype Rand
Rand :: ManagedPtr Rand -> Rand

-- | Copies a <a>Rand</a> into a new one with the same exact state as
--   before. This way you can take a snapshot of the random number
--   generator for replaying later.
--   
--   <i>Since: 2.4</i>
randCopy :: (HasCallStack, MonadIO m) => Rand -> m Rand

-- | Returns the next random <tt><i>gdouble</i></tt> from
--   <i><tt>rand_</tt></i> equally distributed over the range [0..1).
randDouble :: (HasCallStack, MonadIO m) => Rand -> m Double

-- | Returns the next random <tt><i>gdouble</i></tt> from
--   <i><tt>rand_</tt></i> equally distributed over the range
--   [<i><tt>begin</tt></i>..<i><tt>end</tt></i>).
randDoubleRange :: (HasCallStack, MonadIO m) => Rand -> Double -> Double -> m Double

-- | Frees the memory allocated for the <a>Rand</a>.
randFree :: (HasCallStack, MonadIO m) => Rand -> m ()

-- | Returns the next random <tt><i>guint32</i></tt> from
--   <i><tt>rand_</tt></i> equally distributed over the range [0..2^32-1].
randInt :: (HasCallStack, MonadIO m) => Rand -> m Word32

-- | Returns the next random <tt><i>gint32</i></tt> from
--   <i><tt>rand_</tt></i> equally distributed over the range
--   [<i><tt>begin</tt></i>..<i><tt>end</tt></i>-1].
randIntRange :: (HasCallStack, MonadIO m) => Rand -> Int32 -> Int32 -> m Int32

-- | Creates a new random number generator initialized with a seed taken
--   either from <tt>/dev/urandom</tt> (if existing) or from the current
--   time (as a fallback).
--   
--   On Windows, the seed is taken from <tt><i>rand_s()</i></tt>.
randNew :: (HasCallStack, MonadIO m) => m Rand

-- | Creates a new random number generator initialized with
--   <i><tt>seed</tt></i>.
randNewWithSeed :: (HasCallStack, MonadIO m) => Word32 -> m Rand

-- | Creates a new random number generator initialized with
--   <i><tt>seed</tt></i>.
--   
--   <i>Since: 2.4</i>
randNewWithSeedArray :: (HasCallStack, MonadIO m) => Word32 -> Word32 -> m Rand

-- | Sets the seed for the random number generator <a>Rand</a> to
--   <i><tt>seed</tt></i>.
randSetSeed :: (HasCallStack, MonadIO m) => Rand -> Word32 -> m ()

-- | Initializes the random number generator by an array of longs. Array
--   can be of arbitrary size, though only the first 624 values are taken.
--   This function is useful if you have many low entropy seeds, or if you
--   require more then 32 bits of actual entropy for your application.
--   
--   <i>Since: 2.4</i>
randSetSeedArray :: (HasCallStack, MonadIO m) => Rand -> Word32 -> Word32 -> m ()
instance GHC.Classes.Eq GI.GLib.Structs.Rand.Rand
instance Data.GI.Base.BasicTypes.GBoxed GI.GLib.Structs.Rand.Rand
instance Data.GI.Base.Overloading.HasParentTypes GI.GLib.Structs.Rand.Rand
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.GLib.Structs.Rand.Rand)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GLib.Structs.Rand.Rand
instance Data.GI.Base.BasicTypes.TypedObject GI.GLib.Structs.Rand.Rand


-- | The GRecMutex struct is an opaque data structure to represent a
--   recursive mutex. It is similar to a <a>Mutex</a> with the difference
--   that it is possible to lock a GRecMutex multiple times in the same
--   thread without deadlock. When doing so, care has to be taken to unlock
--   the recursive mutex as often as it has been locked.
--   
--   If a <a>RecMutex</a> is allocated in static storage then it can be
--   used without initialisation. Otherwise, you should call
--   <a>recMutexInit</a> on it and <a>recMutexClear</a> when done.
--   
--   A GRecMutex should only be accessed with the g_rec_mutex_ functions.
--   
--   <i>Since: 2.32</i>
module GI.GLib.Structs.RecMutex

-- | Memory-managed wrapper type.
newtype RecMutex
RecMutex :: ManagedPtr RecMutex -> RecMutex

-- | Construct a <a>RecMutex</a> struct initialized to zero.
newZeroRecMutex :: MonadIO m => m RecMutex

-- | Frees the resources allocated to a recursive mutex with
--   <a>recMutexInit</a>.
--   
--   This function should not be used with a <a>RecMutex</a> that has been
--   statically allocated.
--   
--   Calling <a>recMutexClear</a> on a locked recursive mutex leads to
--   undefined behaviour.
--   
--   <i>Since: 2.32</i>
recMutexClear :: (HasCallStack, MonadIO m) => RecMutex -> m ()

-- | Initializes a <a>RecMutex</a> so that it can be used.
--   
--   This function is useful to initialize a recursive mutex that has been
--   allocated on the stack, or as part of a larger structure.
--   
--   It is not necessary to initialise a recursive mutex that has been
--   statically allocated.
--   
--   <h3><i>C code</i></h3>
--   
--   <pre>
--     typedef struct {
--       GRecMutex m;
--       ...
--     } Blob;
--   
--   Blob *b;
--   
--   b = g_new (Blob, 1);
--   g_rec_mutex_init (&amp;b-&gt;m);
--   </pre>
--   
--   Calling <a>recMutexInit</a> on an already initialized <a>RecMutex</a>
--   leads to undefined behaviour.
--   
--   To undo the effect of <a>recMutexInit</a> when a recursive mutex is no
--   longer needed, use <a>recMutexClear</a>.
--   
--   <i>Since: 2.32</i>
recMutexInit :: (HasCallStack, MonadIO m) => RecMutex -> m ()

-- | Locks <i><tt>recMutex</tt></i>. If <i><tt>recMutex</tt></i> is already
--   locked by another thread, the current thread will block until
--   <i><tt>recMutex</tt></i> is unlocked by the other thread. If
--   <i><tt>recMutex</tt></i> is already locked by the current thread, the
--   'lock count' of <i><tt>recMutex</tt></i> is increased. The mutex will
--   only become available again when it is unlocked as many times as it
--   has been locked.
--   
--   <i>Since: 2.32</i>
recMutexLock :: (HasCallStack, MonadIO m) => RecMutex -> m ()

-- | Tries to lock <i><tt>recMutex</tt></i>. If <i><tt>recMutex</tt></i> is
--   already locked by another thread, it immediately returns <a>False</a>.
--   Otherwise it locks <i><tt>recMutex</tt></i> and returns <a>True</a>.
--   
--   <i>Since: 2.32</i>
recMutexTrylock :: (HasCallStack, MonadIO m) => RecMutex -> m Bool

-- | Unlocks <i><tt>recMutex</tt></i>. If another thread is blocked in a
--   <a>recMutexLock</a> call for <i><tt>recMutex</tt></i>, it will become
--   unblocked and can lock <i><tt>recMutex</tt></i> itself.
--   
--   Calling <a>recMutexUnlock</a> on a recursive mutex that is not locked
--   by the current thread leads to undefined behaviour.
--   
--   <i>Since: 2.32</i>
recMutexUnlock :: (HasCallStack, MonadIO m) => RecMutex -> m ()
instance Data.GI.Base.BasicTypes.BoxedPtr GI.GLib.Structs.RecMutex.RecMutex
instance Data.GI.Base.BasicTypes.CallocPtr GI.GLib.Structs.RecMutex.RecMutex
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.GLib.Structs.RecMutex.RecMutex tag
instance GHC.Classes.Eq GI.GLib.Structs.RecMutex.RecMutex
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GLib.Structs.RecMutex.RecMutex


-- | A <tt>GRelation</tt> is a table of data which can be indexed on any
--   number of fields, rather like simple database tables. A
--   <tt>GRelation</tt> contains a number of records, called tuples. Each
--   record contains a number of fields. Records are not ordered, so it is
--   not possible to find the record at a particular index.
--   
--   Note that <tt>GRelation</tt> tables are currently limited to 2 fields.
--   
--   To create a <tt>GRelation</tt>, use
--   <a>Relation</a>.<tt><i>new</i></tt>().
--   
--   To specify which fields should be indexed, use
--   <a>Relation</a>.<tt><i>index</i></tt>(). Note that this must be called
--   before any tuples are added to the <tt>GRelation</tt>.
--   
--   To add records to a <tt>GRelation</tt> use
--   <a>Relation</a>.<tt><i>insert</i></tt>().
--   
--   To determine if a given record appears in a <tt>GRelation</tt>, use
--   <a>Relation</a>.<tt><i>exists</i></tt>(). Note that fields are
--   compared directly, so pointers must point to the exact same position
--   (i.e. different copies of the same string will not match.)
--   
--   To count the number of records which have a particular value in a
--   given field, use <a>relationCount</a>.
--   
--   To get all the records which have a particular value in a given field,
--   use <a>Relation</a>.<tt><i>select</i></tt>(). To access fields of the
--   resulting records, use <a>tuplesIndex</a>. To free the resulting
--   records use <a>tuplesDestroy</a>.
--   
--   To delete all records which have a particular value in a given field,
--   use <a>relationDelete</a>.
--   
--   To destroy the <tt>GRelation</tt>, use <a>relationDestroy</a>.
--   
--   To help debug <tt>GRelation</tt> objects, use <a>relationPrint</a>.
--   
--   <tt>GRelation</tt> has been marked as deprecated, since this API has
--   never been fully implemented, is not very actively maintained and
--   rarely used.
module GI.GLib.Structs.Relation

-- | Memory-managed wrapper type.
newtype Relation
Relation :: ManagedPtr Relation -> Relation

-- | Returns the number of tuples in a <a>Relation</a> that have the given
--   value in the given field.

-- | <i>Deprecated: (Since version 2.26)Rarely used API</i>
relationCount :: (HasCallStack, MonadIO m) => Relation -> Ptr () -> Int32 -> m Int32

-- | Deletes any records from a <a>Relation</a> that have the given key
--   value in the given field.

-- | <i>Deprecated: (Since version 2.26)Rarely used API</i>
relationDelete :: (HasCallStack, MonadIO m) => Relation -> Ptr () -> Int32 -> m Int32

-- | Destroys the <a>Relation</a>, freeing all memory allocated. However,
--   it does not free memory allocated for the tuple data, so you should
--   free that first if appropriate.

-- | <i>Deprecated: (Since version 2.26)Rarely used API</i>
relationDestroy :: (HasCallStack, MonadIO m) => Relation -> m ()

-- | Outputs information about all records in a <a>Relation</a>, as well as
--   the indexes. It is for debugging.

-- | <i>Deprecated: (Since version 2.26)Rarely used API</i>
relationPrint :: (HasCallStack, MonadIO m) => Relation -> m ()
instance Data.GI.Base.BasicTypes.BoxedPtr GI.GLib.Structs.Relation.Relation
instance GHC.Classes.Eq GI.GLib.Structs.Relation.Relation
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GLib.Structs.Relation.Relation


-- | Specifies the <a>Scanner</a> parser configuration. Most settings can
--   be changed during the parsing phase and will affect the lexical
--   parsing of the next unpeeked token.
module GI.GLib.Structs.ScannerConfig

-- | Memory-managed wrapper type.
newtype ScannerConfig
ScannerConfig :: ManagedPtr ScannerConfig -> ScannerConfig

-- | Construct a <a>ScannerConfig</a> struct initialized to zero.
newZeroScannerConfig :: MonadIO m => m ScannerConfig

-- | Get the value of the “<tt>case_sensitive</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scannerConfig #caseSensitive
--   </pre>
getScannerConfigCaseSensitive :: MonadIO m => ScannerConfig -> m Word32

-- | Set the value of the “<tt>case_sensitive</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scannerConfig [ #caseSensitive <a>:=</a> value ]
--   </pre>
setScannerConfigCaseSensitive :: MonadIO m => ScannerConfig -> Word32 -> m ()

-- | Get the value of the “<tt>char_2_token</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scannerConfig #char2Token
--   </pre>
getScannerConfigChar2Token :: MonadIO m => ScannerConfig -> m Word32

-- | Set the value of the “<tt>char_2_token</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scannerConfig [ #char2Token <a>:=</a> value ]
--   </pre>
setScannerConfigChar2Token :: MonadIO m => ScannerConfig -> Word32 -> m ()

-- | Set the value of the “<tt>cpair_comment_single</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #cpairCommentSingle
--   </pre>
clearScannerConfigCpairCommentSingle :: MonadIO m => ScannerConfig -> m ()

-- | Get the value of the “<tt>cpair_comment_single</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scannerConfig #cpairCommentSingle
--   </pre>
getScannerConfigCpairCommentSingle :: MonadIO m => ScannerConfig -> m (Maybe Text)

-- | Set the value of the “<tt>cpair_comment_single</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scannerConfig [ #cpairCommentSingle <a>:=</a> value ]
--   </pre>
setScannerConfigCpairCommentSingle :: MonadIO m => ScannerConfig -> CString -> m ()

-- | Set the value of the “<tt>cset_identifier_first</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #csetIdentifierFirst
--   </pre>
clearScannerConfigCsetIdentifierFirst :: MonadIO m => ScannerConfig -> m ()

-- | Get the value of the “<tt>cset_identifier_first</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scannerConfig #csetIdentifierFirst
--   </pre>
getScannerConfigCsetIdentifierFirst :: MonadIO m => ScannerConfig -> m (Maybe Text)

-- | Set the value of the “<tt>cset_identifier_first</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scannerConfig [ #csetIdentifierFirst <a>:=</a> value ]
--   </pre>
setScannerConfigCsetIdentifierFirst :: MonadIO m => ScannerConfig -> CString -> m ()

-- | Set the value of the “<tt>cset_identifier_nth</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #csetIdentifierNth
--   </pre>
clearScannerConfigCsetIdentifierNth :: MonadIO m => ScannerConfig -> m ()

-- | Get the value of the “<tt>cset_identifier_nth</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scannerConfig #csetIdentifierNth
--   </pre>
getScannerConfigCsetIdentifierNth :: MonadIO m => ScannerConfig -> m (Maybe Text)

-- | Set the value of the “<tt>cset_identifier_nth</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scannerConfig [ #csetIdentifierNth <a>:=</a> value ]
--   </pre>
setScannerConfigCsetIdentifierNth :: MonadIO m => ScannerConfig -> CString -> m ()

-- | Set the value of the “<tt>cset_skip_characters</tt>” field to
--   <a>Nothing</a>. When <a>overloading</a> is enabled, this is equivalent
--   to
--   
--   <pre>
--   <a>clear</a> #csetSkipCharacters
--   </pre>
clearScannerConfigCsetSkipCharacters :: MonadIO m => ScannerConfig -> m ()

-- | Get the value of the “<tt>cset_skip_characters</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scannerConfig #csetSkipCharacters
--   </pre>
getScannerConfigCsetSkipCharacters :: MonadIO m => ScannerConfig -> m (Maybe Text)

-- | Set the value of the “<tt>cset_skip_characters</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scannerConfig [ #csetSkipCharacters <a>:=</a> value ]
--   </pre>
setScannerConfigCsetSkipCharacters :: MonadIO m => ScannerConfig -> CString -> m ()

-- | Get the value of the “<tt>identifier_2_string</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scannerConfig #identifier2String
--   </pre>
getScannerConfigIdentifier2String :: MonadIO m => ScannerConfig -> m Word32

-- | Set the value of the “<tt>identifier_2_string</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scannerConfig [ #identifier2String <a>:=</a> value ]
--   </pre>
setScannerConfigIdentifier2String :: MonadIO m => ScannerConfig -> Word32 -> m ()

-- | Get the value of the “<tt>int_2_float</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scannerConfig #int2Float
--   </pre>
getScannerConfigInt2Float :: MonadIO m => ScannerConfig -> m Word32

-- | Set the value of the “<tt>int_2_float</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scannerConfig [ #int2Float <a>:=</a> value ]
--   </pre>
setScannerConfigInt2Float :: MonadIO m => ScannerConfig -> Word32 -> m ()

-- | Get the value of the “<tt>numbers_2_int</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scannerConfig #numbers2Int
--   </pre>
getScannerConfigNumbers2Int :: MonadIO m => ScannerConfig -> m Word32

-- | Set the value of the “<tt>numbers_2_int</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scannerConfig [ #numbers2Int <a>:=</a> value ]
--   </pre>
setScannerConfigNumbers2Int :: MonadIO m => ScannerConfig -> Word32 -> m ()

-- | Get the value of the “<tt>scan_binary</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scannerConfig #scanBinary
--   </pre>
getScannerConfigScanBinary :: MonadIO m => ScannerConfig -> m Word32

-- | Set the value of the “<tt>scan_binary</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scannerConfig [ #scanBinary <a>:=</a> value ]
--   </pre>
setScannerConfigScanBinary :: MonadIO m => ScannerConfig -> Word32 -> m ()

-- | Get the value of the “<tt>scan_comment_multi</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scannerConfig #scanCommentMulti
--   </pre>
getScannerConfigScanCommentMulti :: MonadIO m => ScannerConfig -> m Word32

-- | Set the value of the “<tt>scan_comment_multi</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scannerConfig [ #scanCommentMulti <a>:=</a> value ]
--   </pre>
setScannerConfigScanCommentMulti :: MonadIO m => ScannerConfig -> Word32 -> m ()

-- | Get the value of the “<tt>scan_float</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scannerConfig #scanFloat
--   </pre>
getScannerConfigScanFloat :: MonadIO m => ScannerConfig -> m Word32

-- | Set the value of the “<tt>scan_float</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scannerConfig [ #scanFloat <a>:=</a> value ]
--   </pre>
setScannerConfigScanFloat :: MonadIO m => ScannerConfig -> Word32 -> m ()

-- | Get the value of the “<tt>scan_hex</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scannerConfig #scanHex
--   </pre>
getScannerConfigScanHex :: MonadIO m => ScannerConfig -> m Word32

-- | Set the value of the “<tt>scan_hex</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scannerConfig [ #scanHex <a>:=</a> value ]
--   </pre>
setScannerConfigScanHex :: MonadIO m => ScannerConfig -> Word32 -> m ()

-- | Get the value of the “<tt>scan_hex_dollar</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scannerConfig #scanHexDollar
--   </pre>
getScannerConfigScanHexDollar :: MonadIO m => ScannerConfig -> m Word32

-- | Set the value of the “<tt>scan_hex_dollar</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scannerConfig [ #scanHexDollar <a>:=</a> value ]
--   </pre>
setScannerConfigScanHexDollar :: MonadIO m => ScannerConfig -> Word32 -> m ()

-- | Get the value of the “<tt>scan_identifier</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scannerConfig #scanIdentifier
--   </pre>
getScannerConfigScanIdentifier :: MonadIO m => ScannerConfig -> m Word32

-- | Set the value of the “<tt>scan_identifier</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scannerConfig [ #scanIdentifier <a>:=</a> value ]
--   </pre>
setScannerConfigScanIdentifier :: MonadIO m => ScannerConfig -> Word32 -> m ()

-- | Get the value of the “<tt>scan_identifier_1char</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scannerConfig #scanIdentifier1char
--   </pre>
getScannerConfigScanIdentifier1char :: MonadIO m => ScannerConfig -> m Word32

-- | Set the value of the “<tt>scan_identifier_1char</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scannerConfig [ #scanIdentifier1char <a>:=</a> value ]
--   </pre>
setScannerConfigScanIdentifier1char :: MonadIO m => ScannerConfig -> Word32 -> m ()

-- | Get the value of the “<tt>scan_identifier_NULL</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scannerConfig #scanIdentifierNULL
--   </pre>
getScannerConfigScanIdentifierNULL :: MonadIO m => ScannerConfig -> m Word32

-- | Set the value of the “<tt>scan_identifier_NULL</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scannerConfig [ #scanIdentifierNULL <a>:=</a> value ]
--   </pre>
setScannerConfigScanIdentifierNULL :: MonadIO m => ScannerConfig -> Word32 -> m ()

-- | Get the value of the “<tt>scan_octal</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scannerConfig #scanOctal
--   </pre>
getScannerConfigScanOctal :: MonadIO m => ScannerConfig -> m Word32

-- | Set the value of the “<tt>scan_octal</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scannerConfig [ #scanOctal <a>:=</a> value ]
--   </pre>
setScannerConfigScanOctal :: MonadIO m => ScannerConfig -> Word32 -> m ()

-- | Get the value of the “<tt>scan_string_dq</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scannerConfig #scanStringDq
--   </pre>
getScannerConfigScanStringDq :: MonadIO m => ScannerConfig -> m Word32

-- | Set the value of the “<tt>scan_string_dq</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scannerConfig [ #scanStringDq <a>:=</a> value ]
--   </pre>
setScannerConfigScanStringDq :: MonadIO m => ScannerConfig -> Word32 -> m ()

-- | Get the value of the “<tt>scan_string_sq</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scannerConfig #scanStringSq
--   </pre>
getScannerConfigScanStringSq :: MonadIO m => ScannerConfig -> m Word32

-- | Set the value of the “<tt>scan_string_sq</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scannerConfig [ #scanStringSq <a>:=</a> value ]
--   </pre>
setScannerConfigScanStringSq :: MonadIO m => ScannerConfig -> Word32 -> m ()

-- | Get the value of the “<tt>scan_symbols</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scannerConfig #scanSymbols
--   </pre>
getScannerConfigScanSymbols :: MonadIO m => ScannerConfig -> m Word32

-- | Set the value of the “<tt>scan_symbols</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scannerConfig [ #scanSymbols <a>:=</a> value ]
--   </pre>
setScannerConfigScanSymbols :: MonadIO m => ScannerConfig -> Word32 -> m ()

-- | Get the value of the “<tt>scope_0_fallback</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scannerConfig #scope0Fallback
--   </pre>
getScannerConfigScope0Fallback :: MonadIO m => ScannerConfig -> m Word32

-- | Set the value of the “<tt>scope_0_fallback</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scannerConfig [ #scope0Fallback <a>:=</a> value ]
--   </pre>
setScannerConfigScope0Fallback :: MonadIO m => ScannerConfig -> Word32 -> m ()

-- | Get the value of the “<tt>skip_comment_multi</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scannerConfig #skipCommentMulti
--   </pre>
getScannerConfigSkipCommentMulti :: MonadIO m => ScannerConfig -> m Word32

-- | Set the value of the “<tt>skip_comment_multi</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scannerConfig [ #skipCommentMulti <a>:=</a> value ]
--   </pre>
setScannerConfigSkipCommentMulti :: MonadIO m => ScannerConfig -> Word32 -> m ()

-- | Get the value of the “<tt>skip_comment_single</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scannerConfig #skipCommentSingle
--   </pre>
getScannerConfigSkipCommentSingle :: MonadIO m => ScannerConfig -> m Word32

-- | Set the value of the “<tt>skip_comment_single</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scannerConfig [ #skipCommentSingle <a>:=</a> value ]
--   </pre>
setScannerConfigSkipCommentSingle :: MonadIO m => ScannerConfig -> Word32 -> m ()

-- | Get the value of the “<tt>store_int64</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scannerConfig #storeInt64
--   </pre>
getScannerConfigStoreInt64 :: MonadIO m => ScannerConfig -> m Word32

-- | Set the value of the “<tt>store_int64</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scannerConfig [ #storeInt64 <a>:=</a> value ]
--   </pre>
setScannerConfigStoreInt64 :: MonadIO m => ScannerConfig -> Word32 -> m ()

-- | Get the value of the “<tt>symbol_2_token</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> scannerConfig #symbol2Token
--   </pre>
getScannerConfigSymbol2Token :: MonadIO m => ScannerConfig -> m Word32

-- | Set the value of the “<tt>symbol_2_token</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> scannerConfig [ #symbol2Token <a>:=</a> value ]
--   </pre>
setScannerConfigSymbol2Token :: MonadIO m => ScannerConfig -> Word32 -> m ()
instance Data.GI.Base.BasicTypes.BoxedPtr GI.GLib.Structs.ScannerConfig.ScannerConfig
instance Data.GI.Base.BasicTypes.CallocPtr GI.GLib.Structs.ScannerConfig.ScannerConfig
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.GLib.Structs.ScannerConfig.ScannerConfig tag
instance GHC.Classes.Eq GI.GLib.Structs.ScannerConfig.ScannerConfig
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GLib.Structs.ScannerConfig.ScannerConfig


-- | A type corresponding to the appropriate struct type for the
--   <tt><i>stat()</i></tt> system call, depending on the platform and/or
--   compiler being used.
--   
--   See <a>stat</a> for more information.
module GI.GLib.Structs.StatBuf

-- | Memory-managed wrapper type.
newtype StatBuf
StatBuf :: ManagedPtr StatBuf -> StatBuf
instance Data.GI.Base.BasicTypes.BoxedPtr GI.GLib.Structs.StatBuf.StatBuf
instance GHC.Classes.Eq GI.GLib.Structs.StatBuf.StatBuf
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GLib.Structs.StatBuf.StatBuf


-- | A <tt>GString</tt> is an object that handles the memory management of
--   a C string.
--   
--   The emphasis of <tt>GString</tt> is on text, typically UTF-8.
--   Crucially, the "str" member of a <tt>GString</tt> is guaranteed to
--   have a trailing nul character, and it is therefore always safe to call
--   functions such as <tt>strchr()</tt> or <tt>strdup()</tt> on it.
--   
--   However, a <tt>GString</tt> can also hold arbitrary binary data,
--   because it has a "len" member, which includes any possible embedded
--   nul characters in the data. Conceptually then, <tt>GString</tt> is
--   like a <tt>GByteArray</tt> with the addition of many convenience
--   methods for text, and a guaranteed nul terminator.
module GI.GLib.Structs.String

-- | Memory-managed wrapper type.
newtype String
String :: ManagedPtr String -> String

-- | Construct a <a>String</a> struct initialized to zero.
newZeroString :: MonadIO m => m String

-- | Adds a string onto the end of a <a>String</a>, expanding it if
--   necessary.
stringAppend :: (HasCallStack, MonadIO m) => String -> Text -> m String

-- | Adds a byte onto the end of a <a>String</a>, expanding it if
--   necessary.
stringAppendC :: (HasCallStack, MonadIO m) => String -> Int8 -> m String

-- | Appends <i><tt>len</tt></i> bytes of <i><tt>val</tt></i> to
--   <i><tt>string</tt></i>.
--   
--   If <i><tt>len</tt></i> is positive, <i><tt>val</tt></i> may contain
--   embedded nuls and need not be nul-terminated. It is the caller's
--   responsibility to ensure that <i><tt>val</tt></i> has at least
--   <i><tt>len</tt></i> addressable bytes.
--   
--   If <i><tt>len</tt></i> is negative, <i><tt>val</tt></i> must be
--   nul-terminated and <i><tt>len</tt></i> is considered to request the
--   entire string length. This makes <a>stringAppendLen</a> equivalent to
--   <a>stringAppend</a>.
stringAppendLen :: (HasCallStack, MonadIO m) => String -> Text -> Int64 -> m String

-- | Converts a Unicode character into UTF-8, and appends it to the string.
stringAppendUnichar :: (HasCallStack, MonadIO m) => String -> Char -> m String

-- | Appends <i><tt>unescaped</tt></i> to <i><tt>string</tt></i>, escaping
--   any characters that are reserved in URIs using URI-style escape
--   sequences.
--   
--   <i>Since: 2.16</i>
stringAppendUriEscaped :: (HasCallStack, MonadIO m) => String -> Text -> Text -> Bool -> m String

-- | Converts all uppercase ASCII letters to lowercase ASCII letters.
stringAsciiDown :: (HasCallStack, MonadIO m) => String -> m String

-- | Converts all lowercase ASCII letters to uppercase ASCII letters.
stringAsciiUp :: (HasCallStack, MonadIO m) => String -> m String

-- | Copies the bytes from a string into a <a>String</a>, destroying any
--   previous contents. It is rather like the standard
--   <tt><i>strcpy()</i></tt> function, except that you do not have to
--   worry about having enough space to copy the string.
stringAssign :: (HasCallStack, MonadIO m) => String -> Text -> m String

-- | Copies the <a>String</a> instance and its contents.
--   
--   This will preserve the allocation length of the <a>String</a> in the
--   copy.
--   
--   <i>Since: 2.86</i>
stringCopy :: (HasCallStack, MonadIO m) => String -> m String

-- | Converts a <a>String</a> to lowercase.

-- | <i>Deprecated: (Since version 2.2)This function uses the
--   locale-specific<tt><i>tolower()</i></tt> function, which is almost
--   never the right thing.Use <a>stringAsciiDown</a> or <a>utf8Strdown</a>
--   instead.</i>
stringDown :: (HasCallStack, MonadIO m) => String -> m String

-- | Compares two strings for equality, returning <a>True</a> if they are
--   equal. For use with <a>HashTable</a>.
stringEqual :: (HasCallStack, MonadIO m) => String -> String -> m Bool

-- | Removes <i><tt>len</tt></i> bytes from a <a>String</a>, starting at
--   position <i><tt>pos</tt></i>. The rest of the <a>String</a> is shifted
--   down to fill the gap.
stringErase :: (HasCallStack, MonadIO m) => String -> Int64 -> Int64 -> m String

-- | Frees the memory allocated for the <a>String</a>. If
--   <i><tt>freeSegment</tt></i> is <a>True</a> it also frees the character
--   data. If it's <a>False</a>, the caller gains ownership of the buffer
--   and must free it after use with <a>free</a>.
--   
--   Instead of passing <a>False</a> to this function, consider using
--   <a>stringFreeAndSteal</a>.
stringFree :: (HasCallStack, MonadIO m) => String -> Bool -> m (Maybe Text)

-- | Frees the memory allocated for the <a>String</a>.
--   
--   The caller gains ownership of the buffer and must free it after use
--   with <a>free</a>.
--   
--   <i>Since: 2.76</i>
stringFreeAndSteal :: (HasCallStack, MonadIO m) => String -> m Text

-- | Transfers ownership of the contents of <i><tt>string</tt></i> to a
--   newly allocated <a>Bytes</a>. The <a>String</a> structure itself is
--   deallocated, and it is therefore invalid to use <i><tt>string</tt></i>
--   after invoking this function.
--   
--   Note that while <a>String</a> ensures that its buffer always has a
--   trailing nul character (not reflected in its "len"), the returned
--   <a>Bytes</a> does not include this extra nul; i.e. it has length
--   exactly equal to the "len" member.
--   
--   <i>Since: 2.34</i>
stringFreeToBytes :: (HasCallStack, MonadIO m) => String -> m Bytes

-- | Creates a hash code for <i><tt>str</tt></i>; for use with
--   <a>HashTable</a>.
stringHash :: (HasCallStack, MonadIO m) => String -> m Word32

-- | Inserts a copy of a string into a <a>String</a>, expanding it if
--   necessary.
stringInsert :: (HasCallStack, MonadIO m) => String -> Int64 -> Text -> m String

-- | Inserts a byte into a <a>String</a>, expanding it if necessary.
stringInsertC :: (HasCallStack, MonadIO m) => String -> Int64 -> Int8 -> m String

-- | Inserts <i><tt>len</tt></i> bytes of <i><tt>val</tt></i> into
--   <i><tt>string</tt></i> at <i><tt>pos</tt></i>.
--   
--   If <i><tt>len</tt></i> is positive, <i><tt>val</tt></i> may contain
--   embedded nuls and need not be nul-terminated. It is the caller's
--   responsibility to ensure that <i><tt>val</tt></i> has at least
--   <i><tt>len</tt></i> addressable bytes.
--   
--   If <i><tt>len</tt></i> is negative, <i><tt>val</tt></i> must be
--   nul-terminated and <i><tt>len</tt></i> is considered to request the
--   entire string length.
--   
--   If <i><tt>pos</tt></i> is -1, bytes are inserted at the end of the
--   string.
stringInsertLen :: (HasCallStack, MonadIO m) => String -> Int64 -> Text -> Int64 -> m String

-- | Converts a Unicode character into UTF-8, and insert it into the string
--   at the given position.
stringInsertUnichar :: (HasCallStack, MonadIO m) => String -> Int64 -> Char -> m String

-- | Creates a new <a>String</a>, initialized with the given string.
stringNew :: (HasCallStack, MonadIO m) => Maybe Text -> m String

-- | Creates a new <a>String</a> with <i><tt>len</tt></i> bytes of the
--   <i><tt>init</tt></i> buffer. Because a length is provided,
--   <i><tt>init</tt></i> need not be nul-terminated, and can contain
--   embedded nul bytes.
--   
--   Since this function does not stop at nul bytes, it is the caller's
--   responsibility to ensure that <i><tt>init</tt></i> has at least
--   <i><tt>len</tt></i> addressable bytes.
stringNewLen :: (HasCallStack, MonadIO m) => Text -> Int64 -> m String

-- | Creates a new <a>String</a>, initialized with the given string.
--   
--   After this call, <i><tt>init</tt></i> belongs to the <a>String</a> and
--   may no longer be modified by the caller. The memory of
--   <i><tt>init</tt></i> has to be dynamically allocated and will
--   eventually be freed with <a>free</a>.
--   
--   <i>Since: 2.78</i>
stringNewTake :: (HasCallStack, MonadIO m) => Maybe Text -> m String

-- | Overwrites part of a string, lengthening it if necessary.
--   
--   <i>Since: 2.14</i>
stringOverwrite :: (HasCallStack, MonadIO m) => String -> CSize -> Text -> m String

-- | Overwrites part of a string, lengthening it if necessary. This
--   function will work with embedded nuls.
--   
--   <i>Since: 2.14</i>
stringOverwriteLen :: (HasCallStack, MonadIO m) => String -> CSize -> Text -> Int64 -> m String

-- | Adds a string on to the start of a <a>String</a>, expanding it if
--   necessary.
stringPrepend :: (HasCallStack, MonadIO m) => String -> Text -> m String

-- | Adds a byte onto the start of a <a>String</a>, expanding it if
--   necessary.
stringPrependC :: (HasCallStack, MonadIO m) => String -> Int8 -> m String

-- | Prepends <i><tt>len</tt></i> bytes of <i><tt>val</tt></i> to
--   <i><tt>string</tt></i>.
--   
--   If <i><tt>len</tt></i> is positive, <i><tt>val</tt></i> may contain
--   embedded nuls and need not be nul-terminated. It is the caller's
--   responsibility to ensure that <i><tt>val</tt></i> has at least
--   <i><tt>len</tt></i> addressable bytes.
--   
--   If <i><tt>len</tt></i> is negative, <i><tt>val</tt></i> must be
--   nul-terminated and <i><tt>len</tt></i> is considered to request the
--   entire string length. This makes <a>stringPrependLen</a> equivalent to
--   <a>stringPrepend</a>.
stringPrependLen :: (HasCallStack, MonadIO m) => String -> Text -> Int64 -> m String

-- | Converts a Unicode character into UTF-8, and prepends it to the
--   string.
stringPrependUnichar :: (HasCallStack, MonadIO m) => String -> Char -> m String

-- | Replaces the string <i><tt>find</tt></i> with the string
--   <i><tt>replace</tt></i> in a <a>String</a> up to <i><tt>limit</tt></i>
--   times. If the number of instances of <i><tt>find</tt></i> in the
--   <a>String</a> is less than <i><tt>limit</tt></i>, all instances are
--   replaced. If <i><tt>limit</tt></i> is <tt>0</tt>, all instances of
--   <i><tt>find</tt></i> are replaced.
--   
--   If <i><tt>find</tt></i> is the empty string, since versions 2.69.1 and
--   2.68.4 the replacement will be inserted no more than once per possible
--   position (beginning of string, end of string and between characters).
--   This did not work correctly in earlier versions.
--   
--   If <i><tt>limit</tt></i> is zero and more than <tt>G_MAXUINT</tt>
--   instances of <i><tt>find</tt></i> are in the input string, they will
--   all be replaced, but the return value will be capped at
--   <tt>G_MAXUINT</tt>.
--   
--   <i>Since: 2.68</i>
stringReplace :: (HasCallStack, MonadIO m) => String -> Text -> Text -> Word32 -> m Word32

-- | Sets the length of a <a>String</a>. If the length is less than the
--   current length, the string will be truncated. If the length is greater
--   than the current length, the contents of the newly added area are
--   undefined. (However, as always, string-&gt;str[string-&gt;len] will be
--   a nul byte.)
stringSetSize :: (HasCallStack, MonadIO m) => String -> CSize -> m String

-- | Creates a new <a>String</a>, with enough space for
--   <i><tt>dflSize</tt></i> bytes. This is useful if you are going to add
--   a lot of text to the string and don't want it to be reallocated too
--   often.
stringSizedNew :: (HasCallStack, MonadIO m) => CSize -> m String

-- | Cuts off the end of the GString, leaving the first <i><tt>len</tt></i>
--   bytes.
stringTruncate :: (HasCallStack, MonadIO m) => String -> CSize -> m String

-- | Converts a <a>String</a> to uppercase.

-- | <i>Deprecated: (Since version 2.2)This function uses the
--   locale-specific<tt><i>toupper()</i></tt> function, which is almost
--   never the right thing.Use <a>stringAsciiUp</a> or <a>utf8Strup</a>
--   instead.</i>
stringUp :: (HasCallStack, MonadIO m) => String -> m String

-- | Get the value of the “<tt>allocated_len</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> string #allocatedLen
--   </pre>
getStringAllocatedLen :: MonadIO m => String -> m CSize

-- | Set the value of the “<tt>allocated_len</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> string [ #allocatedLen <a>:=</a> value ]
--   </pre>
setStringAllocatedLen :: MonadIO m => String -> CSize -> m ()

-- | Get the value of the “<tt>len</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> string #len
--   </pre>
getStringLen :: MonadIO m => String -> m CSize

-- | Set the value of the “<tt>len</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> string [ #len <a>:=</a> value ]
--   </pre>
setStringLen :: MonadIO m => String -> CSize -> m ()

-- | Set the value of the “<tt>str</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #str
--   </pre>
clearStringStr :: MonadIO m => String -> m ()

-- | Get the value of the “<tt>str</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> string #str
--   </pre>
getStringStr :: MonadIO m => String -> m (Maybe Text)

-- | Set the value of the “<tt>str</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> string [ #str <a>:=</a> value ]
--   </pre>
setStringStr :: MonadIO m => String -> CString -> m ()
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.GLib.Structs.String.String tag
instance GHC.Classes.Eq GI.GLib.Structs.String.String
instance Data.GI.Base.BasicTypes.GBoxed GI.GLib.Structs.String.String
instance Data.GI.Base.Overloading.HasParentTypes GI.GLib.Structs.String.String
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.GLib.Structs.String.String)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GLib.Structs.String.String
instance Data.GI.Base.BasicTypes.TypedObject GI.GLib.Structs.String.String


-- | <tt>GStringChunk</tt> provides efficient storage of groups of strings
--   
--   String chunks are used to store groups of strings. Memory is allocated
--   in blocks, and as strings are added to the <tt>GStringChunk</tt> they
--   are copied into the next free position in a block. When a block is
--   full a new block is allocated.
--   
--   When storing a large number of strings, string chunks are more
--   efficient than using <a>strdup</a> since fewer calls to
--   <tt>malloc()</tt> are needed, and less memory is wasted in memory
--   allocation overheads.
--   
--   By adding strings with <a>stringChunkInsertConst</a> it is also
--   possible to remove duplicates.
--   
--   To create a new <tt>GStringChunk</tt> use
--   <a>StringChunk</a>.<tt><i>new</i></tt>().
--   
--   To add strings to a <tt>GStringChunk</tt> use
--   <a>stringChunkInsert</a>.
--   
--   To add strings to a <tt>GStringChunk</tt>, but without duplicating
--   strings which are already in the <tt>GStringChunk</tt>, use
--   <a>stringChunkInsertConst</a>.
--   
--   To free the entire <tt>GStringChunk</tt> use <a>stringChunkFree</a>.
--   It is not possible to free individual strings.
module GI.GLib.Structs.StringChunk

-- | Memory-managed wrapper type.
newtype StringChunk
StringChunk :: ManagedPtr StringChunk -> StringChunk

-- | Frees all strings contained within the <a>StringChunk</a>. After
--   calling <a>stringChunkClear</a> it is not safe to access any of the
--   strings which were contained within it.
--   
--   <i>Since: 2.14</i>
stringChunkClear :: (HasCallStack, MonadIO m) => StringChunk -> m ()

-- | Adds a copy of <i><tt>string</tt></i> to the <a>StringChunk</a>. It
--   returns a pointer to the new copy of the string in the
--   <a>StringChunk</a>. The characters in the string can be changed, if
--   necessary, though you should not change anything after the end of the
--   string.
--   
--   Unlike <a>stringChunkInsertConst</a>, this function does not check for
--   duplicates. Also strings added with <a>stringChunkInsert</a> will not
--   be searched by <a>stringChunkInsertConst</a> when looking for
--   duplicates.
stringChunkInsert :: (HasCallStack, MonadIO m) => StringChunk -> Text -> m Text

-- | Adds a copy of <i><tt>string</tt></i> to the <a>StringChunk</a>,
--   unless the same string has already been added to the
--   <a>StringChunk</a> with <a>stringChunkInsertConst</a>.
--   
--   This function is useful if you need to copy a large number of strings
--   but do not want to waste space storing duplicates. But you must
--   remember that there may be several pointers to the same string, and so
--   any changes made to the strings should be done very carefully.
--   
--   Note that <a>stringChunkInsertConst</a> will not return a pointer to a
--   string added with <a>stringChunkInsert</a>, even if they do match.
stringChunkInsertConst :: (HasCallStack, MonadIO m) => StringChunk -> Text -> m Text

-- | Adds a copy of the first <i><tt>len</tt></i> bytes of
--   <i><tt>string</tt></i> to the <a>StringChunk</a>. The copy is
--   nul-terminated.
--   
--   Since this function does not stop at nul bytes, it is the caller's
--   responsibility to ensure that <i><tt>string</tt></i> has at least
--   <i><tt>len</tt></i> addressable bytes.
--   
--   The characters in the returned string can be changed, if necessary,
--   though you should not change anything after the end of the string.
--   
--   <i>Since: 2.4</i>
stringChunkInsertLen :: (HasCallStack, MonadIO m) => StringChunk -> Text -> Int64 -> m Text
instance Data.GI.Base.BasicTypes.BoxedPtr GI.GLib.Structs.StringChunk.StringChunk
instance GHC.Classes.Eq GI.GLib.Structs.StringChunk.StringChunk
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GLib.Structs.StringChunk.StringChunk


-- | <tt>GStrvBuilder</tt> is a helper object to build a
--   <a>Nothing</a>-terminated string arrays.
--   
--   The following example shows how to build a two element array:
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   g_autoptr(GStrvBuilder) builder = g_strv_builder_new ();
--   g_strv_builder_add (builder, "hello");
--   g_strv_builder_add (builder, "world");
--   
--   g_auto(GStrv) array = g_strv_builder_end (builder);
--   
--   g_assert_true (g_strv_equal (array, (const char *[]) { "hello", "world", NULL }));
--   </pre>
--   
--   <i>Since: 2.68</i>
module GI.GLib.Structs.StrvBuilder

-- | Memory-managed wrapper type.
newtype StrvBuilder
StrvBuilder :: ManagedPtr StrvBuilder -> StrvBuilder

-- | Add a string to the end of the array.
--   
--   Since 2.68
strvBuilderAdd :: (HasCallStack, MonadIO m) => StrvBuilder -> Text -> m ()

-- | Appends all the strings in the given vector to the builder.
--   
--   Since 2.70
strvBuilderAddv :: (HasCallStack, MonadIO m) => StrvBuilder -> [Text] -> m ()

-- | Ends the builder process and returns the constructed NULL-terminated
--   string array. The returned value should be freed with <a>strfreev</a>
--   when no longer needed.
strvBuilderEnd :: (HasCallStack, MonadIO m) => StrvBuilder -> m [Text]

-- | Creates a new <a>StrvBuilder</a> with a reference count of 1. Use
--   <a>strvBuilderUnref</a> on the returned value when no longer needed.
--   
--   <i>Since: 2.68</i>
strvBuilderNew :: (HasCallStack, MonadIO m) => m StrvBuilder

-- | Atomically increments the reference count of <i><tt>builder</tt></i>
--   by one. This function is thread-safe and may be called from any
--   thread.
--   
--   <i>Since: 2.68</i>
strvBuilderRef :: (HasCallStack, MonadIO m) => StrvBuilder -> m StrvBuilder

-- | Add a string to the end of the array. After <i><tt>value</tt></i>
--   belongs to the <a>StrvBuilder</a> and may no longer be modified by the
--   caller.
--   
--   Since 2.80
strvBuilderTake :: (HasCallStack, MonadIO m) => StrvBuilder -> Text -> m ()

-- | Decreases the reference count on <i><tt>builder</tt></i>.
--   
--   In the event that there are no more references, releases all memory
--   associated with the <a>StrvBuilder</a>.
--   
--   <i>Since: 2.68</i>
strvBuilderUnref :: (HasCallStack, MonadIO m) => StrvBuilder -> m ()

-- | Decreases the reference count on the string vector builder, and
--   returns its contents as a <tt>NULL</tt>-terminated string array.
--   
--   This function is especially useful for cases where it's not possible
--   to use <tt>g_autoptr()</tt>.
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   GStrvBuilder *builder = g_strv_builder_new ();
--   g_strv_builder_add (builder, "hello");
--   g_strv_builder_add (builder, "world");
--   
--   GStrv array = g_strv_builder_unref_to_strv (builder);
--   
--   g_assert_true (g_strv_equal (array, (const char *[]) { "hello", "world", NULL }));
--   
--   g_strfreev (array);
--   </pre>
--   
--   <i>Since: 2.82</i>
strvBuilderUnrefToStrv :: (HasCallStack, MonadIO m) => StrvBuilder -> m [Text]
instance GHC.Classes.Eq GI.GLib.Structs.StrvBuilder.StrvBuilder
instance Data.GI.Base.BasicTypes.GBoxed GI.GLib.Structs.StrvBuilder.StrvBuilder
instance Data.GI.Base.Overloading.HasParentTypes GI.GLib.Structs.StrvBuilder.StrvBuilder
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.GLib.Structs.StrvBuilder.StrvBuilder)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GLib.Structs.StrvBuilder.StrvBuilder
instance Data.GI.Base.BasicTypes.TypedObject GI.GLib.Structs.StrvBuilder.StrvBuilder


-- | An opaque structure representing a test case.
module GI.GLib.Structs.TestCase

-- | Memory-managed wrapper type.
newtype TestCase
TestCase :: ManagedPtr TestCase -> TestCase

-- | Free the <i><tt>testCase</tt></i>.
--   
--   <i>Since: 2.70</i>
testCaseFree :: (HasCallStack, MonadIO m) => TestCase -> m ()
instance Data.GI.Base.BasicTypes.BoxedPtr GI.GLib.Structs.TestCase.TestCase
instance GHC.Classes.Eq GI.GLib.Structs.TestCase.TestCase
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GLib.Structs.TestCase.TestCase


-- | <i>No description available in the introspection data.</i>
module GI.GLib.Structs.TestConfig

-- | Memory-managed wrapper type.
newtype TestConfig
TestConfig :: ManagedPtr TestConfig -> TestConfig

-- | Construct a <a>TestConfig</a> struct initialized to zero.
newZeroTestConfig :: MonadIO m => m TestConfig

-- | Get the value of the “<tt>test_initialized</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> testConfig #testInitialized
--   </pre>
getTestConfigTestInitialized :: MonadIO m => TestConfig -> m Bool

-- | Set the value of the “<tt>test_initialized</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> testConfig [ #testInitialized <a>:=</a> value ]
--   </pre>
setTestConfigTestInitialized :: MonadIO m => TestConfig -> Bool -> m ()

-- | Get the value of the “<tt>test_perf</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> testConfig #testPerf
--   </pre>
getTestConfigTestPerf :: MonadIO m => TestConfig -> m Bool

-- | Set the value of the “<tt>test_perf</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> testConfig [ #testPerf <a>:=</a> value ]
--   </pre>
setTestConfigTestPerf :: MonadIO m => TestConfig -> Bool -> m ()

-- | Get the value of the “<tt>test_quick</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> testConfig #testQuick
--   </pre>
getTestConfigTestQuick :: MonadIO m => TestConfig -> m Bool

-- | Set the value of the “<tt>test_quick</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> testConfig [ #testQuick <a>:=</a> value ]
--   </pre>
setTestConfigTestQuick :: MonadIO m => TestConfig -> Bool -> m ()

-- | Get the value of the “<tt>test_quiet</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> testConfig #testQuiet
--   </pre>
getTestConfigTestQuiet :: MonadIO m => TestConfig -> m Bool

-- | Set the value of the “<tt>test_quiet</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> testConfig [ #testQuiet <a>:=</a> value ]
--   </pre>
setTestConfigTestQuiet :: MonadIO m => TestConfig -> Bool -> m ()

-- | Get the value of the “<tt>test_undefined</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> testConfig #testUndefined
--   </pre>
getTestConfigTestUndefined :: MonadIO m => TestConfig -> m Bool

-- | Set the value of the “<tt>test_undefined</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> testConfig [ #testUndefined <a>:=</a> value ]
--   </pre>
setTestConfigTestUndefined :: MonadIO m => TestConfig -> Bool -> m ()

-- | Get the value of the “<tt>test_verbose</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> testConfig #testVerbose
--   </pre>
getTestConfigTestVerbose :: MonadIO m => TestConfig -> m Bool

-- | Set the value of the “<tt>test_verbose</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> testConfig [ #testVerbose <a>:=</a> value ]
--   </pre>
setTestConfigTestVerbose :: MonadIO m => TestConfig -> Bool -> m ()
instance Data.GI.Base.BasicTypes.BoxedPtr GI.GLib.Structs.TestConfig.TestConfig
instance Data.GI.Base.BasicTypes.CallocPtr GI.GLib.Structs.TestConfig.TestConfig
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.GLib.Structs.TestConfig.TestConfig tag
instance GHC.Classes.Eq GI.GLib.Structs.TestConfig.TestConfig
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GLib.Structs.TestConfig.TestConfig


-- | <i>No description available in the introspection data.</i>
module GI.GLib.Structs.TestLogBuffer

-- | Memory-managed wrapper type.
newtype TestLogBuffer
TestLogBuffer :: ManagedPtr TestLogBuffer -> TestLogBuffer

-- | Construct a <a>TestLogBuffer</a> struct initialized to zero.
newZeroTestLogBuffer :: MonadIO m => m TestLogBuffer

-- | Internal function for gtester to free test log messages, no ABI
--   guarantees provided.
testLogBufferFree :: (HasCallStack, MonadIO m) => TestLogBuffer -> m ()

-- | Internal function for gtester to decode test log messages, no ABI
--   guarantees provided.
testLogBufferPush :: (HasCallStack, MonadIO m) => TestLogBuffer -> Word32 -> Word8 -> m ()
instance Data.GI.Base.BasicTypes.BoxedPtr GI.GLib.Structs.TestLogBuffer.TestLogBuffer
instance Data.GI.Base.BasicTypes.CallocPtr GI.GLib.Structs.TestLogBuffer.TestLogBuffer
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.GLib.Structs.TestLogBuffer.TestLogBuffer tag
instance GHC.Classes.Eq GI.GLib.Structs.TestLogBuffer.TestLogBuffer
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GLib.Structs.TestLogBuffer.TestLogBuffer


-- | <i>No description available in the introspection data.</i>
module GI.GLib.Structs.TestLogMsg

-- | Memory-managed wrapper type.
newtype TestLogMsg
TestLogMsg :: ManagedPtr TestLogMsg -> TestLogMsg

-- | Construct a <a>TestLogMsg</a> struct initialized to zero.
newZeroTestLogMsg :: MonadIO m => m TestLogMsg

-- | Internal function for gtester to free test log messages, no ABI
--   guarantees provided.
testLogMsgFree :: (HasCallStack, MonadIO m) => TestLogMsg -> m ()

-- | Get the value of the “<tt>log_type</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> testLogMsg #logType
--   </pre>
getTestLogMsgLogType :: MonadIO m => TestLogMsg -> m TestLogType

-- | Set the value of the “<tt>log_type</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> testLogMsg [ #logType <a>:=</a> value ]
--   </pre>
setTestLogMsgLogType :: MonadIO m => TestLogMsg -> TestLogType -> m ()

-- | Get the value of the “<tt>n_nums</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> testLogMsg #nNums
--   </pre>
getTestLogMsgNNums :: MonadIO m => TestLogMsg -> m Word32

-- | Set the value of the “<tt>n_nums</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> testLogMsg [ #nNums <a>:=</a> value ]
--   </pre>
setTestLogMsgNNums :: MonadIO m => TestLogMsg -> Word32 -> m ()

-- | Get the value of the “<tt>n_strings</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> testLogMsg #nStrings
--   </pre>
getTestLogMsgNStrings :: MonadIO m => TestLogMsg -> m Word32

-- | Set the value of the “<tt>n_strings</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> testLogMsg [ #nStrings <a>:=</a> value ]
--   </pre>
setTestLogMsgNStrings :: MonadIO m => TestLogMsg -> Word32 -> m ()

-- | Set the value of the “<tt>strings</tt>” field to <a>Nothing</a>. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>clear</a> #strings
--   </pre>
clearTestLogMsgStrings :: MonadIO m => TestLogMsg -> m ()

-- | Get the value of the “<tt>strings</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> testLogMsg #strings
--   </pre>
getTestLogMsgStrings :: MonadIO m => TestLogMsg -> m (Maybe Text)

-- | Set the value of the “<tt>strings</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> testLogMsg [ #strings <a>:=</a> value ]
--   </pre>
setTestLogMsgStrings :: MonadIO m => TestLogMsg -> CString -> m ()
instance Data.GI.Base.BasicTypes.BoxedPtr GI.GLib.Structs.TestLogMsg.TestLogMsg
instance Data.GI.Base.BasicTypes.CallocPtr GI.GLib.Structs.TestLogMsg.TestLogMsg
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.GLib.Structs.TestLogMsg.TestLogMsg tag
instance GHC.Classes.Eq GI.GLib.Structs.TestLogMsg.TestLogMsg
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GLib.Structs.TestLogMsg.TestLogMsg


-- | An opaque structure representing a test suite.
module GI.GLib.Structs.TestSuite

-- | Memory-managed wrapper type.
newtype TestSuite
TestSuite :: ManagedPtr TestSuite -> TestSuite

-- | Adds <i><tt>testCase</tt></i> to <i><tt>suite</tt></i>.
--   
--   <i>Since: 2.16</i>
testSuiteAdd :: (HasCallStack, MonadIO m) => TestSuite -> TestCase -> m ()

-- | Adds <i><tt>nestedsuite</tt></i> to <i><tt>suite</tt></i>.
--   
--   <i>Since: 2.16</i>
testSuiteAddSuite :: (HasCallStack, MonadIO m) => TestSuite -> TestSuite -> m ()

-- | Frees the <i><tt>suite</tt></i> and all nested suites.
--   
--   <i>Since: 2.70</i>
testSuiteFree :: (HasCallStack, MonadIO m) => TestSuite -> m ()
instance Data.GI.Base.BasicTypes.BoxedPtr GI.GLib.Structs.TestSuite.TestSuite
instance GHC.Classes.Eq GI.GLib.Structs.TestSuite.TestSuite
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GLib.Structs.TestSuite.TestSuite


-- | Represents a precise time, with seconds and microseconds.
--   
--   Similar to the struct timeval returned by the <tt>gettimeofday()</tt>
--   UNIX system call.
--   
--   GLib is attempting to unify around the use of 64-bit integers to
--   represent microsecond-precision time. As such, this type will be
--   removed from a future version of GLib. A consequence of using
--   <tt>glong</tt> for <tt>tv_sec</tt> is that on 32-bit systems
--   <tt>GTimeVal</tt> is subject to the year 2038 problem.
module GI.GLib.Structs.TimeVal

-- | Memory-managed wrapper type.
newtype TimeVal
TimeVal :: ManagedPtr TimeVal -> TimeVal

-- | Construct a <a>TimeVal</a> struct initialized to zero.
newZeroTimeVal :: MonadIO m => m TimeVal

-- | Adds the given number of microseconds to <i><tt>time_</tt></i>.
--   <i><tt>microseconds</tt></i> can also be negative to decrease the
--   value of <i><tt>time_</tt></i>.

-- | <i>Deprecated: (Since version 2.62)<a>TimeVal</a> is not
--   year-2038-safe. Use <tt>guint64</tt> forrepresenting microseconds
--   since the epoch, or use <a>DateTime</a>.</i>
timeValAdd :: (HasCallStack, MonadIO m) => TimeVal -> CLong -> m ()

-- | Converts a string containing an ISO 8601 encoded date and time to a
--   <a>TimeVal</a> and puts it into <i><tt>time_</tt></i>.
--   
--   <i><tt>isoDate</tt></i> must include year, month, day, hours, minutes,
--   and seconds. It can optionally include fractions of a second and a
--   time zone indicator. (In the absence of any time zone indication, the
--   timestamp is assumed to be in local time.)
--   
--   Any leading or trailing space in <i><tt>isoDate</tt></i> is ignored.
--   
--   This function was deprecated, along with <a>TimeVal</a> itself, in
--   GLib 2.62. Equivalent functionality is available using code like:
--   
--   <pre>
--   GDateTime *dt = g_date_time_new_from_iso8601 (iso8601_string, NULL);
--   gint64 time_val = g_date_time_to_unix (dt);
--   g_date_time_unref (dt);
--   </pre>
--   
--   <i>Since: 2.12</i>

-- | <i>Deprecated: (Since version 2.62)<a>TimeVal</a> is not
--   year-2038-safe. Use<a>dateTimeNewFromIso8601</a> instead.</i>
timeValFromIso8601 :: (HasCallStack, MonadIO m) => Text -> m (Bool, TimeVal)

-- | Converts <i><tt>time_</tt></i> into an RFC 3339 encoded string,
--   relative to the Coordinated Universal Time (UTC). This is one of the
--   many formats allowed by ISO 8601.
--   
--   ISO 8601 allows a large number of date/time formats, with or without
--   punctuation and optional elements. The format returned by this
--   function is a complete date and time, with optional punctuation
--   included, the UTC time zone represented as "Z", and the
--   <i><tt>tvUsec</tt></i> part included if and only if it is nonzero,
--   i.e. either "YYYY-MM-DDTHH:MM:SSZ" or "YYYY-MM-DDTHH:MM:SS.fffffZ".
--   
--   This corresponds to the Internet date/time format defined by <a>RFC
--   3339</a>, and to either of the two most-precise formats defined by the
--   W3C Note <a>Date and Time Formats</a>. Both of these documents are
--   profiles of ISO 8601.
--   
--   Use <a>dateTimeFormat</a> or <tt><i>g_strdup_printf()</i></tt> if a
--   different variation of ISO 8601 format is required.
--   
--   If <i><tt>time_</tt></i> represents a date which is too large to fit
--   into a <tt>struct tm</tt>, <a>Nothing</a> will be returned. This is
--   platform dependent. Note also that since <tt>GTimeVal</tt> stores the
--   number of seconds as a <tt>glong</tt>, on 32-bit systems it is subject
--   to the year 2038 problem. Accordingly, since GLib 2.62, this function
--   has been deprecated. Equivalent functionality is available using:
--   
--   <pre>
--   GDateTime *dt = g_date_time_new_from_unix_utc (time_val);
--   iso8601_string = g_date_time_format_iso8601 (dt);
--   g_date_time_unref (dt);
--   </pre>
--   
--   The return value of <a>timeValToIso8601</a> has been nullable since
--   GLib 2.54; before then, GLib would crash under the same conditions.
--   
--   <i>Since: 2.12</i>

-- | <i>Deprecated: (Since version 2.62)<a>TimeVal</a> is not
--   year-2038-safe. Useg_date_time_format_iso8601(dt) instead.</i>
timeValToIso8601 :: (HasCallStack, MonadIO m) => TimeVal -> m (Maybe Text)

-- | Get the value of the “<tt>tv_sec</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> timeVal #tvSec
--   </pre>
getTimeValTvSec :: MonadIO m => TimeVal -> m CLong

-- | Set the value of the “<tt>tv_sec</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> timeVal [ #tvSec <a>:=</a> value ]
--   </pre>
setTimeValTvSec :: MonadIO m => TimeVal -> CLong -> m ()

-- | Get the value of the “<tt>tv_usec</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> timeVal #tvUsec
--   </pre>
getTimeValTvUsec :: MonadIO m => TimeVal -> m CLong

-- | Set the value of the “<tt>tv_usec</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> timeVal [ #tvUsec <a>:=</a> value ]
--   </pre>
setTimeValTvUsec :: MonadIO m => TimeVal -> CLong -> m ()
instance Data.GI.Base.BasicTypes.BoxedPtr GI.GLib.Structs.TimeVal.TimeVal
instance Data.GI.Base.BasicTypes.CallocPtr GI.GLib.Structs.TimeVal.TimeVal
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.GLib.Structs.TimeVal.TimeVal tag
instance GHC.Classes.Eq GI.GLib.Structs.TimeVal.TimeVal
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GLib.Structs.TimeVal.TimeVal


-- | <tt>GDate</tt> is a struct for calendrical calculations.
--   
--   The <tt>GDate</tt> data structure represents a day between January 1,
--   Year 1, and sometime a few thousand years in the future (right now it
--   will go to the year 65535 or so, but <a>dateSetParse</a> only parses
--   up to the year 8000 or so - just count on "a few thousand").
--   <tt>GDate</tt> is meant to represent everyday dates, not astronomical
--   dates or historical dates or ISO timestamps or the like. It
--   extrapolates the current Gregorian calendar forward and backward in
--   time; there is no attempt to change the calendar to match time periods
--   or locations. <tt>GDate</tt> does not store time information; it
--   represents a day.
--   
--   The <tt>GDate</tt> implementation has several nice features; it is
--   only a 64-bit struct, so storing large numbers of dates is very
--   efficient. It can keep both a Julian and day-month-year representation
--   of the date, since some calculations are much easier with one
--   representation or the other. A Julian representation is simply a count
--   of days since some fixed day in the past; for <a>Date</a> the fixed
--   day is January 1, 1 AD. ("Julian" dates in the <a>Date</a> API aren't
--   really Julian dates in the technical sense; technically, Julian dates
--   count from the start of the Julian period, Jan 1, 4713 BC).
--   
--   <tt>GDate</tt> is simple to use. First you need a "blank" date; you
--   can get a dynamically allocated date from <a>dateNew</a>, or you can
--   declare an automatic variable or array and initialize it by calling
--   <a>dateClear</a>. A cleared date is safe; it's safe to call
--   <a>dateSetDmy</a> and the other mutator functions to initialize the
--   value of a cleared date. However, a cleared date is initially invalid,
--   meaning that it doesn't represent a day that exists. It is undefined
--   to call any of the date calculation routines on an invalid date. If
--   you obtain a date from a user or other unpredictable source, you
--   should check its validity with the <a>dateValid</a> predicate.
--   <a>dateValid</a> is also used to check for errors with
--   <a>dateSetParse</a> and other functions that can fail. Dates can be
--   invalidated by calling <a>dateClear</a> again.
--   
--   It is very important to use the API to access the <tt>GDate</tt>
--   struct. Often only the day-month-year or only the Julian
--   representation is valid. Sometimes neither is valid. Use the API.
--   
--   GLib also features <tt>GDateTime</tt> which represents a precise time.
module GI.GLib.Structs.Date

-- | Memory-managed wrapper type.
newtype Date
Date :: ManagedPtr Date -> Date

-- | Construct a <a>Date</a> struct initialized to zero.
newZeroDate :: MonadIO m => m Date

-- | Increments a date some number of days. To move forward by weeks, add
--   weeks*7 days. The date must be valid.
dateAddDays :: (HasCallStack, MonadIO m) => Date -> Word32 -> m ()

-- | Increments a date by some number of months. If the day of the month is
--   greater than 28, this routine may change the day of the month (because
--   the destination month may not have the current day in it). The date
--   must be valid.
dateAddMonths :: (HasCallStack, MonadIO m) => Date -> Word32 -> m ()

-- | Increments a date by some number of years. If the date is February 29,
--   and the destination year is not a leap year, the date will be changed
--   to February 28. The date must be valid.
dateAddYears :: (HasCallStack, MonadIO m) => Date -> Word32 -> m ()

-- | If <i><tt>date</tt></i> is prior to <i><tt>minDate</tt></i>, sets
--   <i><tt>date</tt></i> equal to <i><tt>minDate</tt></i>. If
--   <i><tt>date</tt></i> falls after <i><tt>maxDate</tt></i>, sets
--   <i><tt>date</tt></i> equal to <i><tt>maxDate</tt></i>. Otherwise,
--   <i><tt>date</tt></i> is unchanged. Either of <i><tt>minDate</tt></i>
--   and <i><tt>maxDate</tt></i> may be <a>Nothing</a>. All
--   non-<a>Nothing</a> dates must be valid.
dateClamp :: (HasCallStack, MonadIO m) => Date -> Date -> Date -> m ()

-- | Initializes one or more <a>Date</a> structs to a safe but invalid
--   state. The cleared dates will not represent an existing date, but will
--   not contain garbage. Useful to init a date declared on the stack.
--   Validity can be tested with <a>dateValid</a>.
dateClear :: (HasCallStack, MonadIO m) => Date -> Word32 -> m ()

-- | <tt><i>qsort()</i></tt>-style comparison function for dates. Both
--   dates must be valid.
dateCompare :: (HasCallStack, MonadIO m) => Date -> Date -> m Int32

-- | Copies a GDate to a newly-allocated GDate. If the input was invalid
--   (as determined by <a>dateValid</a>), the invalid state will be copied
--   as is into the new object.
--   
--   <i>Since: 2.56</i>
dateCopy :: (HasCallStack, MonadIO m) => Date -> m Date

-- | Computes the number of days between two dates. If
--   <i><tt>date2</tt></i> is prior to <i><tt>date1</tt></i>, the returned
--   value is negative. Both dates must be valid.
dateDaysBetween :: (HasCallStack, MonadIO m) => Date -> Date -> m Int32

-- | Frees a <a>Date</a> returned from <a>dateNew</a>.
dateFree :: (HasCallStack, MonadIO m) => Date -> m ()

-- | Returns the day of the month. The date must be valid.
dateGetDay :: (HasCallStack, MonadIO m) => Date -> m Word8

-- | Returns the day of the year, where Jan 1 is the first day of the year.
--   The date must be valid.
dateGetDayOfYear :: (HasCallStack, MonadIO m) => Date -> m Word32

-- | Returns the number of days in a month, taking leap years into account.
dateGetDaysInMonth :: (HasCallStack, MonadIO m) => DateMonth -> Word16 -> m Word8

-- | Returns the week of the year, where weeks are interpreted according to
--   ISO 8601.
--   
--   <i>Since: 2.6</i>
dateGetIso8601WeekOfYear :: (HasCallStack, MonadIO m) => Date -> m Word32

-- | Returns the Julian day or "serial number" of the <a>Date</a>. The
--   Julian day is simply the number of days since January 1, Year 1; i.e.,
--   January 1, Year 1 is Julian day 1; January 2, Year 1 is Julian day 2,
--   etc. The date must be valid.
dateGetJulian :: (HasCallStack, MonadIO m) => Date -> m Word32

-- | Returns the week of the year, where weeks are understood to start on
--   Monday. If the date is before the first Monday of the year, return 0.
--   The date must be valid.
dateGetMondayWeekOfYear :: (HasCallStack, MonadIO m) => Date -> m Word32

-- | Returns the number of weeks in the year, where weeks are taken to
--   start on Monday. Will be 52 or 53. The date must be valid. (Years
--   always have 52 7-day periods, plus 1 or 2 extra days depending on
--   whether it's a leap year. This function is basically telling you how
--   many Mondays are in the year, i.e. there are 53 Mondays if one of the
--   extra days happens to be a Monday.)
dateGetMondayWeeksInYear :: (HasCallStack, MonadIO m) => Word16 -> m Word8

-- | Returns the month of the year. The date must be valid.
dateGetMonth :: (HasCallStack, MonadIO m) => Date -> m DateMonth

-- | Returns the week of the year during which this date falls, if weeks
--   are understood to begin on Sunday. The date must be valid. Can return
--   0 if the day is before the first Sunday of the year.
dateGetSundayWeekOfYear :: (HasCallStack, MonadIO m) => Date -> m Word32

-- | Returns the number of weeks in the year, where weeks are taken to
--   start on Sunday. Will be 52 or 53. The date must be valid. (Years
--   always have 52 7-day periods, plus 1 or 2 extra days depending on
--   whether it's a leap year. This function is basically telling you how
--   many Sundays are in the year, i.e. there are 53 Sundays if one of the
--   extra days happens to be a Sunday.)
dateGetSundayWeeksInYear :: (HasCallStack, MonadIO m) => Word16 -> m Word8

-- | Calculates the week of the year during which this date falls.
--   
--   The result depends on which day is considered the first day of the
--   week, which varies by locale. Both <tt>date</tt> and
--   <tt>first_day_of_week</tt> must be valid.
--   
--   If <i><tt>date</tt></i> is before the start of the first week of the
--   year (for example, before the first Monday in January if
--   <i><tt>firstDayOfWeek</tt></i> is <a>DateWeekdayMonday</a>) then zero
--   will be returned.
--   
--   <i>Since: 2.86</i>
dateGetWeekOfYear :: (HasCallStack, MonadIO m) => Date -> DateWeekday -> m Word32

-- | Returns the day of the week for a <a>Date</a>. The date must be valid.
dateGetWeekday :: (HasCallStack, MonadIO m) => Date -> m DateWeekday

-- | Calculates the number of weeks in the year.
--   
--   The result depends on which day is considered the first day of the
--   week, which varies by locale. <tt>first_day_of_week</tt> must be
--   valid.
--   
--   The result will be either 52 or 53. Years always have 52 seven-day
--   periods, plus one or two extra days depending on whether it’s a leap
--   year. This function effectively calculates how many
--   <i><tt>firstDayOfWeek</tt></i> days there are in the year.
--   
--   <i>Since: 2.86</i>
dateGetWeeksInYear :: (HasCallStack, MonadIO m) => Word16 -> DateWeekday -> m Word8

-- | Returns the year of a <a>Date</a>. The date must be valid.
dateGetYear :: (HasCallStack, MonadIO m) => Date -> m Word16

-- | Returns <a>True</a> if the date is on the first of a month. The date
--   must be valid.
dateIsFirstOfMonth :: (HasCallStack, MonadIO m) => Date -> m Bool

-- | Returns <a>True</a> if the date is the last day of the month. The date
--   must be valid.
dateIsLastOfMonth :: (HasCallStack, MonadIO m) => Date -> m Bool

-- | Returns <a>True</a> if the year is a leap year.
--   
--   For the purposes of this function, leap year is every year divisible
--   by 4 unless that year is divisible by 100. If it is divisible by 100
--   it would be a leap year only if that year is also divisible by 400.
dateIsLeapYear :: (HasCallStack, MonadIO m) => Word16 -> m Bool

-- | Allocates a <a>Date</a> and initializes it to a safe state. The new
--   date will be cleared (as if you'd called <a>dateClear</a>) but invalid
--   (it won't represent an existing day). Free the return value with
--   <a>dateFree</a>.
dateNew :: (HasCallStack, MonadIO m) => m Date

-- | Create a new <a>Date</a> representing the given day-month-year
--   triplet.
--   
--   The triplet you pass in must represent a valid date. Use
--   <a>dateValidDmy</a> if needed to validate it. The returned <a>Date</a>
--   is guaranteed to be non-<a>Nothing</a> and valid.
dateNewDmy :: (HasCallStack, MonadIO m) => Word8 -> DateMonth -> Word16 -> m Date

-- | Create a new <a>Date</a> representing the given Julian date.
--   
--   The <i><tt>julianDay</tt></i> you pass in must be valid. Use
--   <a>dateValidJulian</a> if needed to validate it. The returned
--   <a>Date</a> is guaranteed to be non-<a>Nothing</a> and valid.
dateNewJulian :: (HasCallStack, MonadIO m) => Word32 -> m Date

-- | Checks if <i><tt>date1</tt></i> is less than or equal to
--   <i><tt>date2</tt></i>, and swap the values if this is not the case.
dateOrder :: (HasCallStack, MonadIO m) => Date -> Date -> m ()

-- | Sets the day of the month for a <a>Date</a>. If the resulting
--   day-month-year triplet is invalid, the date will be invalid.
dateSetDay :: (HasCallStack, MonadIO m) => Date -> Word8 -> m ()

-- | Sets the value of a <a>Date</a> from a day, month, and year. The
--   day-month-year triplet must be valid; if you aren't sure it is, call
--   <a>dateValidDmy</a> to check before you set it.
dateSetDmy :: (HasCallStack, MonadIO m) => Date -> Word8 -> DateMonth -> Word16 -> m ()

-- | Sets the value of a <a>Date</a> from a Julian day number.
dateSetJulian :: (HasCallStack, MonadIO m) => Date -> Word32 -> m ()

-- | Sets the month of the year for a <a>Date</a>. If the resulting
--   day-month-year triplet is invalid, the date will be invalid.
dateSetMonth :: (HasCallStack, MonadIO m) => Date -> DateMonth -> m ()

-- | Parses a user-inputted string <i><tt>str</tt></i>, and try to figure
--   out what date it represents, taking the <a>current locale</a> into
--   account. If the string is successfully parsed, the date will be valid
--   after the call. Otherwise, it will be invalid. You should check using
--   <a>dateValid</a> to see whether the parsing succeeded.
--   
--   This function is not appropriate for file formats and the like; it
--   isn't very precise, and its exact behavior varies with the locale.
--   It's intended to be a heuristic routine that guesses what the user
--   means by a given string (and it does work pretty well in that
--   capacity).
dateSetParse :: (HasCallStack, MonadIO m) => Date -> Text -> m ()

-- | Sets the value of a date from a <tt><i>GTime</i></tt> value. The time
--   to date conversion is done using the user's current timezone.

-- | <i>Deprecated: (Since version 2.10)Use <a>dateSetTimeT</a>
--   instead.</i>
dateSetTime :: (HasCallStack, MonadIO m) => Date -> Int32 -> m ()

-- | Sets the value of a date to the date corresponding to a time specified
--   as a time_t. The time to date conversion is done using the user's
--   current timezone.
--   
--   To set the value of a date to the current day, you could write:
--   
--   <h3><i>C code</i></h3>
--   
--   <pre>
--   time_t now = time (NULL);
--   if (now == (time_t) -1)
--     // handle the error
--   g_date_set_time_t (date, now);
--   </pre>
--   
--   <i>Since: 2.10</i>
dateSetTimeT :: (HasCallStack, MonadIO m) => Date -> CTime -> m ()

-- | Sets the value of a date from a <a>TimeVal</a> value. Note that the
--   <i><tt>tvUsec</tt></i> member is ignored, because <a>Date</a> can't
--   make use of the additional precision.
--   
--   The time to date conversion is done using the user's current timezone.
--   
--   <i>Since: 2.10</i>

-- | <i>Deprecated: (Since version 2.62)<a>TimeVal</a> is not
--   year-2038-safe. Use <a>dateSetTimeT</a>instead.</i>
dateSetTimeVal :: (HasCallStack, MonadIO m) => Date -> TimeVal -> m ()

-- | Sets the year for a <a>Date</a>. If the resulting day-month-year
--   triplet is invalid, the date will be invalid.
dateSetYear :: (HasCallStack, MonadIO m) => Date -> Word16 -> m ()

-- | Generates a printed representation of the date, in a
--   <a>locale</a>-specific way. Works just like the platform's C library
--   <tt><i>strftime()</i></tt> function, but only accepts date-related
--   formats; time-related formats give undefined results. Date must be
--   valid. Unlike <tt><i>strftime()</i></tt> (which uses the locale
--   encoding), works on a UTF-8 format string and stores a UTF-8 result.
--   
--   This function does not provide any conversion specifiers in addition
--   to those implemented by the platform's C library. For example, don't
--   expect that using <a>dateStrftime</a> would make the %F provided by
--   the C99 <tt><i>strftime()</i></tt> work on Windows where the C library
--   only complies to C89.
dateStrftime :: (HasCallStack, MonadIO m) => Text -> CSize -> Text -> Date -> m CSize

-- | Moves a date some number of days into the past. To move by weeks, just
--   move by weeks*7 days. The date must be valid.
dateSubtractDays :: (HasCallStack, MonadIO m) => Date -> Word32 -> m ()

-- | Moves a date some number of months into the past. If the current day
--   of the month doesn't exist in the destination month, the day of the
--   month may change. The date must be valid.
dateSubtractMonths :: (HasCallStack, MonadIO m) => Date -> Word32 -> m ()

-- | Moves a date some number of years into the past. If the current day
--   doesn't exist in the destination year (i.e. it's February 29 and you
--   move to a non-leap-year) then the day is changed to February 29. The
--   date must be valid.
dateSubtractYears :: (HasCallStack, MonadIO m) => Date -> Word32 -> m ()

-- | Fills in the date-related bits of a struct tm using the
--   <i><tt>date</tt></i> value. Initializes the non-date parts with
--   something safe but meaningless.
dateToStructTm :: (HasCallStack, MonadIO m) => Date -> Ptr () -> m ()

-- | Returns <a>True</a> if the <a>Date</a> represents an existing day. The
--   date must not contain garbage; it should have been initialized with
--   <a>dateClear</a> if it wasn't allocated by one of the <a>dateNew</a>
--   variants.
dateValid :: (HasCallStack, MonadIO m) => Date -> m Bool

-- | Returns <a>True</a> if the day of the month is valid (a day is valid
--   if it's between 1 and 31 inclusive).
dateValidDay :: (HasCallStack, MonadIO m) => Word8 -> m Bool

-- | Returns <a>True</a> if the day-month-year triplet forms a valid,
--   existing day in the range of days <a>Date</a> understands (Year 1 or
--   later, no more than a few thousand years in the future).
dateValidDmy :: (HasCallStack, MonadIO m) => Word8 -> DateMonth -> Word16 -> m Bool

-- | Returns <a>True</a> if the Julian day is valid. Anything greater than
--   zero is basically a valid Julian, though there is a 32-bit limit.
dateValidJulian :: (HasCallStack, MonadIO m) => Word32 -> m Bool

-- | Returns <a>True</a> if the month value is valid. The 12
--   <a>DateMonth</a> enumeration values are the only valid months.
dateValidMonth :: (HasCallStack, MonadIO m) => DateMonth -> m Bool

-- | Returns <a>True</a> if the weekday is valid. The seven
--   <a>DateWeekday</a> enumeration values are the only valid weekdays.
dateValidWeekday :: (HasCallStack, MonadIO m) => DateWeekday -> m Bool

-- | Returns <a>True</a> if the year is valid. Any year greater than 0 is
--   valid, though there is a 16-bit limit to what <a>Date</a> will
--   understand.
dateValidYear :: (HasCallStack, MonadIO m) => Word16 -> m Bool

-- | Get the value of the “<tt>day</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> date #day
--   </pre>
getDateDay :: MonadIO m => Date -> m Word32

-- | Set the value of the “<tt>day</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> date [ #day <a>:=</a> value ]
--   </pre>
setDateDay :: MonadIO m => Date -> Word32 -> m ()

-- | Get the value of the “<tt>dmy</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> date #dmy
--   </pre>
getDateDmy :: MonadIO m => Date -> m Word32

-- | Set the value of the “<tt>dmy</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> date [ #dmy <a>:=</a> value ]
--   </pre>
setDateDmy :: MonadIO m => Date -> Word32 -> m ()

-- | Get the value of the “<tt>julian</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> date #julian
--   </pre>
getDateJulian :: MonadIO m => Date -> m Word32

-- | Set the value of the “<tt>julian</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> date [ #julian <a>:=</a> value ]
--   </pre>
setDateJulian :: MonadIO m => Date -> Word32 -> m ()

-- | Get the value of the “<tt>julian_days</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> date #julianDays
--   </pre>
getDateJulianDays :: MonadIO m => Date -> m Word32

-- | Set the value of the “<tt>julian_days</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> date [ #julianDays <a>:=</a> value ]
--   </pre>
setDateJulianDays :: MonadIO m => Date -> Word32 -> m ()

-- | Get the value of the “<tt>month</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> date #month
--   </pre>
getDateMonth :: MonadIO m => Date -> m Word32

-- | Set the value of the “<tt>month</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> date [ #month <a>:=</a> value ]
--   </pre>
setDateMonth :: MonadIO m => Date -> Word32 -> m ()

-- | Get the value of the “<tt>year</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> date #year
--   </pre>
getDateYear :: MonadIO m => Date -> m Word32

-- | Set the value of the “<tt>year</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> date [ #year <a>:=</a> value ]
--   </pre>
setDateYear :: MonadIO m => Date -> Word32 -> m ()
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.GLib.Structs.Date.Date tag
instance GHC.Classes.Eq GI.GLib.Structs.Date.Date
instance Data.GI.Base.BasicTypes.GBoxed GI.GLib.Structs.Date.Date
instance Data.GI.Base.Overloading.HasParentTypes GI.GLib.Structs.Date.Date
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.GLib.Structs.Date.Date)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GLib.Structs.Date.Date
instance Data.GI.Base.BasicTypes.TypedObject GI.GLib.Structs.Date.Date


-- | A <tt>GTimeZone</tt> represents a time zone, at no particular point in
--   time.
--   
--   The <tt>GTimeZone</tt> struct is refcounted and immutable.
--   
--   Each time zone has an identifier (for example, ‘Europe/London’) which
--   is platform dependent. See <a>timeZoneNew</a> for information on the
--   identifier formats. The identifier of a time zone can be retrieved
--   using <a>timeZoneGetIdentifier</a>.
--   
--   A time zone contains a number of intervals. Each interval has an
--   abbreviation to describe it (for example, ‘PDT’), an offset to UTC and
--   a flag indicating if the daylight savings time is in effect during
--   that interval. A time zone always has at least one interval — interval
--   0. Note that interval abbreviations are not the same as time zone
--   identifiers (apart from ‘UTC’), and cannot be passed to
--   <a>timeZoneNew</a>.
--   
--   Every UTC time is contained within exactly one interval, but a given
--   local time may be contained within zero, one or two intervals (due to
--   incontinuities associated with daylight savings time).
--   
--   An interval may refer to a specific period of time (eg: the duration
--   of daylight savings time during 2010) or it may refer to many periods
--   of time that share the same properties (eg: all periods of daylight
--   savings time). It is also possible (usually for political reasons)
--   that some properties (like the abbreviation) change between intervals
--   without other properties changing.
--   
--   <i>Since: 2.26</i>
module GI.GLib.Structs.TimeZone

-- | Memory-managed wrapper type.
newtype TimeZone
TimeZone :: ManagedPtr TimeZone -> TimeZone

-- | Finds an interval within <i><tt>tz</tt></i> that corresponds to the
--   given <i><tt>time_</tt></i>, possibly adjusting <i><tt>time_</tt></i>
--   if required to fit into an interval. The meaning of
--   <i><tt>time_</tt></i> depends on <i><tt>type</tt></i>.
--   
--   This function is similar to <a>timeZoneFindInterval</a>, with the
--   difference that it always succeeds (by making the adjustments
--   described below).
--   
--   In any of the cases where <a>timeZoneFindInterval</a> succeeds then
--   this function returns the same value, without modifying
--   <i><tt>time_</tt></i>.
--   
--   This function may, however, modify <i><tt>time_</tt></i> in order to
--   deal with non-existent times. If the non-existent local
--   <i><tt>time_</tt></i> of 02:30 were requested on March 14th 2010 in
--   Toronto then this function would adjust <i><tt>time_</tt></i> to be
--   03:00 and return the interval containing the adjusted time.
--   
--   <i>Since: 2.26</i>
timeZoneAdjustTime :: (HasCallStack, MonadIO m) => TimeZone -> TimeType -> Int64 -> m (Int32, Int64)

-- | Finds an interval within <i><tt>tz</tt></i> that corresponds to the
--   given <i><tt>time_</tt></i>. The meaning of <i><tt>time_</tt></i>
--   depends on <i><tt>type</tt></i>.
--   
--   If <i><tt>type</tt></i> is <a>TimeTypeUniversal</a> then this function
--   will always succeed (since universal time is monotonic and
--   continuous).
--   
--   Otherwise <i><tt>time_</tt></i> is treated as local time. The
--   distinction between <a>TimeTypeStandard</a> and
--   <a>TimeTypeDaylight</a> is ignored except in the case that the given
--   <i><tt>time_</tt></i> is ambiguous. In Toronto, for example, 01:30 on
--   November 7th 2010 occurred twice (once inside of daylight savings time
--   and the next, an hour later, outside of daylight savings time). In
--   this case, the different value of <i><tt>type</tt></i> would result in
--   a different interval being returned.
--   
--   It is still possible for this function to fail. In Toronto, for
--   example, 02:00 on March 14th 2010 does not exist (due to the leap
--   forward to begin daylight savings time). -1 is returned in that case.
--   
--   <i>Since: 2.26</i>
timeZoneFindInterval :: (HasCallStack, MonadIO m) => TimeZone -> TimeType -> Int64 -> m Int32

-- | Determines the time zone abbreviation to be used during a particular
--   <i><tt>interval</tt></i> of time in the time zone <i><tt>tz</tt></i>.
--   
--   For example, in Toronto this is currently "EST" during the winter
--   months and "EDT" during the summer months when daylight savings time
--   is in effect.
--   
--   <i>Since: 2.26</i>
timeZoneGetAbbreviation :: (HasCallStack, MonadIO m) => TimeZone -> Int32 -> m Text

-- | Get the identifier of this <a>TimeZone</a>, as passed to
--   <a>timeZoneNew</a>. If the identifier passed at construction time was
--   not recognised, <tt>UTC</tt> will be returned. If it was
--   <a>Nothing</a>, the identifier of the local timezone at construction
--   time will be returned.
--   
--   The identifier will be returned in the same format as provided at
--   construction time: if provided as a time offset, that will be returned
--   by this function.
--   
--   <i>Since: 2.58</i>
timeZoneGetIdentifier :: (HasCallStack, MonadIO m) => TimeZone -> m Text

-- | Determines the offset to UTC in effect during a particular
--   <i><tt>interval</tt></i> of time in the time zone <i><tt>tz</tt></i>.
--   
--   The offset is the number of seconds that you add to UTC time to arrive
--   at local time for <i><tt>tz</tt></i> (ie: negative numbers for time
--   zones west of GMT, positive numbers for east).
--   
--   <i>Since: 2.26</i>
timeZoneGetOffset :: (HasCallStack, MonadIO m) => TimeZone -> Int32 -> m Int32

-- | Determines if daylight savings time is in effect during a particular
--   <i><tt>interval</tt></i> of time in the time zone <i><tt>tz</tt></i>.
--   
--   <i>Since: 2.26</i>
timeZoneIsDst :: (HasCallStack, MonadIO m) => TimeZone -> Int32 -> m Bool

-- | A version of <a>timeZoneNewIdentifier</a> which returns the UTC time
--   zone if <i><tt>identifier</tt></i> could not be parsed or loaded.
--   
--   If you need to check whether <i><tt>identifier</tt></i> was loaded
--   successfully, use <a>timeZoneNewIdentifier</a>.
--   
--   <i>Since: 2.26</i>

-- | <i>Deprecated: (Since version 2.68)Use <a>timeZoneNewIdentifier</a>
--   instead, as it provideserror reporting. Change your code to handle a
--   potentially <a>Nothing</a> returnvalue.</i>
timeZoneNew :: (HasCallStack, MonadIO m) => Maybe Text -> m TimeZone

-- | Creates a <a>TimeZone</a> corresponding to <i><tt>identifier</tt></i>.
--   If <i><tt>identifier</tt></i> cannot be parsed or loaded,
--   <a>Nothing</a> is returned.
--   
--   <i><tt>identifier</tt></i> can either be an RFC3339/ISO 8601 time
--   offset or something that would pass as a valid value for the
--   <tt>TZ</tt> environment variable (including <a>Nothing</a>).
--   
--   In Windows, <i><tt>identifier</tt></i> can also be the unlocalized
--   name of a time zone for standard time, for example "Pacific Standard
--   Time".
--   
--   Valid RFC3339 time offsets are <tt>"Z"</tt> (for UTC) or
--   <tt>"±hh:mm"</tt>. ISO 8601 additionally specifies <tt>"±hhmm"</tt>
--   and <tt>"±hh"</tt>. Offsets are time values to be added to Coordinated
--   Universal Time (UTC) to get the local time.
--   
--   In UNIX, the <tt>TZ</tt> environment variable typically corresponds to
--   the name of a file in the zoneinfo database, an absolute path to a
--   file somewhere else, or a string in "std offset [dst
--   [offset],start[/time],end[/time]]" (POSIX) format. There are no spaces
--   in the specification. The name of standard and daylight savings time
--   zone must be three or more alphabetic characters. Offsets are time
--   values to be added to local time to get Coordinated Universal Time
--   (UTC) and should be <tt>"[±]hh[[:]mm[:ss]]"</tt>. Dates are either
--   <tt>"Jn"</tt> (Julian day with n between 1 and 365, leap years not
--   counted), <tt>"n"</tt> (zero-based Julian day with n between 0 and
--   365) or <tt>"Mm.w.d"</tt> (day d (0 &lt;= d &lt;= 6) of week w (1
--   &lt;= w &lt;= 5) of month m (1 &lt;= m &lt;= 12), day 0 is a Sunday).
--   Times are in local wall clock time, the default is 02:00:00.
--   
--   In Windows, the "tzn[+|–]hh[:mm[:ss]][dzn]" format is used, but also
--   accepts POSIX format. The Windows format uses US rules for all time
--   zones; daylight savings time is 60 minutes behind the standard time
--   with date and time of change taken from Pacific Standard Time. Offsets
--   are time values to be added to the local time to get Coordinated
--   Universal Time (UTC).
--   
--   <a>timeZoneNewLocal</a> calls this function with the value of the
--   <tt>TZ</tt> environment variable. This function itself is independent
--   of the value of <tt>TZ</tt>, but if <i><tt>identifier</tt></i> is
--   <a>Nothing</a> then <tt>/etc/localtime</tt> will be consulted to
--   discover the correct time zone on UNIX and the registry will be
--   consulted or <tt><i>GetTimeZoneInformation()</i></tt> will be used to
--   get the local time zone on Windows.
--   
--   If intervals are not available, only time zone rules from <tt>TZ</tt>
--   environment variable or other means, then they will be computed from
--   year 1900 to 2037. If the maximum year for the rules is available and
--   it is greater than 2037, then it will followed instead.
--   
--   See <a>RFC3339 §5.6</a> for a precise definition of valid RFC3339 time
--   offsets (the <tt>time-offset</tt> expansion) and ISO 8601 for the full
--   list of valid time offsets. See <a>The GNU C Library manual</a> for an
--   explanation of the possible values of the <tt>TZ</tt> environment
--   variable. See <a>Microsoft Time Zone Index Values</a> for the list of
--   time zones on Windows.
--   
--   You should release the return value by calling <a>timeZoneUnref</a>
--   when you are done with it.
--   
--   <i>Since: 2.68</i>
timeZoneNewIdentifier :: (HasCallStack, MonadIO m) => Maybe Text -> m (Maybe TimeZone)

-- | Creates a <a>TimeZone</a> corresponding to local time. The local time
--   zone may change between invocations to this function; for example, if
--   the system administrator changes it.
--   
--   This is equivalent to calling <a>timeZoneNew</a> with the value of the
--   <tt>TZ</tt> environment variable (including the possibility of
--   <a>Nothing</a>).
--   
--   You should release the return value by calling <a>timeZoneUnref</a>
--   when you are done with it.
--   
--   <i>Since: 2.26</i>
timeZoneNewLocal :: (HasCallStack, MonadIO m) => m TimeZone

-- | Creates a <a>TimeZone</a> corresponding to the given constant offset
--   from UTC, in seconds.
--   
--   This is equivalent to calling <a>timeZoneNew</a> with a string in the
--   form <tt>[+|-]hh[:mm[:ss]]</tt>.
--   
--   It is possible for this function to fail if <i><tt>seconds</tt></i> is
--   too big (greater than 24 hours), in which case this function will
--   return the UTC timezone for backwards compatibility. To detect
--   failures like this, use <a>timeZoneNewIdentifier</a> directly.
--   
--   <i>Since: 2.58</i>
timeZoneNewOffset :: (HasCallStack, MonadIO m) => Int32 -> m TimeZone

-- | Creates a <a>TimeZone</a> corresponding to UTC.
--   
--   This is equivalent to calling <a>timeZoneNew</a> with a value like
--   "Z", "UTC", "+00", etc.
--   
--   You should release the return value by calling <a>timeZoneUnref</a>
--   when you are done with it.
--   
--   <i>Since: 2.26</i>
timeZoneNewUtc :: (HasCallStack, MonadIO m) => m TimeZone

-- | Increases the reference count on <i><tt>tz</tt></i>.
--   
--   <i>Since: 2.26</i>
timeZoneRef :: (HasCallStack, MonadIO m) => TimeZone -> m TimeZone

-- | Decreases the reference count on <i><tt>tz</tt></i>.
--   
--   <i>Since: 2.26</i>
timeZoneUnref :: (HasCallStack, MonadIO m) => TimeZone -> m ()
instance GHC.Classes.Eq GI.GLib.Structs.TimeZone.TimeZone
instance Data.GI.Base.BasicTypes.GBoxed GI.GLib.Structs.TimeZone.TimeZone
instance Data.GI.Base.Overloading.HasParentTypes GI.GLib.Structs.TimeZone.TimeZone
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.GLib.Structs.TimeZone.TimeZone)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.GLib.Structs.TimeZone.TimeZone
instance Data.GI.Base.BasicTypes.TypedObject GI.GLib.Structs.TimeZone.TimeZone


-- | <tt>GDateTime</tt> is a structure that combines a Gregorian date and
--   time into a single structure.
--   
--   <tt>GDateTime</tt> provides many conversion and methods to manipulate
--   dates and times. Time precision is provided down to microseconds and
--   the time can range (proleptically) from 0001-01-01 00:00:00 to
--   9999-12-31 23:59:59.999999. <tt>GDateTime</tt> follows POSIX time in
--   the sense that it is oblivious to leap seconds.
--   
--   <tt>GDateTime</tt> is an immutable object; once it has been created it
--   cannot be modified further. All modifiers will create a new
--   <tt>GDateTime</tt>. Nearly all such functions can fail due to the date
--   or time going out of range, in which case <a>Nothing</a> will be
--   returned.
--   
--   <tt>GDateTime</tt> is reference counted: the reference count is
--   increased by calling <a>dateTimeRef</a> and decreased by calling
--   <a>dateTimeUnref</a>. When the reference count drops to 0, the
--   resources allocated by the <tt>GDateTime</tt> structure are released.
--   
--   Many parts of the API may produce non-obvious results. As an example,
--   adding two months to January 31st will yield March 31st whereas adding
--   one month and then one month again will yield either March 28th or
--   March 29th. Also note that adding 24 hours is not always the same as
--   adding one day (since days containing daylight savings time
--   transitions are either 23 or 25 hours in length).
--   
--   <i>Since: 2.26</i>
module GI.GLib.Structs.DateTime

-- | Memory-managed wrapper type.
newtype DateTime
DateTime :: ManagedPtr DateTime -> DateTime

-- | Creates a copy of <i><tt>datetime</tt></i> and adds the specified
--   timespan to the copy.
--   
--   <i>Since: 2.26</i>
dateTimeAdd :: (HasCallStack, MonadIO m) => DateTime -> Int64 -> m (Maybe DateTime)

-- | Creates a copy of <i><tt>datetime</tt></i> and adds the specified
--   number of days to the copy. Add negative values to subtract days.
--   
--   <i>Since: 2.26</i>
dateTimeAddDays :: (HasCallStack, MonadIO m) => DateTime -> Int32 -> m (Maybe DateTime)

-- | Creates a new <a>DateTime</a> adding the specified values to the
--   current date and time in <i><tt>datetime</tt></i>. Add negative values
--   to subtract.
--   
--   <i>Since: 2.26</i>
dateTimeAddFull :: (HasCallStack, MonadIO m) => DateTime -> Int32 -> Int32 -> Int32 -> Int32 -> Int32 -> Double -> m (Maybe DateTime)

-- | Creates a copy of <i><tt>datetime</tt></i> and adds the specified
--   number of hours. Add negative values to subtract hours.
--   
--   <i>Since: 2.26</i>
dateTimeAddHours :: (HasCallStack, MonadIO m) => DateTime -> Int32 -> m (Maybe DateTime)

-- | Creates a copy of <i><tt>datetime</tt></i> adding the specified number
--   of minutes. Add negative values to subtract minutes.
--   
--   <i>Since: 2.26</i>
dateTimeAddMinutes :: (HasCallStack, MonadIO m) => DateTime -> Int32 -> m (Maybe DateTime)

-- | Creates a copy of <i><tt>datetime</tt></i> and adds the specified
--   number of months to the copy. Add negative values to subtract months.
--   
--   The day of the month of the resulting <a>DateTime</a> is clamped to
--   the number of days in the updated calendar month. For example, if
--   adding 1 month to 31st January 2018, the result would be 28th February
--   2018. In 2020 (a leap year), the result would be 29th February.
--   
--   <i>Since: 2.26</i>
dateTimeAddMonths :: (HasCallStack, MonadIO m) => DateTime -> Int32 -> m (Maybe DateTime)

-- | Creates a copy of <i><tt>datetime</tt></i> and adds the specified
--   number of seconds. Add negative values to subtract seconds.
--   
--   <i>Since: 2.26</i>
dateTimeAddSeconds :: (HasCallStack, MonadIO m) => DateTime -> Double -> m (Maybe DateTime)

-- | Creates a copy of <i><tt>datetime</tt></i> and adds the specified
--   number of weeks to the copy. Add negative values to subtract weeks.
--   
--   <i>Since: 2.26</i>
dateTimeAddWeeks :: (HasCallStack, MonadIO m) => DateTime -> Int32 -> m (Maybe DateTime)

-- | Creates a copy of <i><tt>datetime</tt></i> and adds the specified
--   number of years to the copy. Add negative values to subtract years.
--   
--   As with <a>dateTimeAddMonths</a>, if the resulting date would be 29th
--   February on a non-leap year, the day will be clamped to 28th February.
--   
--   <i>Since: 2.26</i>
dateTimeAddYears :: (HasCallStack, MonadIO m) => DateTime -> Int32 -> m (Maybe DateTime)

-- | A comparison function for <tt><i>GDateTimes</i></tt> that is suitable
--   as a <a>CompareFunc</a>. Both <tt><i>GDateTimes</i></tt> must be
--   non-<a>Nothing</a>.
--   
--   <i>Since: 2.26</i>
dateTimeCompare :: (HasCallStack, MonadIO m) => DateTime -> DateTime -> m Int32

-- | Calculates the difference in time between <i><tt>end</tt></i> and
--   <i><tt>begin</tt></i>. The <tt><i>GTimeSpan</i></tt> that is returned
--   is effectively <i><tt>end</tt></i> - <i><tt>begin</tt></i> (ie:
--   positive if the first parameter is larger).
--   
--   <i>Since: 2.26</i>
dateTimeDifference :: (HasCallStack, MonadIO m) => DateTime -> DateTime -> m Int64

-- | Checks to see if <i><tt>dt1</tt></i> and <i><tt>dt2</tt></i> are
--   equal.
--   
--   Equal here means that they represent the same moment after converting
--   them to the same time zone.
--   
--   <i>Since: 2.26</i>
dateTimeEqual :: (HasCallStack, MonadIO m) => DateTime -> DateTime -> m Bool

-- | Creates a newly allocated string representing the requested
--   <i><tt>format</tt></i>.
--   
--   The format strings understood by this function are a subset of the
--   <tt>strftime()</tt> format language as specified by C99. The
--   <tt>%D</tt>, <tt>%U</tt> and <tt>%W</tt> conversions are not
--   supported, nor is the <tt>E</tt> modifier. The GNU extensions
--   <tt>%k</tt>, <tt>%l</tt>, <tt>%s</tt> and <tt>%P</tt> are supported,
--   however, as are the <tt>0</tt>, <tt>_</tt> and <tt>-</tt> modifiers.
--   The Python extension <tt>%f</tt> is also supported.
--   
--   In contrast to <tt>strftime()</tt>, this function always produces a
--   UTF-8 string, regardless of the current locale. Note that the
--   rendering of many formats is locale-dependent and may not match the
--   <tt>strftime()</tt> output exactly.
--   
--   The following format specifiers are supported:
--   
--   <ul>
--   <li><tt>%a</tt>: the abbreviated weekday name according to the current
--   locale</li>
--   <li><tt>%A</tt>: the full weekday name according to the current
--   locale</li>
--   <li><tt>%b</tt>: the abbreviated month name according to the current
--   locale</li>
--   <li><tt>%B</tt>: the full month name according to the current
--   locale</li>
--   <li><tt>%c</tt>: the preferred date and time representation for the
--   current locale</li>
--   <li><tt>%C</tt>: the century number (year/100) as a 2-digit integer
--   (00-99)</li>
--   <li><tt>%d</tt>: the day of the month as a decimal number (range 01 to
--   31)</li>
--   <li><tt>%e</tt>: the day of the month as a decimal number (range 1 to
--   31); single digits are preceded by a figure space (U+2007)</li>
--   <li><tt>%F</tt>: equivalent to <tt>%Y-%m-%d</tt> (the ISO 8601 date
--   format)</li>
--   <li><tt>%g</tt>: the last two digits of the ISO 8601 week-based year
--   as a decimal number (00-99). This works well with <tt>%V</tt> and
--   <tt>%u</tt>.</li>
--   <li><tt>%G</tt>: the ISO 8601 week-based year as a decimal number.
--   This works well with <tt>%V</tt> and <tt>%u</tt>.</li>
--   <li><tt>%h</tt>: equivalent to <tt>%b</tt></li>
--   <li><tt>%H</tt>: the hour as a decimal number using a 24-hour clock
--   (range 00 to 23)</li>
--   <li><tt>%I</tt>: the hour as a decimal number using a 12-hour clock
--   (range 01 to 12)</li>
--   <li><tt>%j</tt>: the day of the year as a decimal number (range 001 to
--   366)</li>
--   <li><tt>%k</tt>: the hour (24-hour clock) as a decimal number (range 0
--   to 23); single digits are preceded by a figure space (U+2007)</li>
--   <li><tt>%l</tt>: the hour (12-hour clock) as a decimal number (range 1
--   to 12); single digits are preceded by a figure space (U+2007)</li>
--   <li><tt>%m</tt>: the month as a decimal number (range 01 to 12)</li>
--   <li><tt>%M</tt>: the minute as a decimal number (range 00 to 59)</li>
--   <li><tt>%f</tt>: the microsecond as a decimal number (range 000000 to
--   999999)</li>
--   <li><tt>%p</tt>: either ‘AM’ or ‘PM’ according to the given time
--   value, or the corresponding strings for the current locale. Noon is
--   treated as ‘PM’ and midnight as ‘AM’. Use of this format specifier is
--   discouraged, as many locales have no concept of AM/PM formatting. Use
--   <tt>%c</tt> or <tt>%X</tt> instead.</li>
--   <li><tt>%P</tt>: like <tt>%p</tt> but lowercase: ‘am’ or ‘pm’ or a
--   corresponding string for the current locale. Use of this format
--   specifier is discouraged, as many locales have no concept of AM/PM
--   formatting. Use <tt>%c</tt> or <tt>%X</tt> instead.</li>
--   <li><tt>%r</tt>: the time in a.m. or p.m. notation. Use of this format
--   specifier is discouraged, as many locales have no concept of AM/PM
--   formatting. Use <tt>%c</tt> or <tt>%X</tt> instead.</li>
--   <li><tt>%R</tt>: the time in 24-hour notation (<tt>%H:%M</tt>)</li>
--   <li><tt>%s</tt>: the number of seconds since the Epoch, that is, since
--   1970-01-01 00:00:00 UTC</li>
--   <li><tt>%S</tt>: the second as a decimal number (range 00 to 60)</li>
--   <li><tt>%t</tt>: a tab character</li>
--   <li><tt>%T</tt>: the time in 24-hour notation with seconds
--   (<tt>%H:%M:%S</tt>)</li>
--   <li><tt>%u</tt>: the ISO 8601 standard day of the week as a decimal,
--   range 1 to 7, Monday being 1. This works well with <tt>%G</tt> and
--   <tt>%V</tt>.</li>
--   <li><tt>%V</tt>: the ISO 8601 standard week number of the current year
--   as a decimal number, range 01 to 53, where week 1 is the first week
--   that has at least 4 days in the new year. See
--   <a>dateTimeGetWeekOfYear</a>. This works well with <tt>%G</tt> and
--   <tt>%u</tt>.</li>
--   <li><tt>%w</tt>: the day of the week as a decimal, range 0 to 6,
--   Sunday being 0. This is not the ISO 8601 standard format — use
--   <tt>%u</tt> instead.</li>
--   <li><tt>%x</tt>: the preferred date representation for the current
--   locale without the time</li>
--   <li><tt>%X</tt>: the preferred time representation for the current
--   locale without the date</li>
--   <li><tt>%y</tt>: the year as a decimal number without the century</li>
--   <li><tt>%Y</tt>: the year as a decimal number including the
--   century</li>
--   <li><tt>%z</tt>: the time zone as an offset from UTC
--   (<tt>+hhmm</tt>)</li>
--   <li><tt>%:z</tt>: the time zone as an offset from UTC
--   (<tt>+hh:mm</tt>). This is a gnulib <tt>strftime()</tt> extension.
--   Since: 2.38</li>
--   <li><tt>%::z</tt>: the time zone as an offset from UTC
--   (<tt>+hh:mm:ss</tt>). This is a gnulib <tt>strftime()</tt> extension.
--   Since: 2.38</li>
--   <li><tt>%:::z</tt>: the time zone as an offset from UTC, with
--   <tt>:</tt> to necessary precision (e.g., <tt>-04</tt>,
--   <tt>+05:30</tt>). This is a gnulib <tt>strftime()</tt> extension.
--   Since: 2.38</li>
--   <li><tt>%Z</tt>: the time zone or name or abbreviation</li>
--   <li><tt>%%</tt>: a literal <tt>%</tt> character</li>
--   </ul>
--   
--   Some conversion specifications can be modified by preceding the
--   conversion specifier by one or more modifier characters.
--   
--   The following modifiers are supported for many of the numeric
--   conversions:
--   
--   <ul>
--   <li><tt>O</tt>: Use alternative numeric symbols, if the current locale
--   supports those.</li>
--   <li><tt>_</tt>: Pad a numeric result with spaces. This overrides the
--   default padding for the specifier.</li>
--   <li><tt>-</tt>: Do not pad a numeric result. This overrides the
--   default padding for the specifier.</li>
--   <li><tt>0</tt>: Pad a numeric result with zeros. This overrides the
--   default padding for the specifier.</li>
--   </ul>
--   
--   The following modifiers are supported for many of the alphabetic
--   conversions:
--   
--   <ul>
--   <li><tt>^</tt>: Use upper case if possible. This is a gnulib
--   <tt>strftime()</tt> extension. Since: 2.80</li>
--   <li><tt>#</tt>: Use opposite case if possible. This is a gnulib
--   <tt>strftime()</tt> extension. Since: 2.80</li>
--   </ul>
--   
--   Additionally, when <tt>O</tt> is used with <tt>B</tt>, <tt>b</tt>, or
--   <tt>h</tt>, it produces the alternative form of a month name. The
--   alternative form should be used when the month name is used without a
--   day number (e.g., standalone). It is required in some languages
--   (Baltic, Slavic, Greek, and more) due to their grammatical rules. For
--   other languages there is no difference. <tt>%OB</tt> is a GNU and BSD
--   <tt>strftime()</tt> extension expected to be added to the future POSIX
--   specification, <tt>%Ob</tt> and <tt>%Oh</tt> are GNU
--   <tt>strftime()</tt> extensions. Since: 2.56
--   
--   Since GLib 2.80, when <tt>E</tt> is used with <tt>%c</tt>,
--   <tt>%C</tt>, <tt>%x</tt>, <tt>%X</tt>, <tt>%y</tt> or <tt>%Y</tt>, the
--   date is formatted using an alternate era representation specific to
--   the locale. This is typically used for the Thai solar calendar or
--   Japanese era names, for example.
--   
--   <ul>
--   <li><tt>%Ec</tt>: the preferred date and time representation for the
--   current locale, using the alternate era representation</li>
--   <li><tt>%EC</tt>: the name of the era</li>
--   <li><tt>%Ex</tt>: the preferred date representation for the current
--   locale without the time, using the alternate era representation</li>
--   <li><tt>%EX</tt>: the preferred time representation for the current
--   locale without the date, using the alternate era representation</li>
--   <li><tt>%Ey</tt>: the year since the beginning of the era denoted by
--   the <tt>%EC</tt> specifier</li>
--   <li><tt>%EY</tt>: the full alternative year representation</li>
--   </ul>
--   
--   <i>Since: 2.26</i>
dateTimeFormat :: (HasCallStack, MonadIO m) => DateTime -> Text -> m (Maybe Text)

-- | Format <i><tt>datetime</tt></i> in <a>ISO 8601 format</a>, including
--   the date, time and time zone, and return that as a UTF-8 encoded
--   string.
--   
--   Since GLib 2.66, this will output to sub-second precision if needed.
--   
--                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        