@gtkx/ffi 0.1.45 → 0.1.46

package/dist/generated/glib/enums.js

@@ -1,265 +1,832 @@
+/** Error codes returned by bookmark file parsing. */
 export var BookmarkFileError;
 (function (BookmarkFileError) {
+    /** URI was ill-formed */
     BookmarkFileError[BookmarkFileError["INVALID_URI"] = 0] = "INVALID_URI";
+    /** a requested field was not found */
     BookmarkFileError[BookmarkFileError["INVALID_VALUE"] = 1] = "INVALID_VALUE";
+    /**
+     * a requested application did
+     * not register a bookmark
+     */
     BookmarkFileError[BookmarkFileError["APP_NOT_REGISTERED"] = 2] = "APP_NOT_REGISTERED";
+    /** a requested URI was not found */
     BookmarkFileError[BookmarkFileError["URI_NOT_FOUND"] = 3] = "URI_NOT_FOUND";
+    /** document was ill formed */
     BookmarkFileError[BookmarkFileError["READ"] = 4] = "READ";
+    /**
+     * the text being parsed was
+     * in an unknown encoding
+     */
     BookmarkFileError[BookmarkFileError["UNKNOWN_ENCODING"] = 5] = "UNKNOWN_ENCODING";
+    /** an error occurred while writing */
     BookmarkFileError[BookmarkFileError["WRITE"] = 6] = "WRITE";
+    /** requested file was not found */
     BookmarkFileError[BookmarkFileError["FILE_NOT_FOUND"] = 7] = "FILE_NOT_FOUND";
 })(BookmarkFileError || (BookmarkFileError = {}));
+/**
+ * The hashing algorithm to be used by #GChecksum when performing the
+ * digest of some data.
+ *
+ * Note that the #GChecksumType enumeration may be extended at a later
+ * date to include new hashing algorithm types.
+ */
 export var ChecksumType;
 (function (ChecksumType) {
+    /** Use the MD5 hashing algorithm */
     ChecksumType[ChecksumType["MD5"] = 0] = "MD5";
+    /** Use the SHA-1 hashing algorithm */
     ChecksumType[ChecksumType["SHA1"] = 1] = "SHA1";
+    /** Use the SHA-256 hashing algorithm */
     ChecksumType[ChecksumType["SHA256"] = 2] = "SHA256";
+    /** Use the SHA-512 hashing algorithm (Since: 2.36) */
     ChecksumType[ChecksumType["SHA512"] = 3] = "SHA512";
+    /** Use the SHA-384 hashing algorithm (Since: 2.51) */
     ChecksumType[ChecksumType["SHA384"] = 4] = "SHA384";
 })(ChecksumType || (ChecksumType = {}));
+/** Error codes returned by character set conversion routines. */
 export var ConvertError;
 (function (ConvertError) {
+    /**
+     * Conversion between the requested character
+     * sets is not supported.
+     */
     ConvertError[ConvertError["NO_CONVERSION"] = 0] = "NO_CONVERSION";
+    /**
+     * Invalid byte sequence in conversion input;
+     * or the character sequence could not be represented in the target
+     * character set.
+     */
     ConvertError[ConvertError["ILLEGAL_SEQUENCE"] = 1] = "ILLEGAL_SEQUENCE";
+    /** Conversion failed for some reason. */
     ConvertError[ConvertError["FAILED"] = 2] = "FAILED";
+    /** Partial character sequence at end of input. */
     ConvertError[ConvertError["PARTIAL_INPUT"] = 3] = "PARTIAL_INPUT";
+    /** URI is invalid. */
     ConvertError[ConvertError["BAD_URI"] = 4] = "BAD_URI";
+    /** Pathname is not an absolute path. */
     ConvertError[ConvertError["NOT_ABSOLUTE_PATH"] = 5] = "NOT_ABSOLUTE_PATH";
+    /** No memory available. Since: 2.40 */
     ConvertError[ConvertError["NO_MEMORY"] = 6] = "NO_MEMORY";
+    /**
+     * An embedded NUL character is present in
+     * conversion output where a NUL-terminated string is expected.
+     * Since: 2.56
+     */
     ConvertError[ConvertError["EMBEDDED_NUL"] = 7] = "EMBEDDED_NUL";
 })(ConvertError || (ConvertError = {}));
+/**
+ * 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.
+ */
 export var DateDMY;
 (function (DateDMY) {
+    /** a day */
     DateDMY[DateDMY["DAY"] = 0] = "DAY";
+    /** a month */
     DateDMY[DateDMY["MONTH"] = 1] = "MONTH";
+    /** a year */
     DateDMY[DateDMY["YEAR"] = 2] = "YEAR";
 })(DateDMY || (DateDMY = {}));
+/**
+ * Enumeration representing a month; values are %G_DATE_JANUARY,
+ * %G_DATE_FEBRUARY, etc. %G_DATE_BAD_MONTH is the invalid value.
+ */
 export var DateMonth;
 (function (DateMonth) {
+    /** invalid value */
     DateMonth[DateMonth["BAD_MONTH"] = 0] = "BAD_MONTH";
+    /** January */
     DateMonth[DateMonth["JANUARY"] = 1] = "JANUARY";
+    /** February */
     DateMonth[DateMonth["FEBRUARY"] = 2] = "FEBRUARY";
+    /** March */
     DateMonth[DateMonth["MARCH"] = 3] = "MARCH";
+    /** April */
     DateMonth[DateMonth["APRIL"] = 4] = "APRIL";
+    /** May */
     DateMonth[DateMonth["MAY"] = 5] = "MAY";
+    /** June */
     DateMonth[DateMonth["JUNE"] = 6] = "JUNE";
+    /** July */
     DateMonth[DateMonth["JULY"] = 7] = "JULY";
+    /** August */
     DateMonth[DateMonth["AUGUST"] = 8] = "AUGUST";
+    /** September */
     DateMonth[DateMonth["SEPTEMBER"] = 9] = "SEPTEMBER";
+    /** October */
     DateMonth[DateMonth["OCTOBER"] = 10] = "OCTOBER";
+    /** November */
     DateMonth[DateMonth["NOVEMBER"] = 11] = "NOVEMBER";
+    /** December */
     DateMonth[DateMonth["DECEMBER"] = 12] = "DECEMBER";
 })(DateMonth || (DateMonth = {}));
+/**
+ * Enumeration representing a day of the week; %G_DATE_MONDAY,
+ * %G_DATE_TUESDAY, etc. %G_DATE_BAD_WEEKDAY is an invalid weekday.
+ */
 export var DateWeekday;
 (function (DateWeekday) {
+    /** invalid value */
     DateWeekday[DateWeekday["BAD_WEEKDAY"] = 0] = "BAD_WEEKDAY";
+    /** Monday */
     DateWeekday[DateWeekday["MONDAY"] = 1] = "MONDAY";
+    /** Tuesday */
     DateWeekday[DateWeekday["TUESDAY"] = 2] = "TUESDAY";
+    /** Wednesday */
     DateWeekday[DateWeekday["WEDNESDAY"] = 3] = "WEDNESDAY";
+    /** Thursday */
     DateWeekday[DateWeekday["THURSDAY"] = 4] = "THURSDAY";
+    /** Friday */
     DateWeekday[DateWeekday["FRIDAY"] = 5] = "FRIDAY";
+    /** Saturday */
     DateWeekday[DateWeekday["SATURDAY"] = 6] = "SATURDAY";
+    /** Sunday */
     DateWeekday[DateWeekday["SUNDAY"] = 7] = "SUNDAY";
 })(DateWeekday || (DateWeekday = {}));
+/**
+ * The possible errors, used in the `v_error` field
+ * of #GTokenValue, when the token is a %G_TOKEN_ERROR.
+ */
 export var ErrorType;
 (function (ErrorType) {
+    /** unknown error */
     ErrorType[ErrorType["UNKNOWN"] = 0] = "UNKNOWN";
+    /** unexpected end of file */
     ErrorType[ErrorType["UNEXP_EOF"] = 1] = "UNEXP_EOF";
+    /** unterminated string constant */
     ErrorType[ErrorType["UNEXP_EOF_IN_STRING"] = 2] = "UNEXP_EOF_IN_STRING";
+    /** unterminated comment */
     ErrorType[ErrorType["UNEXP_EOF_IN_COMMENT"] = 3] = "UNEXP_EOF_IN_COMMENT";
+    /** non-digit character in a number */
     ErrorType[ErrorType["NON_DIGIT_IN_CONST"] = 4] = "NON_DIGIT_IN_CONST";
+    /** digit beyond radix in a number */
     ErrorType[ErrorType["DIGIT_RADIX"] = 5] = "DIGIT_RADIX";
+    /** non-decimal floating point number */
     ErrorType[ErrorType["FLOAT_RADIX"] = 6] = "FLOAT_RADIX";
+    /** malformed floating point number */
     ErrorType[ErrorType["FLOAT_MALFORMED"] = 7] = "FLOAT_MALFORMED";
 })(ErrorType || (ErrorType = {}));
+/**
+ * Values corresponding to `errno` codes returned from file operations
+ * on UNIX. Unlike `errno` 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.
+ */
 export var FileError;
 (function (FileError) {
+    /**
+     * Operation not permitted; only the owner of
+     * the file (or other resource) or processes with special privileges
+     * can perform the operation.
+     */
     FileError[FileError["EXIST"] = 0] = "EXIST";
+    /**
+     * File is a directory; you cannot open a directory
+     * for writing, or create or remove hard links to it.
+     */
     FileError[FileError["ISDIR"] = 1] = "ISDIR";
+    /**
+     * Permission denied; the file permissions do not
+     * allow the attempted operation.
+     */
     FileError[FileError["ACCES"] = 2] = "ACCES";
+    /** Filename too long. */
     FileError[FileError["NAMETOOLONG"] = 3] = "NAMETOOLONG";
+    /**
+     * 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.
+     */
     FileError[FileError["NOENT"] = 4] = "NOENT";
+    /**
+     * A file that isn't a directory was specified when
+     * a directory is required.
+     */
     FileError[FileError["NOTDIR"] = 5] = "NOTDIR";
+    /**
+     * 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.
+     */
     FileError[FileError["NXIO"] = 6] = "NXIO";
+    /**
+     * The underlying file system of the specified file
+     * does not support memory mapping.
+     */
     FileError[FileError["NODEV"] = 7] = "NODEV";
+    /**
+     * The directory containing the new link can't be
+     * modified because it's on a read-only file system.
+     */
     FileError[FileError["ROFS"] = 8] = "ROFS";
+    /** Text file busy. */
     FileError[FileError["TXTBSY"] = 9] = "TXTBSY";
+    /**
+     * You passed in a pointer to bad memory.
+     * (GLib won't reliably return this, don't pass in pointers to bad
+     * memory.)
+     */
     FileError[FileError["FAULT"] = 10] = "FAULT";
+    /**
+     * Too many levels of symbolic links were encountered
+     * in looking up a file name. This often indicates a cycle of symbolic
+     * links.
+     */
     FileError[FileError["LOOP"] = 11] = "LOOP";
+    /**
+     * No space left on device; write operation on a
+     * file failed because the disk is full.
+     */
     FileError[FileError["NOSPC"] = 12] = "NOSPC";
+    /**
+     * No memory available. The system cannot allocate
+     * more virtual memory because its capacity is full.
+     */
     FileError[FileError["NOMEM"] = 13] = "NOMEM";
+    /**
+     * The current process has too many files open and
+     * can't open any more. Duplicate descriptors do count toward this
+     * limit.
+     */
     FileError[FileError["MFILE"] = 14] = "MFILE";
+    /**
+     * There are too many distinct file openings in the
+     * entire system.
+     */
     FileError[FileError["NFILE"] = 15] = "NFILE";
+    /**
+     * 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).
+     */
     FileError[FileError["BADF"] = 16] = "BADF";
+    /**
+     * Invalid argument. This is used to indicate
+     * various kinds of problems with passing the wrong argument to a
+     * library function.
+     */
     FileError[FileError["INVAL"] = 17] = "INVAL";
+    /**
+     * 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'.
+     */
     FileError[FileError["PIPE"] = 18] = "PIPE";
+    /**
+     * Resource temporarily unavailable; the call might
+     * work if you try again later.
+     */
     FileError[FileError["AGAIN"] = 19] = "AGAIN";
+    /**
+     * Interrupted function call; an asynchronous signal
+     * occurred and prevented completion of the call. When this
+     * happens, you should try the call again.
+     */
     FileError[FileError["INTR"] = 20] = "INTR";
+    /**
+     * Input/output error; usually used for physical read
+     * or write errors. i.e. the disk or other physical device hardware
+     * is returning errors.
+     */
     FileError[FileError["IO"] = 21] = "IO";
+    /**
+     * Operation not permitted; only the owner of the
+     * file (or other resource) or processes with special privileges can
+     * perform the operation.
+     */
     FileError[FileError["PERM"] = 22] = "PERM";
+    /**
+     * Function not implemented; this indicates that
+     * the system is missing some functionality.
+     */
     FileError[FileError["NOSYS"] = 23] = "NOSYS";
+    /**
+     * Does not correspond to a UNIX error code; this
+     * is the standard "failed for unspecified reason" error code present
+     * in all #GError error code enumerations. Returned if no specific
+     * code applies.
+     */
     FileError[FileError["FAILED"] = 24] = "FAILED";
 })(FileError || (FileError = {}));
+/** Error codes returned by #GIOChannel operations. */
 export var IOChannelError;
 (function (IOChannelError) {
+    /** File too large. */
     IOChannelError[IOChannelError["FBIG"] = 0] = "FBIG";
+    /** Invalid argument. */
     IOChannelError[IOChannelError["INVAL"] = 1] = "INVAL";
+    /** IO error. */
     IOChannelError[IOChannelError["IO"] = 2] = "IO";
+    /** File is a directory. */
     IOChannelError[IOChannelError["ISDIR"] = 3] = "ISDIR";
+    /** No space left on device. */
     IOChannelError[IOChannelError["NOSPC"] = 4] = "NOSPC";
+    /** No such device or address. */
     IOChannelError[IOChannelError["NXIO"] = 5] = "NXIO";
+    /** Value too large for defined datatype. */
     IOChannelError[IOChannelError["OVERFLOW"] = 6] = "OVERFLOW";
+    /** Broken pipe. */
     IOChannelError[IOChannelError["PIPE"] = 7] = "PIPE";
+    /** Some other error. */
     IOChannelError[IOChannelError["FAILED"] = 8] = "FAILED";
 })(IOChannelError || (IOChannelError = {}));
+/**
+ * #GIOError is only used by the deprecated functions
+ * g_io_channel_read(), g_io_channel_write(), and g_io_channel_seek().
+ */
 export var IOError;
 (function (IOError) {
+    /** no error */
     IOError[IOError["NONE"] = 0] = "NONE";
+    /** an EAGAIN error occurred */
     IOError[IOError["AGAIN"] = 1] = "AGAIN";
+    /** an EINVAL error occurred */
     IOError[IOError["INVAL"] = 2] = "INVAL";
+    /** another error occurred */
     IOError[IOError["UNKNOWN"] = 3] = "UNKNOWN";
 })(IOError || (IOError = {}));
+/** Statuses returned by most of the #GIOFuncs functions. */
 export var IOStatus;
 (function (IOStatus) {
+    /** An error occurred. */
     IOStatus[IOStatus["ERROR"] = 0] = "ERROR";
+    /** Success. */
     IOStatus[IOStatus["NORMAL"] = 1] = "NORMAL";
+    /** End of file. */
     IOStatus[IOStatus["EOF"] = 2] = "EOF";
+    /** Resource temporarily unavailable. */
     IOStatus[IOStatus["AGAIN"] = 3] = "AGAIN";
 })(IOStatus || (IOStatus = {}));
+/** Error codes returned by key file parsing. */
 export var KeyFileError;
 (function (KeyFileError) {
+    /**
+     * the text being parsed was in
+     * an unknown encoding
+     */
     KeyFileError[KeyFileError["UNKNOWN_ENCODING"] = 0] = "UNKNOWN_ENCODING";
+    /** document was ill-formed */
     KeyFileError[KeyFileError["PARSE"] = 1] = "PARSE";
+    /** the file was not found */
     KeyFileError[KeyFileError["NOT_FOUND"] = 2] = "NOT_FOUND";
+    /** a requested key was not found */
     KeyFileError[KeyFileError["KEY_NOT_FOUND"] = 3] = "KEY_NOT_FOUND";
+    /** a requested group was not found */
     KeyFileError[KeyFileError["GROUP_NOT_FOUND"] = 4] = "GROUP_NOT_FOUND";
+    /** a value could not be parsed */
     KeyFileError[KeyFileError["INVALID_VALUE"] = 5] = "INVALID_VALUE";
 })(KeyFileError || (KeyFileError = {}));
+/**
+ * Return values from #GLogWriterFuncs 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 #GLogWriterFunc ignores a log entry, it should return
+ * %G_LOG_WRITER_HANDLED.
+ */
 export var LogWriterOutput;
 (function (LogWriterOutput) {
+    /** Log writer has handled the log entry. */
     LogWriterOutput[LogWriterOutput["HANDLED"] = 1] = "HANDLED";
+    /** Log writer could not handle the log entry. */
     LogWriterOutput[LogWriterOutput["UNHANDLED"] = 0] = "UNHANDLED";
 })(LogWriterOutput || (LogWriterOutput = {}));
+/** Error codes returned by markup parsing. */
 export var MarkupError;
 (function (MarkupError) {
+    /** text being parsed was not valid UTF-8 */
     MarkupError[MarkupError["BAD_UTF8"] = 0] = "BAD_UTF8";
+    /** document contained nothing, or only whitespace */
     MarkupError[MarkupError["EMPTY"] = 1] = "EMPTY";
+    /** document was ill-formed */
     MarkupError[MarkupError["PARSE"] = 2] = "PARSE";
+    /**
+     * error should be set by #GMarkupParser
+     * functions; element wasn't known
+     */
     MarkupError[MarkupError["UNKNOWN_ELEMENT"] = 3] = "UNKNOWN_ELEMENT";
+    /**
+     * error should be set by #GMarkupParser
+     * functions; attribute wasn't known
+     */
     MarkupError[MarkupError["UNKNOWN_ATTRIBUTE"] = 4] = "UNKNOWN_ATTRIBUTE";
+    /**
+     * error should be set by #GMarkupParser
+     * functions; content was invalid
+     */
     MarkupError[MarkupError["INVALID_CONTENT"] = 5] = "INVALID_CONTENT";
+    /**
+     * error should be set by #GMarkupParser
+     * functions; a required attribute was missing
+     */
     MarkupError[MarkupError["MISSING_ATTRIBUTE"] = 6] = "MISSING_ATTRIBUTE";
 })(MarkupError || (MarkupError = {}));
+/**
+ * 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.
+ */
 export var NormalizeMode;
 (function (NormalizeMode) {
+    /**
+     * standardize differences that do not affect the
+     * text content, such as the above-mentioned accent representation
+     */
     NormalizeMode[NormalizeMode["DEFAULT"] = 0] = "DEFAULT";
+    /** another name for %G_NORMALIZE_DEFAULT */
     NormalizeMode[NormalizeMode["NFD"] = 0] = "NFD";
+    /**
+     * like %G_NORMALIZE_DEFAULT, but with
+     * composed forms rather than a maximally decomposed form
+     */
     NormalizeMode[NormalizeMode["DEFAULT_COMPOSE"] = 1] = "DEFAULT_COMPOSE";
+    /** another name for %G_NORMALIZE_DEFAULT_COMPOSE */
     NormalizeMode[NormalizeMode["NFC"] = 1] = "NFC";
+    /**
+     * beyond %G_NORMALIZE_DEFAULT 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
+     */
     NormalizeMode[NormalizeMode["ALL"] = 2] = "ALL";
+    /** another name for %G_NORMALIZE_ALL */
     NormalizeMode[NormalizeMode["NFKD"] = 2] = "NFKD";
+    /**
+     * like %G_NORMALIZE_ALL, but with composed
+     * forms rather than a maximally decomposed form
+     */
     NormalizeMode[NormalizeMode["ALL_COMPOSE"] = 3] = "ALL_COMPOSE";
+    /** another name for %G_NORMALIZE_ALL_COMPOSE */
     NormalizeMode[NormalizeMode["NFKC"] = 3] = "NFKC";
 })(NormalizeMode || (NormalizeMode = {}));
+/** Error codes returned by functions converting a string to a number. */
 export var NumberParserError;
 (function (NumberParserError) {
+    /** string was not a valid number */
     NumberParserError[NumberParserError["INVALID"] = 0] = "INVALID";
+    /** string was a number, but out of bounds */
     NumberParserError[NumberParserError["OUT_OF_BOUNDS"] = 1] = "OUT_OF_BOUNDS";
 })(NumberParserError || (NumberParserError = {}));
+/**
+ * The possible statuses of a one-time initialization function
+ * controlled by a #GOnce struct.
+ */
 export var OnceStatus;
 (function (OnceStatus) {
+    /** the function has not been called yet. */
     OnceStatus[OnceStatus["NOTCALLED"] = 0] = "NOTCALLED";
+    /** the function call is currently in progress. */
     OnceStatus[OnceStatus["PROGRESS"] = 1] = "PROGRESS";
+    /** the function has been called. */
     OnceStatus[OnceStatus["READY"] = 2] = "READY";
 })(OnceStatus || (OnceStatus = {}));
+/**
+ * The #GOptionArg 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: `-x arg`, with a long
+ * option: `--name arg` or combined in a single argument: `--name=arg`.
+ */
 export var OptionArg;
 (function (OptionArg) {
+    /** No extra argument. This is useful for simple flags or booleans. */
     OptionArg[OptionArg["NONE"] = 0] = "NONE";
+    /** The option takes a UTF-8 string argument. */
     OptionArg[OptionArg["STRING"] = 1] = "STRING";
+    /** The option takes an integer argument. */
     OptionArg[OptionArg["INT"] = 2] = "INT";
+    /**
+     * The option provides a callback (of type #GOptionArgFunc)
+     * to parse the extra argument.
+     */
     OptionArg[OptionArg["CALLBACK"] = 3] = "CALLBACK";
+    /**
+     * The option takes a filename as argument, which will
+     * be in the GLib filename encoding rather than UTF-8.
+     */
     OptionArg[OptionArg["FILENAME"] = 4] = "FILENAME";
+    /**
+     * The option takes a string argument, multiple
+     * uses of the option are collected into an array of strings.
+     */
     OptionArg[OptionArg["STRING_ARRAY"] = 5] = "STRING_ARRAY";
+    /**
+     * The option takes a filename as argument,
+     * multiple uses of the option are collected into an array of strings.
+     */
     OptionArg[OptionArg["FILENAME_ARRAY"] = 6] = "FILENAME_ARRAY";
+    /**
+     * 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
+     */
     OptionArg[OptionArg["DOUBLE"] = 7] = "DOUBLE";
+    /**
+     * The option takes a 64-bit integer. Like
+     * %G_OPTION_ARG_INT but for larger numbers. The number can be in
+     * decimal base, or in hexadecimal (when prefixed with `0x`, for
+     * example, `0xffffffff`). Since 2.12
+     */
     OptionArg[OptionArg["INT64"] = 8] = "INT64";
 })(OptionArg || (OptionArg = {}));
+/** Error codes returned by option parsing. */
 export var OptionError;
 (function (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 g_option_context_set_ignore_unknown_options().
+     */
     OptionError[OptionError["UNKNOWN_OPTION"] = 0] = "UNKNOWN_OPTION";
+    /** A value couldn't be parsed. */
     OptionError[OptionError["BAD_VALUE"] = 1] = "BAD_VALUE";
+    /** A #GOptionArgFunc callback failed. */
     OptionError[OptionError["FAILED"] = 2] = "FAILED";
 })(OptionError || (OptionError = {}));
+/** Error codes returned by regular expressions functions. */
 export var RegexError;
 (function (RegexError) {
+    /** Compilation of the regular expression failed. */
     RegexError[RegexError["COMPILE"] = 0] = "COMPILE";
+    /** Optimization of the regular expression failed. */
     RegexError[RegexError["OPTIMIZE"] = 1] = "OPTIMIZE";
+    /**
+     * Replacement failed due to an ill-formed replacement
+     * string.
+     */
     RegexError[RegexError["REPLACE"] = 2] = "REPLACE";
+    /** The match process failed. */
     RegexError[RegexError["MATCH"] = 3] = "MATCH";
+    /**
+     * Internal error of the regular expression engine.
+     * Since 2.16
+     */
     RegexError[RegexError["INTERNAL"] = 4] = "INTERNAL";
+    /** "\\" at end of pattern. Since 2.16 */
     RegexError[RegexError["STRAY_BACKSLASH"] = 101] = "STRAY_BACKSLASH";
+    /** "\\c" at end of pattern. Since 2.16 */
     RegexError[RegexError["MISSING_CONTROL_CHAR"] = 102] = "MISSING_CONTROL_CHAR";
+    /**
+     * Unrecognized character follows "\\".
+     * Since 2.16
+     */
     RegexError[RegexError["UNRECOGNIZED_ESCAPE"] = 103] = "UNRECOGNIZED_ESCAPE";
+    /**
+     * Numbers out of order in "{}"
+     * quantifier. Since 2.16
+     */
     RegexError[RegexError["QUANTIFIERS_OUT_OF_ORDER"] = 104] = "QUANTIFIERS_OUT_OF_ORDER";
+    /**
+     * Number too big in "{}" quantifier.
+     * Since 2.16
+     */
     RegexError[RegexError["QUANTIFIER_TOO_BIG"] = 105] = "QUANTIFIER_TOO_BIG";
+    /**
+     * Missing terminating "]" for
+     * character class. Since 2.16
+     */
     RegexError[RegexError["UNTERMINATED_CHARACTER_CLASS"] = 106] = "UNTERMINATED_CHARACTER_CLASS";
+    /**
+     * Invalid escape sequence
+     * in character class. Since 2.16
+     */
     RegexError[RegexError["INVALID_ESCAPE_IN_CHARACTER_CLASS"] = 107] = "INVALID_ESCAPE_IN_CHARACTER_CLASS";
+    /**
+     * Range out of order in character class.
+     * Since 2.16
+     */
     RegexError[RegexError["RANGE_OUT_OF_ORDER"] = 108] = "RANGE_OUT_OF_ORDER";
+    /** Nothing to repeat. Since 2.16 */
     RegexError[RegexError["NOTHING_TO_REPEAT"] = 109] = "NOTHING_TO_REPEAT";
+    /**
+     * Unrecognized character after "(?",
+     * "(?<" or "(?P". Since 2.16
+     */
     RegexError[RegexError["UNRECOGNIZED_CHARACTER"] = 112] = "UNRECOGNIZED_CHARACTER";
+    /**
+     * POSIX named classes are
+     * supported only within a class. Since 2.16
+     */
     RegexError[RegexError["POSIX_NAMED_CLASS_OUTSIDE_CLASS"] = 113] = "POSIX_NAMED_CLASS_OUTSIDE_CLASS";
+    /**
+     * Missing terminating ")" or ")"
+     * without opening "(". Since 2.16
+     */
     RegexError[RegexError["UNMATCHED_PARENTHESIS"] = 114] = "UNMATCHED_PARENTHESIS";
+    /**
+     * Reference to non-existent
+     * subpattern. Since 2.16
+     */
     RegexError[RegexError["INEXISTENT_SUBPATTERN_REFERENCE"] = 115] = "INEXISTENT_SUBPATTERN_REFERENCE";
+    /**
+     * Missing terminating ")" after comment.
+     * Since 2.16
+     */
     RegexError[RegexError["UNTERMINATED_COMMENT"] = 118] = "UNTERMINATED_COMMENT";
+    /**
+     * Regular expression too large.
+     * Since 2.16
+     */
     RegexError[RegexError["EXPRESSION_TOO_LARGE"] = 120] = "EXPRESSION_TOO_LARGE";
+    /** Failed to get memory. Since 2.16 */
     RegexError[RegexError["MEMORY_ERROR"] = 121] = "MEMORY_ERROR";
+    /**
+     * Lookbehind assertion is not
+     * fixed length. Since 2.16
+     */
     RegexError[RegexError["VARIABLE_LENGTH_LOOKBEHIND"] = 125] = "VARIABLE_LENGTH_LOOKBEHIND";
+    /**
+     * Malformed number or name after "(?(".
+     * Since 2.16
+     */
     RegexError[RegexError["MALFORMED_CONDITION"] = 126] = "MALFORMED_CONDITION";
+    /**
+     * Conditional group contains
+     * more than two branches. Since 2.16
+     */
     RegexError[RegexError["TOO_MANY_CONDITIONAL_BRANCHES"] = 127] = "TOO_MANY_CONDITIONAL_BRANCHES";
+    /**
+     * Assertion expected after "(?(".
+     * Since 2.16
+     */
     RegexError[RegexError["ASSERTION_EXPECTED"] = 128] = "ASSERTION_EXPECTED";
+    /**
+     * Unknown POSIX class name.
+     * Since 2.16
+     */
     RegexError[RegexError["UNKNOWN_POSIX_CLASS_NAME"] = 130] = "UNKNOWN_POSIX_CLASS_NAME";
+    /**
+     * POSIX collating
+     * elements are not supported. Since 2.16
+     */
     RegexError[RegexError["POSIX_COLLATING_ELEMENTS_NOT_SUPPORTED"] = 131] = "POSIX_COLLATING_ELEMENTS_NOT_SUPPORTED";
+    /**
+     * Character value in "\\x{...}" sequence
+     * is too large. Since 2.16
+     */
     RegexError[RegexError["HEX_CODE_TOO_LARGE"] = 134] = "HEX_CODE_TOO_LARGE";
+    /** Invalid condition "(?(0)". Since 2.16 */
     RegexError[RegexError["INVALID_CONDITION"] = 135] = "INVALID_CONDITION";
+    /**
+     * \\C not allowed in
+     * lookbehind assertion. Since 2.16
+     */
     RegexError[RegexError["SINGLE_BYTE_MATCH_IN_LOOKBEHIND"] = 136] = "SINGLE_BYTE_MATCH_IN_LOOKBEHIND";
+    /**
+     * Recursive call could loop indefinitely.
+     * Since 2.16
+     */
     RegexError[RegexError["INFINITE_LOOP"] = 140] = "INFINITE_LOOP";
+    /**
+     * Missing terminator
+     * in subpattern name. Since 2.16
+     */
     RegexError[RegexError["MISSING_SUBPATTERN_NAME_TERMINATOR"] = 142] = "MISSING_SUBPATTERN_NAME_TERMINATOR";
+    /**
+     * Two named subpatterns have
+     * the same name. Since 2.16
+     */
     RegexError[RegexError["DUPLICATE_SUBPATTERN_NAME"] = 143] = "DUPLICATE_SUBPATTERN_NAME";
+    /**
+     * Malformed "\\P" or "\\p" sequence.
+     * Since 2.16
+     */
     RegexError[RegexError["MALFORMED_PROPERTY"] = 146] = "MALFORMED_PROPERTY";
+    /**
+     * Unknown property name after "\\P" or
+     * "\\p". Since 2.16
+     */
     RegexError[RegexError["UNKNOWN_PROPERTY"] = 147] = "UNKNOWN_PROPERTY";
+    /**
+     * Subpattern name is too long
+     * (maximum 32 characters). Since 2.16
+     */
     RegexError[RegexError["SUBPATTERN_NAME_TOO_LONG"] = 148] = "SUBPATTERN_NAME_TOO_LONG";
+    /**
+     * Too many named subpatterns (maximum
+     * 10,000). Since 2.16
+     */
     RegexError[RegexError["TOO_MANY_SUBPATTERNS"] = 149] = "TOO_MANY_SUBPATTERNS";
+    /**
+     * Octal value is greater than "\\377".
+     * Since 2.16
+     */
     RegexError[RegexError["INVALID_OCTAL_VALUE"] = 151] = "INVALID_OCTAL_VALUE";
+    /**
+     * "DEFINE" group contains more
+     * than one branch. Since 2.16
+     */
     RegexError[RegexError["TOO_MANY_BRANCHES_IN_DEFINE"] = 154] = "TOO_MANY_BRANCHES_IN_DEFINE";
+    /**
+     * Repeating a "DEFINE" group is not allowed.
+     * This error is never raised. Since: 2.16 Deprecated: 2.34
+     */
     RegexError[RegexError["DEFINE_REPETION"] = 155] = "DEFINE_REPETION";
+    /**
+     * Inconsistent newline options.
+     * Since 2.16
+     */
     RegexError[RegexError["INCONSISTENT_NEWLINE_OPTIONS"] = 156] = "INCONSISTENT_NEWLINE_OPTIONS";
+    /**
+     * "\\g" is not followed by a braced,
+     * angle-bracketed, or quoted name or number, or by a plain number. Since: 2.16
+     */
     RegexError[RegexError["MISSING_BACK_REFERENCE"] = 157] = "MISSING_BACK_REFERENCE";
+    /** relative reference must not be zero. Since: 2.34 */
     RegexError[RegexError["INVALID_RELATIVE_REFERENCE"] = 158] = "INVALID_RELATIVE_REFERENCE";
+    /**
+     * the backtracing
+     * control verb used does not allow an argument. Since: 2.34
+     */
     RegexError[RegexError["BACKTRACKING_CONTROL_VERB_ARGUMENT_FORBIDDEN"] = 159] = "BACKTRACKING_CONTROL_VERB_ARGUMENT_FORBIDDEN";
+    /**
+     * unknown backtracing
+     * control verb. Since: 2.34
+     */
     RegexError[RegexError["UNKNOWN_BACKTRACKING_CONTROL_VERB"] = 160] = "UNKNOWN_BACKTRACKING_CONTROL_VERB";
+    /** number is too big in escape sequence. Since: 2.34 */
     RegexError[RegexError["NUMBER_TOO_BIG"] = 161] = "NUMBER_TOO_BIG";
+    /** Missing subpattern name. Since: 2.34 */
     RegexError[RegexError["MISSING_SUBPATTERN_NAME"] = 162] = "MISSING_SUBPATTERN_NAME";
+    /** Missing digit. Since 2.34 */
     RegexError[RegexError["MISSING_DIGIT"] = 163] = "MISSING_DIGIT";
+    /**
+     * In JavaScript compatibility mode,
+     * "[" is an invalid data character. Since: 2.34
+     */
     RegexError[RegexError["INVALID_DATA_CHARACTER"] = 164] = "INVALID_DATA_CHARACTER";
+    /**
+     * different names for subpatterns of the
+     * same number are not allowed. Since: 2.34
+     */
     RegexError[RegexError["EXTRA_SUBPATTERN_NAME"] = 165] = "EXTRA_SUBPATTERN_NAME";
+    /**
+     * the backtracing control
+     * verb requires an argument. Since: 2.34
+     */
     RegexError[RegexError["BACKTRACKING_CONTROL_VERB_ARGUMENT_REQUIRED"] = 166] = "BACKTRACKING_CONTROL_VERB_ARGUMENT_REQUIRED";
+    /**
+     * "\\c" must be followed by an ASCII
+     * character. Since: 2.34
+     */
     RegexError[RegexError["INVALID_CONTROL_CHAR"] = 168] = "INVALID_CONTROL_CHAR";
+    /**
+     * "\\k" is not followed by a braced, angle-bracketed, or
+     * quoted name. Since: 2.34
+     */
     RegexError[RegexError["MISSING_NAME"] = 169] = "MISSING_NAME";
+    /** "\\N" is not supported in a class. Since: 2.34 */
     RegexError[RegexError["NOT_SUPPORTED_IN_CLASS"] = 171] = "NOT_SUPPORTED_IN_CLASS";
+    /** too many forward references. Since: 2.34 */
     RegexError[RegexError["TOO_MANY_FORWARD_REFERENCES"] = 172] = "TOO_MANY_FORWARD_REFERENCES";
+    /**
+     * the name is too long in "(*MARK)", "(*PRUNE)",
+     * "(*SKIP)", or "(*THEN)". Since: 2.34
+     */
     RegexError[RegexError["NAME_TOO_LONG"] = 175] = "NAME_TOO_LONG";
+    /**
+     * the character value in the \\u sequence is
+     * too large. Since: 2.34
+     */
     RegexError[RegexError["CHARACTER_VALUE_TOO_LARGE"] = 176] = "CHARACTER_VALUE_TOO_LARGE";
 })(RegexError || (RegexError = {}));
+/**
+ * An enumeration specifying the base position for a
+ * g_io_channel_seek_position() operation.
+ */
 export var SeekType;
 (function (SeekType) {
+    /** the current position in the file. */
     SeekType[SeekType["CUR"] = 0] = "CUR";
+    /** the start of the file. */
     SeekType[SeekType["SET"] = 1] = "SET";
+    /** the end of the file. */
     SeekType[SeekType["END"] = 2] = "END";
 })(SeekType || (SeekType = {}));
+/** Error codes returned by shell functions. */
 export var ShellError;
 (function (ShellError) {
+    /** Mismatched or otherwise mangled quoting. */
     ShellError[ShellError["BAD_QUOTING"] = 0] = "BAD_QUOTING";
+    /** String to be parsed was empty. */
     ShellError[ShellError["EMPTY_STRING"] = 1] = "EMPTY_STRING";
+    /** Some other error. */
     ShellError[ShellError["FAILED"] = 2] = "FAILED";
 })(ShellError || (ShellError = {}));
 export var SliceConfig;
@@ -271,33 +838,79 @@ export var SliceConfig;
     SliceConfig[SliceConfig["CHUNK_SIZES"] = 5] = "CHUNK_SIZES";
     SliceConfig[SliceConfig["CONTENTION_COUNTER"] = 6] = "CONTENTION_COUNTER";
 })(SliceConfig || (SliceConfig = {}));
+/** Error codes returned by spawning processes. */
 export var SpawnError;
 (function (SpawnError) {
+    /** Fork failed due to lack of memory. */
     SpawnError[SpawnError["FORK"] = 0] = "FORK";
+    /** Read or select on pipes failed. */
     SpawnError[SpawnError["READ"] = 1] = "READ";
+    /** Changing to working directory failed. */
     SpawnError[SpawnError["CHDIR"] = 2] = "CHDIR";
+    /** execv() returned `EACCES` */
     SpawnError[SpawnError["ACCES"] = 3] = "ACCES";
+    /** execv() returned `EPERM` */
     SpawnError[SpawnError["PERM"] = 4] = "PERM";
+    /** execv() returned `E2BIG` */
     SpawnError[SpawnError["TOO_BIG"] = 5] = "TOO_BIG";
+    /** deprecated alias for %G_SPAWN_ERROR_TOO_BIG (deprecated since GLib 2.32) */
     SpawnError[SpawnError["_2BIG"] = 5] = "_2BIG";
+    /** execv() returned `ENOEXEC` */
     SpawnError[SpawnError["NOEXEC"] = 6] = "NOEXEC";
+    /** execv() returned `ENAMETOOLONG` */
     SpawnError[SpawnError["NAMETOOLONG"] = 7] = "NAMETOOLONG";
+    /** execv() returned `ENOENT` */
     SpawnError[SpawnError["NOENT"] = 8] = "NOENT";
+    /** execv() returned `ENOMEM` */
     SpawnError[SpawnError["NOMEM"] = 9] = "NOMEM";
+    /** execv() returned `ENOTDIR` */
     SpawnError[SpawnError["NOTDIR"] = 10] = "NOTDIR";
+    /** execv() returned `ELOOP` */
     SpawnError[SpawnError["LOOP"] = 11] = "LOOP";
+    /** execv() returned `ETXTBUSY` */
     SpawnError[SpawnError["TXTBUSY"] = 12] = "TXTBUSY";
+    /** execv() returned `EIO` */
     SpawnError[SpawnError["IO"] = 13] = "IO";
+    /** execv() returned `ENFILE` */
     SpawnError[SpawnError["NFILE"] = 14] = "NFILE";
+    /** execv() returned `EMFILE` */
     SpawnError[SpawnError["MFILE"] = 15] = "MFILE";
+    /** execv() returned `EINVAL` */
     SpawnError[SpawnError["INVAL"] = 16] = "INVAL";
+    /** execv() returned `EISDIR` */
     SpawnError[SpawnError["ISDIR"] = 17] = "ISDIR";
+    /** execv() returned `ELIBBAD` */
     SpawnError[SpawnError["LIBBAD"] = 18] = "LIBBAD";
+    /**
+     * Some other fatal failure,
+     * `error->message` should explain.
+     */
     SpawnError[SpawnError["FAILED"] = 19] = "FAILED";
 })(SpawnError || (SpawnError = {}));
+/**
+ * The type of file to return the filename for, when used with
+ * [func@GLib.test_build_filename].
+ *
+ * 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 `EXTRA_DIST` or
+ * `dist_schema_DATA` sense, in which case they will always be in the
+ * srcdir) or built (in the `BUILT_SOURCES` 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.
+ */
 export var TestFileType;
 (function (TestFileType) {
+    /** a file that was included in the distribution tarball */
     TestFileType[TestFileType["DIST"] = 0] = "DIST";
+    /** a file that was built on the compiling machine */
     TestFileType[TestFileType["BUILT"] = 1] = "BUILT";
 })(TestFileType || (TestFileType = {}));
 export var TestLogType;
@@ -322,388 +935,830 @@ export var TestResult;
     TestResult[TestResult["FAILURE"] = 2] = "FAILURE";
     TestResult[TestResult["INCOMPLETE"] = 3] = "INCOMPLETE";
 })(TestResult || (TestResult = {}));
+/** Possible errors of thread related functions. */
 export var ThreadError;
 (function (ThreadError) {
+    /**
+     * a thread couldn't be created due to resource
+     * shortage. Try again later.
+     */
     ThreadError[ThreadError["THREAD_ERROR_AGAIN"] = 0] = "THREAD_ERROR_AGAIN";
 })(ThreadError || (ThreadError = {}));
+/** Thread priorities. */
 export var ThreadPriority;
 (function (ThreadPriority) {
+    /** a priority lower than normal */
     ThreadPriority[ThreadPriority["LOW"] = 0] = "LOW";
+    /** the default priority */
     ThreadPriority[ThreadPriority["NORMAL"] = 1] = "NORMAL";
+    /** a priority higher than normal */
     ThreadPriority[ThreadPriority["HIGH"] = 2] = "HIGH";
+    /** the highest priority */
     ThreadPriority[ThreadPriority["URGENT"] = 3] = "URGENT";
 })(ThreadPriority || (ThreadPriority = {}));
+/**
+ * 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).
+ */
 export var TimeType;
 (function (TimeType) {
+    /** the time is in local standard time */
     TimeType[TimeType["STANDARD"] = 0] = "STANDARD";
+    /** the time is in local daylight time */
     TimeType[TimeType["DAYLIGHT"] = 1] = "DAYLIGHT";
+    /** the time is in UTC */
     TimeType[TimeType["UNIVERSAL"] = 2] = "UNIVERSAL";
 })(TimeType || (TimeType = {}));
+/**
+ * The possible types of token returned from each
+ * g_scanner_get_next_token() call.
+ */
 export var TokenType;
 (function (TokenType) {
+    /** the end of the file */
     TokenType[TokenType["EOF"] = 0] = "EOF";
+    /** a '(' character */
     TokenType[TokenType["LEFT_PAREN"] = 40] = "LEFT_PAREN";
+    /** a ')' character */
     TokenType[TokenType["RIGHT_PAREN"] = 41] = "RIGHT_PAREN";
+    /** a '{' character */
     TokenType[TokenType["LEFT_CURLY"] = 123] = "LEFT_CURLY";
+    /** a '}' character */
     TokenType[TokenType["RIGHT_CURLY"] = 125] = "RIGHT_CURLY";
+    /** a '[' character */
     TokenType[TokenType["LEFT_BRACE"] = 91] = "LEFT_BRACE";
+    /** a ']' character */
     TokenType[TokenType["RIGHT_BRACE"] = 93] = "RIGHT_BRACE";
+    /** a '=' character */
     TokenType[TokenType["EQUAL_SIGN"] = 61] = "EQUAL_SIGN";
+    /** a ',' character */
     TokenType[TokenType["COMMA"] = 44] = "COMMA";
+    /** not a token */
     TokenType[TokenType["NONE"] = 256] = "NONE";
+    /** an error occurred */
     TokenType[TokenType["ERROR"] = 257] = "ERROR";
+    /** a character */
     TokenType[TokenType["CHAR"] = 258] = "CHAR";
+    /** a binary integer */
     TokenType[TokenType["BINARY"] = 259] = "BINARY";
+    /** an octal integer */
     TokenType[TokenType["OCTAL"] = 260] = "OCTAL";
+    /** an integer */
     TokenType[TokenType["INT"] = 261] = "INT";
+    /** a hex integer */
     TokenType[TokenType["HEX"] = 262] = "HEX";
+    /** a floating point number */
     TokenType[TokenType["FLOAT"] = 263] = "FLOAT";
+    /** a string */
     TokenType[TokenType["STRING"] = 264] = "STRING";
+    /** a symbol */
     TokenType[TokenType["SYMBOL"] = 265] = "SYMBOL";
+    /** an identifier */
     TokenType[TokenType["IDENTIFIER"] = 266] = "IDENTIFIER";
+    /** a null identifier */
     TokenType[TokenType["IDENTIFIER_NULL"] = 267] = "IDENTIFIER_NULL";
+    /** one line comment */
     TokenType[TokenType["COMMENT_SINGLE"] = 268] = "COMMENT_SINGLE";
+    /** multi line comment */
     TokenType[TokenType["COMMENT_MULTI"] = 269] = "COMMENT_MULTI";
 })(TokenType || (TokenType = {}));
+/**
+ * Specifies the type of traversal performed by g_tree_traverse(),
+ * g_node_traverse() and g_node_find().
+ *
+ * The different orders are illustrated here:
+ *
+ * - In order: A, B, C, D, E, F, G, H, I
+ *
+ * - Pre order: F, B, A, D, C, E, G, I, H
+ *
+ * - Post order: A, C, E, D, B, H, I, G, F
+ *
+ * - Level order: F, B, G, A, D, I, C, E, H
+ */
 export var TraverseType;
 (function (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.
+     */
     TraverseType[TraverseType["IN_ORDER"] = 0] = "IN_ORDER";
+    /** visits a node, then its children. */
     TraverseType[TraverseType["PRE_ORDER"] = 1] = "PRE_ORDER";
+    /** visits the node's children, then the node itself. */
     TraverseType[TraverseType["POST_ORDER"] = 2] = "POST_ORDER";
+    /**
+     * is not implemented for
+     * balanced binary trees.
+     * For n-ary trees, 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.
+     */
     TraverseType[TraverseType["LEVEL_ORDER"] = 3] = "LEVEL_ORDER";
 })(TraverseType || (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 %G_UNICODE_BREAK_UNKNOWN.
+ *
+ * See [Unicode Line Breaking Algorithm](https://www.unicode.org/reports/tr14/).
+ */
 export var UnicodeBreakType;
 (function (UnicodeBreakType) {
+    /** Mandatory Break (BK) */
     UnicodeBreakType[UnicodeBreakType["MANDATORY"] = 0] = "MANDATORY";
+    /** Carriage Return (CR) */
     UnicodeBreakType[UnicodeBreakType["CARRIAGE_RETURN"] = 1] = "CARRIAGE_RETURN";
+    /** Line Feed (LF) */
     UnicodeBreakType[UnicodeBreakType["LINE_FEED"] = 2] = "LINE_FEED";
+    /** Attached Characters and Combining Marks (CM) */
     UnicodeBreakType[UnicodeBreakType["COMBINING_MARK"] = 3] = "COMBINING_MARK";
+    /** Surrogates (SG) */
     UnicodeBreakType[UnicodeBreakType["SURROGATE"] = 4] = "SURROGATE";
+    /** Zero Width Space (ZW) */
     UnicodeBreakType[UnicodeBreakType["ZERO_WIDTH_SPACE"] = 5] = "ZERO_WIDTH_SPACE";
+    /** Inseparable (IN) */
     UnicodeBreakType[UnicodeBreakType["INSEPARABLE"] = 6] = "INSEPARABLE";
+    /** Non-breaking ("Glue") (GL) */
     UnicodeBreakType[UnicodeBreakType["NON_BREAKING_GLUE"] = 7] = "NON_BREAKING_GLUE";
+    /** Contingent Break Opportunity (CB) */
     UnicodeBreakType[UnicodeBreakType["CONTINGENT"] = 8] = "CONTINGENT";
+    /** Space (SP) */
     UnicodeBreakType[UnicodeBreakType["SPACE"] = 9] = "SPACE";
+    /** Break Opportunity After (BA) */
     UnicodeBreakType[UnicodeBreakType["AFTER"] = 10] = "AFTER";
+    /** Break Opportunity Before (BB) */
     UnicodeBreakType[UnicodeBreakType["BEFORE"] = 11] = "BEFORE";
+    /** Break Opportunity Before and After (B2) */
     UnicodeBreakType[UnicodeBreakType["BEFORE_AND_AFTER"] = 12] = "BEFORE_AND_AFTER";
+    /** Hyphen (HY) */
     UnicodeBreakType[UnicodeBreakType["HYPHEN"] = 13] = "HYPHEN";
+    /** Nonstarter (NS) */
     UnicodeBreakType[UnicodeBreakType["NON_STARTER"] = 14] = "NON_STARTER";
+    /** Opening Punctuation (OP) */
     UnicodeBreakType[UnicodeBreakType["OPEN_PUNCTUATION"] = 15] = "OPEN_PUNCTUATION";
+    /** Closing Punctuation (CL) */
     UnicodeBreakType[UnicodeBreakType["CLOSE_PUNCTUATION"] = 16] = "CLOSE_PUNCTUATION";
+    /** Ambiguous Quotation (QU) */
     UnicodeBreakType[UnicodeBreakType["QUOTATION"] = 17] = "QUOTATION";
+    /** Exclamation/Interrogation (EX) */
     UnicodeBreakType[UnicodeBreakType["EXCLAMATION"] = 18] = "EXCLAMATION";
+    /** Ideographic (ID) */
     UnicodeBreakType[UnicodeBreakType["IDEOGRAPHIC"] = 19] = "IDEOGRAPHIC";
+    /** Numeric (NU) */
     UnicodeBreakType[UnicodeBreakType["NUMERIC"] = 20] = "NUMERIC";
+    /** Infix Separator (Numeric) (IS) */
     UnicodeBreakType[UnicodeBreakType["INFIX_SEPARATOR"] = 21] = "INFIX_SEPARATOR";
+    /** Symbols Allowing Break After (SY) */
     UnicodeBreakType[UnicodeBreakType["SYMBOL"] = 22] = "SYMBOL";
+    /** Ordinary Alphabetic and Symbol Characters (AL) */
     UnicodeBreakType[UnicodeBreakType["ALPHABETIC"] = 23] = "ALPHABETIC";
+    /** Prefix (Numeric) (PR) */
     UnicodeBreakType[UnicodeBreakType["PREFIX"] = 24] = "PREFIX";
+    /** Postfix (Numeric) (PO) */
     UnicodeBreakType[UnicodeBreakType["POSTFIX"] = 25] = "POSTFIX";
+    /** Complex Content Dependent (South East Asian) (SA) */
     UnicodeBreakType[UnicodeBreakType["COMPLEX_CONTEXT"] = 26] = "COMPLEX_CONTEXT";
+    /** Ambiguous (Alphabetic or Ideographic) (AI) */
     UnicodeBreakType[UnicodeBreakType["AMBIGUOUS"] = 27] = "AMBIGUOUS";
+    /** Unknown (XX) */
     UnicodeBreakType[UnicodeBreakType["UNKNOWN"] = 28] = "UNKNOWN";
+    /** Next Line (NL) */
     UnicodeBreakType[UnicodeBreakType["NEXT_LINE"] = 29] = "NEXT_LINE";
+    /** Word Joiner (WJ) */
     UnicodeBreakType[UnicodeBreakType["WORD_JOINER"] = 30] = "WORD_JOINER";
+    /** Hangul L Jamo (JL) */
     UnicodeBreakType[UnicodeBreakType["HANGUL_L_JAMO"] = 31] = "HANGUL_L_JAMO";
+    /** Hangul V Jamo (JV) */
     UnicodeBreakType[UnicodeBreakType["HANGUL_V_JAMO"] = 32] = "HANGUL_V_JAMO";
+    /** Hangul T Jamo (JT) */
     UnicodeBreakType[UnicodeBreakType["HANGUL_T_JAMO"] = 33] = "HANGUL_T_JAMO";
+    /** Hangul LV Syllable (H2) */
     UnicodeBreakType[UnicodeBreakType["HANGUL_LV_SYLLABLE"] = 34] = "HANGUL_LV_SYLLABLE";
+    /** Hangul LVT Syllable (H3) */
     UnicodeBreakType[UnicodeBreakType["HANGUL_LVT_SYLLABLE"] = 35] = "HANGUL_LVT_SYLLABLE";
+    /**
+     * Closing Parenthesis (CP). Since 2.28. Deprecated: 2.70: Use %G_UNICODE_BREAK_CLOSE_PARENTHESIS instead.
+     */
     UnicodeBreakType[UnicodeBreakType["CLOSE_PARANTHESIS"] = 36] = "CLOSE_PARANTHESIS";
+    /** Closing Parenthesis (CP). Since 2.70 */
     UnicodeBreakType[UnicodeBreakType["CLOSE_PARENTHESIS"] = 36] = "CLOSE_PARENTHESIS";
+    /** Conditional Japanese Starter (CJ). Since: 2.32 */
     UnicodeBreakType[UnicodeBreakType["CONDITIONAL_JAPANESE_STARTER"] = 37] = "CONDITIONAL_JAPANESE_STARTER";
+    /** Hebrew Letter (HL). Since: 2.32 */
     UnicodeBreakType[UnicodeBreakType["HEBREW_LETTER"] = 38] = "HEBREW_LETTER";
+    /** Regional Indicator (RI). Since: 2.36 */
     UnicodeBreakType[UnicodeBreakType["REGIONAL_INDICATOR"] = 39] = "REGIONAL_INDICATOR";
+    /** Emoji Base (EB). Since: 2.50 */
     UnicodeBreakType[UnicodeBreakType["EMOJI_BASE"] = 40] = "EMOJI_BASE";
+    /** Emoji Modifier (EM). Since: 2.50 */
     UnicodeBreakType[UnicodeBreakType["EMOJI_MODIFIER"] = 41] = "EMOJI_MODIFIER";
+    /** Zero Width Joiner (ZWJ). Since: 2.50 */
     UnicodeBreakType[UnicodeBreakType["ZERO_WIDTH_JOINER"] = 42] = "ZERO_WIDTH_JOINER";
+    /** Aksara (AK). Since: 2.80 */
     UnicodeBreakType[UnicodeBreakType["AKSARA"] = 43] = "AKSARA";
+    /** Aksara Pre-Base (AP). Since: 2.80 */
     UnicodeBreakType[UnicodeBreakType["AKSARA_PRE_BASE"] = 44] = "AKSARA_PRE_BASE";
+    /** Aksara Start (AS). Since: 2.80 */
     UnicodeBreakType[UnicodeBreakType["AKSARA_START"] = 45] = "AKSARA_START";
+    /** Virama Final (VF). Since: 2.80 */
     UnicodeBreakType[UnicodeBreakType["VIRAMA_FINAL"] = 46] = "VIRAMA_FINAL";
+    /** Virama (VI). Since: 2.80 */
     UnicodeBreakType[UnicodeBreakType["VIRAMA"] = 47] = "VIRAMA";
 })(UnicodeBreakType || (UnicodeBreakType = {}));
+/**
+ * The #GUnicodeScript 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 #PangoScript.
+ *
+ * Note that new types may be added in the future. Applications
+ * should be ready to handle unknown values.
+ * See [Unicode Standard Annex #24: Script names](http://www.unicode.org/reports/tr24/).
+ */
 export var UnicodeScript;
 (function (UnicodeScript) {
+    /** a value never returned from g_unichar_get_script() */
     UnicodeScript[UnicodeScript["INVALID_CODE"] = -1] = "INVALID_CODE";
+    /** a character used by multiple different scripts */
     UnicodeScript[UnicodeScript["COMMON"] = 0] = "COMMON";
+    /**
+     * a mark glyph that takes its script from the
+     * base glyph to which it is attached
+     */
     UnicodeScript[UnicodeScript["INHERITED"] = 1] = "INHERITED";
+    /** Arabic */
     UnicodeScript[UnicodeScript["ARABIC"] = 2] = "ARABIC";
+    /** Armenian */
     UnicodeScript[UnicodeScript["ARMENIAN"] = 3] = "ARMENIAN";
+    /** Bengali */
     UnicodeScript[UnicodeScript["BENGALI"] = 4] = "BENGALI";
+    /** Bopomofo */
     UnicodeScript[UnicodeScript["BOPOMOFO"] = 5] = "BOPOMOFO";
+    /** Cherokee */
     UnicodeScript[UnicodeScript["CHEROKEE"] = 6] = "CHEROKEE";
+    /** Coptic */
     UnicodeScript[UnicodeScript["COPTIC"] = 7] = "COPTIC";
+    /** Cyrillic */
     UnicodeScript[UnicodeScript["CYRILLIC"] = 8] = "CYRILLIC";
+    /** Deseret */
     UnicodeScript[UnicodeScript["DESERET"] = 9] = "DESERET";
+    /** Devanagari */
     UnicodeScript[UnicodeScript["DEVANAGARI"] = 10] = "DEVANAGARI";
+    /** Ethiopic */
     UnicodeScript[UnicodeScript["ETHIOPIC"] = 11] = "ETHIOPIC";
+    /** Georgian */
     UnicodeScript[UnicodeScript["GEORGIAN"] = 12] = "GEORGIAN";
+    /** Gothic */
     UnicodeScript[UnicodeScript["GOTHIC"] = 13] = "GOTHIC";
+    /** Greek */
     UnicodeScript[UnicodeScript["GREEK"] = 14] = "GREEK";
+    /** Gujarati */
     UnicodeScript[UnicodeScript["GUJARATI"] = 15] = "GUJARATI";
+    /** Gurmukhi */
     UnicodeScript[UnicodeScript["GURMUKHI"] = 16] = "GURMUKHI";
+    /** Han */
     UnicodeScript[UnicodeScript["HAN"] = 17] = "HAN";
+    /** Hangul */
     UnicodeScript[UnicodeScript["HANGUL"] = 18] = "HANGUL";
+    /** Hebrew */
     UnicodeScript[UnicodeScript["HEBREW"] = 19] = "HEBREW";
+    /** Hiragana */
     UnicodeScript[UnicodeScript["HIRAGANA"] = 20] = "HIRAGANA";
+    /** Kannada */
     UnicodeScript[UnicodeScript["KANNADA"] = 21] = "KANNADA";
+    /** Katakana */
     UnicodeScript[UnicodeScript["KATAKANA"] = 22] = "KATAKANA";
+    /** Khmer */
     UnicodeScript[UnicodeScript["KHMER"] = 23] = "KHMER";
+    /** Lao */
     UnicodeScript[UnicodeScript["LAO"] = 24] = "LAO";
+    /** Latin */
     UnicodeScript[UnicodeScript["LATIN"] = 25] = "LATIN";
+    /** Malayalam */
     UnicodeScript[UnicodeScript["MALAYALAM"] = 26] = "MALAYALAM";
+    /** Mongolian */
     UnicodeScript[UnicodeScript["MONGOLIAN"] = 27] = "MONGOLIAN";
+    /** Myanmar */
     UnicodeScript[UnicodeScript["MYANMAR"] = 28] = "MYANMAR";
+    /** Ogham */
     UnicodeScript[UnicodeScript["OGHAM"] = 29] = "OGHAM";
+    /** Old Italic */
     UnicodeScript[UnicodeScript["OLD_ITALIC"] = 30] = "OLD_ITALIC";
+    /** Oriya */
     UnicodeScript[UnicodeScript["ORIYA"] = 31] = "ORIYA";
+    /** Runic */
     UnicodeScript[UnicodeScript["RUNIC"] = 32] = "RUNIC";
+    /** Sinhala */
     UnicodeScript[UnicodeScript["SINHALA"] = 33] = "SINHALA";
+    /** Syriac */
     UnicodeScript[UnicodeScript["SYRIAC"] = 34] = "SYRIAC";
+    /** Tamil */
     UnicodeScript[UnicodeScript["TAMIL"] = 35] = "TAMIL";
+    /** Telugu */
     UnicodeScript[UnicodeScript["TELUGU"] = 36] = "TELUGU";
+    /** Thaana */
     UnicodeScript[UnicodeScript["THAANA"] = 37] = "THAANA";
+    /** Thai */
     UnicodeScript[UnicodeScript["THAI"] = 38] = "THAI";
+    /** Tibetan */
     UnicodeScript[UnicodeScript["TIBETAN"] = 39] = "TIBETAN";
+    /** Canadian Aboriginal */
     UnicodeScript[UnicodeScript["CANADIAN_ABORIGINAL"] = 40] = "CANADIAN_ABORIGINAL";
+    /** Yi */
     UnicodeScript[UnicodeScript["YI"] = 41] = "YI";
+    /** Tagalog */
     UnicodeScript[UnicodeScript["TAGALOG"] = 42] = "TAGALOG";
+    /** Hanunoo */
     UnicodeScript[UnicodeScript["HANUNOO"] = 43] = "HANUNOO";
+    /** Buhid */
     UnicodeScript[UnicodeScript["BUHID"] = 44] = "BUHID";
+    /** Tagbanwa */
     UnicodeScript[UnicodeScript["TAGBANWA"] = 45] = "TAGBANWA";
+    /** Braille */
     UnicodeScript[UnicodeScript["BRAILLE"] = 46] = "BRAILLE";
+    /** Cypriot */
     UnicodeScript[UnicodeScript["CYPRIOT"] = 47] = "CYPRIOT";
+    /** Limbu */
     UnicodeScript[UnicodeScript["LIMBU"] = 48] = "LIMBU";
+    /** Osmanya */
     UnicodeScript[UnicodeScript["OSMANYA"] = 49] = "OSMANYA";
+    /** Shavian */
     UnicodeScript[UnicodeScript["SHAVIAN"] = 50] = "SHAVIAN";
+    /** Linear B */
     UnicodeScript[UnicodeScript["LINEAR_B"] = 51] = "LINEAR_B";
+    /** Tai Le */
     UnicodeScript[UnicodeScript["TAI_LE"] = 52] = "TAI_LE";
+    /** Ugaritic */
     UnicodeScript[UnicodeScript["UGARITIC"] = 53] = "UGARITIC";
+    /** New Tai Lue */
     UnicodeScript[UnicodeScript["NEW_TAI_LUE"] = 54] = "NEW_TAI_LUE";
+    /** Buginese */
     UnicodeScript[UnicodeScript["BUGINESE"] = 55] = "BUGINESE";
+    /** Glagolitic */
     UnicodeScript[UnicodeScript["GLAGOLITIC"] = 56] = "GLAGOLITIC";
+    /** Tifinagh */
     UnicodeScript[UnicodeScript["TIFINAGH"] = 57] = "TIFINAGH";
+    /** Syloti Nagri */
     UnicodeScript[UnicodeScript["SYLOTI_NAGRI"] = 58] = "SYLOTI_NAGRI";
+    /** Old Persian */
     UnicodeScript[UnicodeScript["OLD_PERSIAN"] = 59] = "OLD_PERSIAN";
+    /** Kharoshthi */
     UnicodeScript[UnicodeScript["KHAROSHTHI"] = 60] = "KHAROSHTHI";
+    /** an unassigned code point */
     UnicodeScript[UnicodeScript["UNKNOWN"] = 61] = "UNKNOWN";
+    /** Balinese */
     UnicodeScript[UnicodeScript["BALINESE"] = 62] = "BALINESE";
+    /** Cuneiform */
     UnicodeScript[UnicodeScript["CUNEIFORM"] = 63] = "CUNEIFORM";
+    /** Phoenician */
     UnicodeScript[UnicodeScript["PHOENICIAN"] = 64] = "PHOENICIAN";
+    /** Phags-pa */
     UnicodeScript[UnicodeScript["PHAGS_PA"] = 65] = "PHAGS_PA";
+    /** N'Ko */
     UnicodeScript[UnicodeScript["NKO"] = 66] = "NKO";
+    /** Kayah Li. Since 2.16.3 */
     UnicodeScript[UnicodeScript["KAYAH_LI"] = 67] = "KAYAH_LI";
+    /** Lepcha. Since 2.16.3 */
     UnicodeScript[UnicodeScript["LEPCHA"] = 68] = "LEPCHA";
+    /** Rejang. Since 2.16.3 */
     UnicodeScript[UnicodeScript["REJANG"] = 69] = "REJANG";
+    /** Sundanese. Since 2.16.3 */
     UnicodeScript[UnicodeScript["SUNDANESE"] = 70] = "SUNDANESE";
+    /** Saurashtra. Since 2.16.3 */
     UnicodeScript[UnicodeScript["SAURASHTRA"] = 71] = "SAURASHTRA";
+    /** Cham. Since 2.16.3 */
     UnicodeScript[UnicodeScript["CHAM"] = 72] = "CHAM";
+    /** Ol Chiki. Since 2.16.3 */
     UnicodeScript[UnicodeScript["OL_CHIKI"] = 73] = "OL_CHIKI";
+    /** Vai. Since 2.16.3 */
     UnicodeScript[UnicodeScript["VAI"] = 74] = "VAI";
+    /** Carian. Since 2.16.3 */
     UnicodeScript[UnicodeScript["CARIAN"] = 75] = "CARIAN";
+    /** Lycian. Since 2.16.3 */
     UnicodeScript[UnicodeScript["LYCIAN"] = 76] = "LYCIAN";
+    /** Lydian. Since 2.16.3 */
     UnicodeScript[UnicodeScript["LYDIAN"] = 77] = "LYDIAN";
+    /** Avestan. Since 2.26 */
     UnicodeScript[UnicodeScript["AVESTAN"] = 78] = "AVESTAN";
+    /** Bamum. Since 2.26 */
     UnicodeScript[UnicodeScript["BAMUM"] = 79] = "BAMUM";
+    /** Egyptian Hieroglpyhs. Since 2.26 */
     UnicodeScript[UnicodeScript["EGYPTIAN_HIEROGLYPHS"] = 80] = "EGYPTIAN_HIEROGLYPHS";
+    /** Imperial Aramaic. Since 2.26 */
     UnicodeScript[UnicodeScript["IMPERIAL_ARAMAIC"] = 81] = "IMPERIAL_ARAMAIC";
+    /** Inscriptional Pahlavi. Since 2.26 */
     UnicodeScript[UnicodeScript["INSCRIPTIONAL_PAHLAVI"] = 82] = "INSCRIPTIONAL_PAHLAVI";
+    /** Inscriptional Parthian. Since 2.26 */
     UnicodeScript[UnicodeScript["INSCRIPTIONAL_PARTHIAN"] = 83] = "INSCRIPTIONAL_PARTHIAN";
+    /** Javanese. Since 2.26 */
     UnicodeScript[UnicodeScript["JAVANESE"] = 84] = "JAVANESE";
+    /** Kaithi. Since 2.26 */
     UnicodeScript[UnicodeScript["KAITHI"] = 85] = "KAITHI";
+    /** Lisu. Since 2.26 */
     UnicodeScript[UnicodeScript["LISU"] = 86] = "LISU";
+    /** Meetei Mayek. Since 2.26 */
     UnicodeScript[UnicodeScript["MEETEI_MAYEK"] = 87] = "MEETEI_MAYEK";
+    /** Old South Arabian. Since 2.26 */
     UnicodeScript[UnicodeScript["OLD_SOUTH_ARABIAN"] = 88] = "OLD_SOUTH_ARABIAN";
+    /** Old Turkic. Since 2.28 */
     UnicodeScript[UnicodeScript["OLD_TURKIC"] = 89] = "OLD_TURKIC";
+    /** Samaritan. Since 2.26 */
     UnicodeScript[UnicodeScript["SAMARITAN"] = 90] = "SAMARITAN";
+    /** Tai Tham. Since 2.26 */
     UnicodeScript[UnicodeScript["TAI_THAM"] = 91] = "TAI_THAM";
+    /** Tai Viet. Since 2.26 */
     UnicodeScript[UnicodeScript["TAI_VIET"] = 92] = "TAI_VIET";
+    /** Batak. Since 2.28 */
     UnicodeScript[UnicodeScript["BATAK"] = 93] = "BATAK";
+    /** Brahmi. Since 2.28 */
     UnicodeScript[UnicodeScript["BRAHMI"] = 94] = "BRAHMI";
+    /** Mandaic. Since 2.28 */
     UnicodeScript[UnicodeScript["MANDAIC"] = 95] = "MANDAIC";
+    /** Chakma. Since: 2.32 */
     UnicodeScript[UnicodeScript["CHAKMA"] = 96] = "CHAKMA";
+    /** Meroitic Cursive. Since: 2.32 */
     UnicodeScript[UnicodeScript["MEROITIC_CURSIVE"] = 97] = "MEROITIC_CURSIVE";
+    /** Meroitic Hieroglyphs. Since: 2.32 */
     UnicodeScript[UnicodeScript["MEROITIC_HIEROGLYPHS"] = 98] = "MEROITIC_HIEROGLYPHS";
+    /** Miao. Since: 2.32 */
     UnicodeScript[UnicodeScript["MIAO"] = 99] = "MIAO";
+    /** Sharada. Since: 2.32 */
     UnicodeScript[UnicodeScript["SHARADA"] = 100] = "SHARADA";
+    /** Sora Sompeng. Since: 2.32 */
     UnicodeScript[UnicodeScript["SORA_SOMPENG"] = 101] = "SORA_SOMPENG";
+    /** Takri. Since: 2.32 */
     UnicodeScript[UnicodeScript["TAKRI"] = 102] = "TAKRI";
+    /** Bassa. Since: 2.42 */
     UnicodeScript[UnicodeScript["BASSA_VAH"] = 103] = "BASSA_VAH";
+    /** Caucasian Albanian. Since: 2.42 */
     UnicodeScript[UnicodeScript["CAUCASIAN_ALBANIAN"] = 104] = "CAUCASIAN_ALBANIAN";
+    /** Duployan. Since: 2.42 */
     UnicodeScript[UnicodeScript["DUPLOYAN"] = 105] = "DUPLOYAN";
+    /** Elbasan. Since: 2.42 */
     UnicodeScript[UnicodeScript["ELBASAN"] = 106] = "ELBASAN";
+    /** Grantha. Since: 2.42 */
     UnicodeScript[UnicodeScript["GRANTHA"] = 107] = "GRANTHA";
+    /** Kjohki. Since: 2.42 */
     UnicodeScript[UnicodeScript["KHOJKI"] = 108] = "KHOJKI";
+    /** Khudawadi, Sindhi. Since: 2.42 */
     UnicodeScript[UnicodeScript["KHUDAWADI"] = 109] = "KHUDAWADI";
+    /** Linear A. Since: 2.42 */
     UnicodeScript[UnicodeScript["LINEAR_A"] = 110] = "LINEAR_A";
+    /** Mahajani. Since: 2.42 */
     UnicodeScript[UnicodeScript["MAHAJANI"] = 111] = "MAHAJANI";
+    /** Manichaean. Since: 2.42 */
     UnicodeScript[UnicodeScript["MANICHAEAN"] = 112] = "MANICHAEAN";
+    /** Mende Kikakui. Since: 2.42 */
     UnicodeScript[UnicodeScript["MENDE_KIKAKUI"] = 113] = "MENDE_KIKAKUI";
+    /** Modi. Since: 2.42 */
     UnicodeScript[UnicodeScript["MODI"] = 114] = "MODI";
+    /** Mro. Since: 2.42 */
     UnicodeScript[UnicodeScript["MRO"] = 115] = "MRO";
+    /** Nabataean. Since: 2.42 */
     UnicodeScript[UnicodeScript["NABATAEAN"] = 116] = "NABATAEAN";
+    /** Old North Arabian. Since: 2.42 */
     UnicodeScript[UnicodeScript["OLD_NORTH_ARABIAN"] = 117] = "OLD_NORTH_ARABIAN";
+    /** Old Permic. Since: 2.42 */
     UnicodeScript[UnicodeScript["OLD_PERMIC"] = 118] = "OLD_PERMIC";
+    /** Pahawh Hmong. Since: 2.42 */
     UnicodeScript[UnicodeScript["PAHAWH_HMONG"] = 119] = "PAHAWH_HMONG";
+    /** Palmyrene. Since: 2.42 */
     UnicodeScript[UnicodeScript["PALMYRENE"] = 120] = "PALMYRENE";
+    /** Pau Cin Hau. Since: 2.42 */
     UnicodeScript[UnicodeScript["PAU_CIN_HAU"] = 121] = "PAU_CIN_HAU";
+    /** Psalter Pahlavi. Since: 2.42 */
     UnicodeScript[UnicodeScript["PSALTER_PAHLAVI"] = 122] = "PSALTER_PAHLAVI";
+    /** Siddham. Since: 2.42 */
     UnicodeScript[UnicodeScript["SIDDHAM"] = 123] = "SIDDHAM";
+    /** Tirhuta. Since: 2.42 */
     UnicodeScript[UnicodeScript["TIRHUTA"] = 124] = "TIRHUTA";
+    /** Warang Citi. Since: 2.42 */
     UnicodeScript[UnicodeScript["WARANG_CITI"] = 125] = "WARANG_CITI";
+    /** Ahom. Since: 2.48 */
     UnicodeScript[UnicodeScript["AHOM"] = 126] = "AHOM";
+    /** Anatolian Hieroglyphs. Since: 2.48 */
     UnicodeScript[UnicodeScript["ANATOLIAN_HIEROGLYPHS"] = 127] = "ANATOLIAN_HIEROGLYPHS";
+    /** Hatran. Since: 2.48 */
     UnicodeScript[UnicodeScript["HATRAN"] = 128] = "HATRAN";
+    /** Multani. Since: 2.48 */
     UnicodeScript[UnicodeScript["MULTANI"] = 129] = "MULTANI";
+    /** Old Hungarian. Since: 2.48 */
     UnicodeScript[UnicodeScript["OLD_HUNGARIAN"] = 130] = "OLD_HUNGARIAN";
+    /** Signwriting. Since: 2.48 */
     UnicodeScript[UnicodeScript["SIGNWRITING"] = 131] = "SIGNWRITING";
+    /** Adlam. Since: 2.50 */
     UnicodeScript[UnicodeScript["ADLAM"] = 132] = "ADLAM";
+    /** Bhaiksuki. Since: 2.50 */
     UnicodeScript[UnicodeScript["BHAIKSUKI"] = 133] = "BHAIKSUKI";
+    /** Marchen. Since: 2.50 */
     UnicodeScript[UnicodeScript["MARCHEN"] = 134] = "MARCHEN";
+    /** Newa. Since: 2.50 */
     UnicodeScript[UnicodeScript["NEWA"] = 135] = "NEWA";
+    /** Osage. Since: 2.50 */
     UnicodeScript[UnicodeScript["OSAGE"] = 136] = "OSAGE";
+    /** Tangut. Since: 2.50 */
     UnicodeScript[UnicodeScript["TANGUT"] = 137] = "TANGUT";
+    /** Masaram Gondi. Since: 2.54 */
     UnicodeScript[UnicodeScript["MASARAM_GONDI"] = 138] = "MASARAM_GONDI";
+    /** Nushu. Since: 2.54 */
     UnicodeScript[UnicodeScript["NUSHU"] = 139] = "NUSHU";
+    /** Soyombo. Since: 2.54 */
     UnicodeScript[UnicodeScript["SOYOMBO"] = 140] = "SOYOMBO";
+    /** Zanabazar Square. Since: 2.54 */
     UnicodeScript[UnicodeScript["ZANABAZAR_SQUARE"] = 141] = "ZANABAZAR_SQUARE";
+    /** Dogra. Since: 2.58 */
     UnicodeScript[UnicodeScript["DOGRA"] = 142] = "DOGRA";
+    /** Gunjala Gondi. Since: 2.58 */
     UnicodeScript[UnicodeScript["GUNJALA_GONDI"] = 143] = "GUNJALA_GONDI";
+    /** Hanifi Rohingya. Since: 2.58 */
     UnicodeScript[UnicodeScript["HANIFI_ROHINGYA"] = 144] = "HANIFI_ROHINGYA";
+    /** Makasar. Since: 2.58 */
     UnicodeScript[UnicodeScript["MAKASAR"] = 145] = "MAKASAR";
+    /** Medefaidrin. Since: 2.58 */
     UnicodeScript[UnicodeScript["MEDEFAIDRIN"] = 146] = "MEDEFAIDRIN";
+    /** Old Sogdian. Since: 2.58 */
     UnicodeScript[UnicodeScript["OLD_SOGDIAN"] = 147] = "OLD_SOGDIAN";
+    /** Sogdian. Since: 2.58 */
     UnicodeScript[UnicodeScript["SOGDIAN"] = 148] = "SOGDIAN";
+    /** Elym. Since: 2.62 */
     UnicodeScript[UnicodeScript["ELYMAIC"] = 149] = "ELYMAIC";
+    /** Nand. Since: 2.62 */
     UnicodeScript[UnicodeScript["NANDINAGARI"] = 150] = "NANDINAGARI";
+    /** Rohg. Since: 2.62 */
     UnicodeScript[UnicodeScript["NYIAKENG_PUACHUE_HMONG"] = 151] = "NYIAKENG_PUACHUE_HMONG";
+    /** Wcho. Since: 2.62 */
     UnicodeScript[UnicodeScript["WANCHO"] = 152] = "WANCHO";
+    /** Chorasmian. Since: 2.66 */
     UnicodeScript[UnicodeScript["CHORASMIAN"] = 153] = "CHORASMIAN";
+    /** Dives Akuru. Since: 2.66 */
     UnicodeScript[UnicodeScript["DIVES_AKURU"] = 154] = "DIVES_AKURU";
+    /** Khitan small script. Since: 2.66 */
     UnicodeScript[UnicodeScript["KHITAN_SMALL_SCRIPT"] = 155] = "KHITAN_SMALL_SCRIPT";
+    /** Yezidi. Since: 2.66 */
     UnicodeScript[UnicodeScript["YEZIDI"] = 156] = "YEZIDI";
+    /** Cypro-Minoan. Since: 2.72 */
     UnicodeScript[UnicodeScript["CYPRO_MINOAN"] = 157] = "CYPRO_MINOAN";
+    /** Old Uyghur. Since: 2.72 */
     UnicodeScript[UnicodeScript["OLD_UYGHUR"] = 158] = "OLD_UYGHUR";
+    /** Tangsa. Since: 2.72 */
     UnicodeScript[UnicodeScript["TANGSA"] = 159] = "TANGSA";
+    /** Toto. Since: 2.72 */
     UnicodeScript[UnicodeScript["TOTO"] = 160] = "TOTO";
+    /** Vithkuqi. Since: 2.72 */
     UnicodeScript[UnicodeScript["VITHKUQI"] = 161] = "VITHKUQI";
+    /** Mathematical notation. Since: 2.72 */
     UnicodeScript[UnicodeScript["MATH"] = 162] = "MATH";
+    /** Kawi. Since 2.74 */
     UnicodeScript[UnicodeScript["KAWI"] = 163] = "KAWI";
+    /** Nag Mundari. Since 2.74 */
     UnicodeScript[UnicodeScript["NAG_MUNDARI"] = 164] = "NAG_MUNDARI";
+    /** Todhri. Since: 2.84 */
     UnicodeScript[UnicodeScript["TODHRI"] = 165] = "TODHRI";
+    /** Garay. Since: 2.84 */
     UnicodeScript[UnicodeScript["GARAY"] = 166] = "GARAY";
+    /** Tulu-Tigalari. Since: 2.84 */
     UnicodeScript[UnicodeScript["TULU_TIGALARI"] = 167] = "TULU_TIGALARI";
+    /** Sunuwar. Since: 2.84 */
     UnicodeScript[UnicodeScript["SUNUWAR"] = 168] = "SUNUWAR";
+    /** Gurung Khema. Since: 2.84 */
     UnicodeScript[UnicodeScript["GURUNG_KHEMA"] = 169] = "GURUNG_KHEMA";
+    /** Kirat Rai. Since: 2.84 */
     UnicodeScript[UnicodeScript["KIRAT_RAI"] = 170] = "KIRAT_RAI";
+    /** Ol Onal. Since: 2.84 */
     UnicodeScript[UnicodeScript["OL_ONAL"] = 171] = "OL_ONAL";
 })(UnicodeScript || (UnicodeScript = {}));
+/**
+ * These are the possible character classifications from the
+ * Unicode specification.
+ * See [Unicode Character Database](http://www.unicode.org/reports/tr44/#General_Category_Values).
+ */
 export var UnicodeType;
 (function (UnicodeType) {
+    /** General category "Other, Control" (Cc) */
     UnicodeType[UnicodeType["CONTROL"] = 0] = "CONTROL";
+    /** General category "Other, Format" (Cf) */
     UnicodeType[UnicodeType["FORMAT"] = 1] = "FORMAT";
+    /** General category "Other, Not Assigned" (Cn) */
     UnicodeType[UnicodeType["UNASSIGNED"] = 2] = "UNASSIGNED";
+    /** General category "Other, Private Use" (Co) */
     UnicodeType[UnicodeType["PRIVATE_USE"] = 3] = "PRIVATE_USE";
+    /** General category "Other, Surrogate" (Cs) */
     UnicodeType[UnicodeType["SURROGATE"] = 4] = "SURROGATE";
+    /** General category "Letter, Lowercase" (Ll) */
     UnicodeType[UnicodeType["LOWERCASE_LETTER"] = 5] = "LOWERCASE_LETTER";
+    /** General category "Letter, Modifier" (Lm) */
     UnicodeType[UnicodeType["MODIFIER_LETTER"] = 6] = "MODIFIER_LETTER";
+    /** General category "Letter, Other" (Lo) */
     UnicodeType[UnicodeType["OTHER_LETTER"] = 7] = "OTHER_LETTER";
+    /** General category "Letter, Titlecase" (Lt) */
     UnicodeType[UnicodeType["TITLECASE_LETTER"] = 8] = "TITLECASE_LETTER";
+    /** General category "Letter, Uppercase" (Lu) */
     UnicodeType[UnicodeType["UPPERCASE_LETTER"] = 9] = "UPPERCASE_LETTER";
+    /** General category "Mark, Spacing" (Mc) */
     UnicodeType[UnicodeType["SPACING_MARK"] = 10] = "SPACING_MARK";
+    /** General category "Mark, Enclosing" (Me) */
     UnicodeType[UnicodeType["ENCLOSING_MARK"] = 11] = "ENCLOSING_MARK";
+    /** General category "Mark, Nonspacing" (Mn) */
     UnicodeType[UnicodeType["NON_SPACING_MARK"] = 12] = "NON_SPACING_MARK";
+    /** General category "Number, Decimal Digit" (Nd) */
     UnicodeType[UnicodeType["DECIMAL_NUMBER"] = 13] = "DECIMAL_NUMBER";
+    /** General category "Number, Letter" (Nl) */
     UnicodeType[UnicodeType["LETTER_NUMBER"] = 14] = "LETTER_NUMBER";
+    /** General category "Number, Other" (No) */
     UnicodeType[UnicodeType["OTHER_NUMBER"] = 15] = "OTHER_NUMBER";
+    /** General category "Punctuation, Connector" (Pc) */
     UnicodeType[UnicodeType["CONNECT_PUNCTUATION"] = 16] = "CONNECT_PUNCTUATION";
+    /** General category "Punctuation, Dash" (Pd) */
     UnicodeType[UnicodeType["DASH_PUNCTUATION"] = 17] = "DASH_PUNCTUATION";
+    /** General category "Punctuation, Close" (Pe) */
     UnicodeType[UnicodeType["CLOSE_PUNCTUATION"] = 18] = "CLOSE_PUNCTUATION";
+    /** General category "Punctuation, Final quote" (Pf) */
     UnicodeType[UnicodeType["FINAL_PUNCTUATION"] = 19] = "FINAL_PUNCTUATION";
+    /** General category "Punctuation, Initial quote" (Pi) */
     UnicodeType[UnicodeType["INITIAL_PUNCTUATION"] = 20] = "INITIAL_PUNCTUATION";
+    /** General category "Punctuation, Other" (Po) */
     UnicodeType[UnicodeType["OTHER_PUNCTUATION"] = 21] = "OTHER_PUNCTUATION";
+    /** General category "Punctuation, Open" (Ps) */
     UnicodeType[UnicodeType["OPEN_PUNCTUATION"] = 22] = "OPEN_PUNCTUATION";
+    /** General category "Symbol, Currency" (Sc) */
     UnicodeType[UnicodeType["CURRENCY_SYMBOL"] = 23] = "CURRENCY_SYMBOL";
+    /** General category "Symbol, Modifier" (Sk) */
     UnicodeType[UnicodeType["MODIFIER_SYMBOL"] = 24] = "MODIFIER_SYMBOL";
+    /** General category "Symbol, Math" (Sm) */
     UnicodeType[UnicodeType["MATH_SYMBOL"] = 25] = "MATH_SYMBOL";
+    /** General category "Symbol, Other" (So) */
     UnicodeType[UnicodeType["OTHER_SYMBOL"] = 26] = "OTHER_SYMBOL";
+    /** General category "Separator, Line" (Zl) */
     UnicodeType[UnicodeType["LINE_SEPARATOR"] = 27] = "LINE_SEPARATOR";
+    /** General category "Separator, Paragraph" (Zp) */
     UnicodeType[UnicodeType["PARAGRAPH_SEPARATOR"] = 28] = "PARAGRAPH_SEPARATOR";
+    /** General category "Separator, Space" (Zs) */
     UnicodeType[UnicodeType["SPACE_SEPARATOR"] = 29] = "SPACE_SEPARATOR";
 })(UnicodeType || (UnicodeType = {}));
+/** Mnemonic constants for the ends of a Unix pipe. */
 export var UnixPipeEnd;
 (function (UnixPipeEnd) {
+    /** The readable file descriptor 0 */
     UnixPipeEnd[UnixPipeEnd["READ"] = 0] = "READ";
+    /** The writable file descriptor 1 */
     UnixPipeEnd[UnixPipeEnd["WRITE"] = 1] = "WRITE";
 })(UnixPipeEnd || (UnixPipeEnd = {}));
+/** Error codes returned by #GUri methods. */
 export var UriError;
 (function (UriError) {
+    /**
+     * Generic error if no more specific error is available.
+     * See the error message for details.
+     */
     UriError[UriError["FAILED"] = 0] = "FAILED";
+    /** The scheme of a URI could not be parsed. */
     UriError[UriError["BAD_SCHEME"] = 1] = "BAD_SCHEME";
+    /** The user/userinfo of a URI could not be parsed. */
     UriError[UriError["BAD_USER"] = 2] = "BAD_USER";
+    /** The password of a URI could not be parsed. */
     UriError[UriError["BAD_PASSWORD"] = 3] = "BAD_PASSWORD";
+    /** The authentication parameters of a URI could not be parsed. */
     UriError[UriError["BAD_AUTH_PARAMS"] = 4] = "BAD_AUTH_PARAMS";
+    /** The host of a URI could not be parsed. */
     UriError[UriError["BAD_HOST"] = 5] = "BAD_HOST";
+    /** The port of a URI could not be parsed. */
     UriError[UriError["BAD_PORT"] = 6] = "BAD_PORT";
+    /** The path of a URI could not be parsed. */
     UriError[UriError["BAD_PATH"] = 7] = "BAD_PATH";
+    /** The query of a URI could not be parsed. */
     UriError[UriError["BAD_QUERY"] = 8] = "BAD_QUERY";
+    /** The fragment of a URI could not be parsed. */
     UriError[UriError["BAD_FRAGMENT"] = 9] = "BAD_FRAGMENT";
 })(UriError || (UriError = {}));
+/**
+ * These are logical ids for special directories which are defined
+ * depending on the platform used. You should use g_get_user_special_dir()
+ * to retrieve the full path associated to the logical id.
+ *
+ * The #GUserDirectory enumeration can be extended at later date. Not
+ * every platform has a directory for every logical id in this
+ * enumeration.
+ */
 export var UserDirectory;
 (function (UserDirectory) {
+    /** the user's Desktop directory */
     UserDirectory[UserDirectory["DIRECTORY_DESKTOP"] = 0] = "DIRECTORY_DESKTOP";
+    /** the user's Documents directory */
     UserDirectory[UserDirectory["DIRECTORY_DOCUMENTS"] = 1] = "DIRECTORY_DOCUMENTS";
+    /** the user's Downloads directory */
     UserDirectory[UserDirectory["DIRECTORY_DOWNLOAD"] = 2] = "DIRECTORY_DOWNLOAD";
+    /** the user's Music directory */
     UserDirectory[UserDirectory["DIRECTORY_MUSIC"] = 3] = "DIRECTORY_MUSIC";
+    /** the user's Pictures directory */
     UserDirectory[UserDirectory["DIRECTORY_PICTURES"] = 4] = "DIRECTORY_PICTURES";
+    /** the user's shared directory */
     UserDirectory[UserDirectory["DIRECTORY_PUBLIC_SHARE"] = 5] = "DIRECTORY_PUBLIC_SHARE";
+    /** the user's Templates directory */
     UserDirectory[UserDirectory["DIRECTORY_TEMPLATES"] = 6] = "DIRECTORY_TEMPLATES";
+    /** the user's Movies directory */
     UserDirectory[UserDirectory["DIRECTORY_VIDEOS"] = 7] = "DIRECTORY_VIDEOS";
+    /** the number of enum values */
     UserDirectory[UserDirectory["N_DIRECTORIES"] = 8] = "N_DIRECTORIES";
 })(UserDirectory || (UserDirectory = {}));
+/** The range of possible top-level types of #GVariant instances. */
 export var VariantClass;
 (function (VariantClass) {
+    /** The #GVariant is a boolean. */
     VariantClass[VariantClass["BOOLEAN"] = 98] = "BOOLEAN";
+    /** The #GVariant is a byte. */
     VariantClass[VariantClass["BYTE"] = 121] = "BYTE";
+    /** The #GVariant is a signed 16 bit integer. */
     VariantClass[VariantClass["INT16"] = 110] = "INT16";
+    /** The #GVariant is an unsigned 16 bit integer. */
     VariantClass[VariantClass["UINT16"] = 113] = "UINT16";
+    /** The #GVariant is a signed 32 bit integer. */
     VariantClass[VariantClass["INT32"] = 105] = "INT32";
+    /** The #GVariant is an unsigned 32 bit integer. */
     VariantClass[VariantClass["UINT32"] = 117] = "UINT32";
+    /** The #GVariant is a signed 64 bit integer. */
     VariantClass[VariantClass["INT64"] = 120] = "INT64";
+    /** The #GVariant is an unsigned 64 bit integer. */
     VariantClass[VariantClass["UINT64"] = 116] = "UINT64";
+    /** The #GVariant is a file handle index. */
     VariantClass[VariantClass["HANDLE"] = 104] = "HANDLE";
+    /**
+     * The #GVariant is a double precision floating
+     * point value.
+     */
     VariantClass[VariantClass["DOUBLE"] = 100] = "DOUBLE";
+    /** The #GVariant is a normal string. */
     VariantClass[VariantClass["STRING"] = 115] = "STRING";
+    /**
+     * The #GVariant is a D-Bus object path
+     * string.
+     */
     VariantClass[VariantClass["OBJECT_PATH"] = 111] = "OBJECT_PATH";
+    /** The #GVariant is a D-Bus signature string. */
     VariantClass[VariantClass["SIGNATURE"] = 103] = "SIGNATURE";
+    /** The #GVariant is a variant. */
     VariantClass[VariantClass["VARIANT"] = 118] = "VARIANT";
+    /** The #GVariant is a maybe-typed value. */
     VariantClass[VariantClass["MAYBE"] = 109] = "MAYBE";
+    /** The #GVariant is an array. */
     VariantClass[VariantClass["ARRAY"] = 97] = "ARRAY";
+    /** The #GVariant is a tuple. */
     VariantClass[VariantClass["TUPLE"] = 40] = "TUPLE";
+    /** The #GVariant is a dictionary entry. */
     VariantClass[VariantClass["DICT_ENTRY"] = 123] = "DICT_ENTRY";
 })(VariantClass || (VariantClass = {}));
+/** Error codes returned by parsing text-format GVariants. */
 export var VariantParseError;
 (function (VariantParseError) {
+    /** generic error (unused) */
     VariantParseError[VariantParseError["FAILED"] = 0] = "FAILED";
+    /** a non-basic #GVariantType was given where a basic type was expected */
     VariantParseError[VariantParseError["BASIC_TYPE_EXPECTED"] = 1] = "BASIC_TYPE_EXPECTED";
+    /** cannot infer the #GVariantType */
     VariantParseError[VariantParseError["CANNOT_INFER_TYPE"] = 2] = "CANNOT_INFER_TYPE";
+    /** an indefinite #GVariantType was given where a definite type was expected */
     VariantParseError[VariantParseError["DEFINITE_TYPE_EXPECTED"] = 3] = "DEFINITE_TYPE_EXPECTED";
+    /** extra data after parsing finished */
     VariantParseError[VariantParseError["INPUT_NOT_AT_END"] = 4] = "INPUT_NOT_AT_END";
+    /** invalid character in number or unicode escape */
     VariantParseError[VariantParseError["INVALID_CHARACTER"] = 5] = "INVALID_CHARACTER";
+    /** not a valid #GVariant format string */
     VariantParseError[VariantParseError["INVALID_FORMAT_STRING"] = 6] = "INVALID_FORMAT_STRING";
+    /** not a valid object path */
     VariantParseError[VariantParseError["INVALID_OBJECT_PATH"] = 7] = "INVALID_OBJECT_PATH";
+    /** not a valid type signature */
     VariantParseError[VariantParseError["INVALID_SIGNATURE"] = 8] = "INVALID_SIGNATURE";
+    /** not a valid #GVariant type string */
     VariantParseError[VariantParseError["INVALID_TYPE_STRING"] = 9] = "INVALID_TYPE_STRING";
+    /** could not find a common type for array entries */
     VariantParseError[VariantParseError["NO_COMMON_TYPE"] = 10] = "NO_COMMON_TYPE";
+    /** the numerical value is out of range of the given type */
     VariantParseError[VariantParseError["NUMBER_OUT_OF_RANGE"] = 11] = "NUMBER_OUT_OF_RANGE";
+    /** the numerical value is out of range for any type */
     VariantParseError[VariantParseError["NUMBER_TOO_BIG"] = 12] = "NUMBER_TOO_BIG";
+    /** cannot parse as variant of the specified type */
     VariantParseError[VariantParseError["TYPE_ERROR"] = 13] = "TYPE_ERROR";
+    /** an unexpected token was encountered */
     VariantParseError[VariantParseError["UNEXPECTED_TOKEN"] = 14] = "UNEXPECTED_TOKEN";
+    /** an unknown keyword was encountered */
     VariantParseError[VariantParseError["UNKNOWN_KEYWORD"] = 15] = "UNKNOWN_KEYWORD";
+    /** unterminated string constant */
     VariantParseError[VariantParseError["UNTERMINATED_STRING_CONSTANT"] = 16] = "UNTERMINATED_STRING_CONSTANT";
+    /** no value given */
     VariantParseError[VariantParseError["VALUE_EXPECTED"] = 17] = "VALUE_EXPECTED";
+    /**
+     * variant was too deeply nested; #GVariant is only guaranteed to handle nesting up to 64 levels (Since: 2.64)
+     */
     VariantParseError[VariantParseError["RECURSION"] = 18] = "RECURSION";
 })(VariantParseError || (VariantParseError = {}));
 export var AsciiType;
@@ -720,216 +1775,882 @@ export var AsciiType;
     AsciiType[AsciiType["UPPER"] = 512] = "UPPER";
     AsciiType[AsciiType["XDIGIT"] = 1024] = "XDIGIT";
 })(AsciiType || (AsciiType = {}));
+/**
+ * Flags to pass to g_file_set_contents_full() to affect its safety and
+ * performance.
+ */
 export var FileSetContentsFlags;
 (function (FileSetContentsFlags) {
+    /**
+     * No guarantees about file consistency or durability.
+     * The most dangerous setting, which is slightly faster than other settings.
+     */
     FileSetContentsFlags[FileSetContentsFlags["NONE"] = 0] = "NONE";
+    /**
+     * 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 `fsync()`
+     * on the file and use of an atomic `rename()` of the new version of the file
+     * over the old.
+     */
     FileSetContentsFlags[FileSetContentsFlags["CONSISTENT"] = 1] = "CONSISTENT";
+    /**
+     * Guarantee file durability: after a crash, the
+     * new version of the file will be available. On Unix systems this equates to
+     * an `fsync()` on the file (if %G_FILE_SET_CONTENTS_CONSISTENT is unset), or
+     * the effects of %G_FILE_SET_CONTENTS_CONSISTENT plus an `fsync()` on the
+     * directory containing the file after calling `rename()`.
+     */
     FileSetContentsFlags[FileSetContentsFlags["DURABLE"] = 2] = "DURABLE";
+    /**
+     * 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.
+     */
     FileSetContentsFlags[FileSetContentsFlags["ONLY_EXISTING"] = 4] = "ONLY_EXISTING";
 })(FileSetContentsFlags || (FileSetContentsFlags = {}));
+/** A test to perform on a file using g_file_test(). */
 export var FileTest;
 (function (FileTest) {
+    /**
+     * %TRUE if the file is a regular file
+     * (not a directory). Note that this test will also return %TRUE
+     * if the tested file is a symlink to a regular file.
+     */
     FileTest[FileTest["IS_REGULAR"] = 1] = "IS_REGULAR";
+    /** %TRUE if the file is a symlink. */
     FileTest[FileTest["IS_SYMLINK"] = 2] = "IS_SYMLINK";
+    /** %TRUE if the file is a directory. */
     FileTest[FileTest["IS_DIR"] = 4] = "IS_DIR";
+    /** %TRUE if the file is executable. */
     FileTest[FileTest["IS_EXECUTABLE"] = 8] = "IS_EXECUTABLE";
+    /**
+     * %TRUE if the file exists. It may or may not
+     * be a regular file.
+     */
     FileTest[FileTest["EXISTS"] = 16] = "EXISTS";
 })(FileTest || (FileTest = {}));
+/** Flags to modify the format of the string returned by g_format_size_full(). */
 export var FormatSizeFlags;
 (function (FormatSizeFlags) {
+    /** behave the same as g_format_size() */
     FormatSizeFlags[FormatSizeFlags["DEFAULT"] = 0] = "DEFAULT";
+    /**
+     * include the exact number of bytes as part
+     * of the returned string.  For example, "45.6 kB (45,612 bytes)".
+     */
     FormatSizeFlags[FormatSizeFlags["LONG_FORMAT"] = 1] = "LONG_FORMAT";
+    /**
+     * 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.
+     */
     FormatSizeFlags[FormatSizeFlags["IEC_UNITS"] = 2] = "IEC_UNITS";
+    /**
+     * set the size as a quantity in bits, rather than
+     * bytes, and return units in bits. For example, ‘Mbit’ rather than ‘MB’.
+     */
     FormatSizeFlags[FormatSizeFlags["BITS"] = 4] = "BITS";
+    /**
+     * return only value, without unit; this should
+     * not be used together with `G_FORMAT_SIZE_LONG_FORMAT`     nor @G_FORMAT_SIZE_ONLY_UNIT. Since: 2.74
+     */
     FormatSizeFlags[FormatSizeFlags["ONLY_VALUE"] = 8] = "ONLY_VALUE";
+    /**
+     * return only unit, without value; this should
+     * not be used together with `G_FORMAT_SIZE_LONG_FORMAT`     nor @G_FORMAT_SIZE_ONLY_VALUE. Since: 2.74
+     */
     FormatSizeFlags[FormatSizeFlags["ONLY_UNIT"] = 16] = "ONLY_UNIT";
 })(FormatSizeFlags || (FormatSizeFlags = {}));
+/** Flags used internally in the #GHook implementation. */
 export var HookFlagMask;
 (function (HookFlagMask) {
+    /** set if the hook has not been destroyed */
     HookFlagMask[HookFlagMask["ACTIVE"] = 1] = "ACTIVE";
+    /** set if the hook is currently being run */
     HookFlagMask[HookFlagMask["IN_CALL"] = 2] = "IN_CALL";
+    /**
+     * A mask covering all bits reserved for
+     * hook flags; see %G_HOOK_FLAG_USER_SHIFT
+     */
     HookFlagMask[HookFlagMask["MASK"] = 15] = "MASK";
 })(HookFlagMask || (HookFlagMask = {}));
+/**
+ * A bitwise combination representing a condition to watch for on an
+ * event source.
+ */
 export var IOCondition;
 (function (IOCondition) {
+    /** There is data to read. */
     IOCondition[IOCondition["IN"] = 1] = "IN";
+    /** Data can be written (without blocking). */
     IOCondition[IOCondition["OUT"] = 4] = "OUT";
+    /** There is urgent data to read. */
     IOCondition[IOCondition["PRI"] = 2] = "PRI";
+    /** Error condition. */
     IOCondition[IOCondition["ERR"] = 8] = "ERR";
+    /**
+     * Hung up (the connection has been broken, usually for
+     * pipes and sockets).
+     */
     IOCondition[IOCondition["HUP"] = 16] = "HUP";
+    /** Invalid request. The file descriptor is not open. */
     IOCondition[IOCondition["NVAL"] = 32] = "NVAL";
 })(IOCondition || (IOCondition = {}));
+/**
+ * Specifies properties of a #GIOChannel. Some of the flags can only be
+ * read with g_io_channel_get_flags(), but not changed with
+ * g_io_channel_set_flags().
+ */
 export var IOFlags;
 (function (IOFlags) {
+    /** no special flags set. Since: 2.74 */
     IOFlags[IOFlags["NONE"] = 0] = "NONE";
+    /**
+     * turns on append mode, corresponds to %O_APPEND
+     * (see the documentation of the UNIX open() syscall)
+     */
     IOFlags[IOFlags["APPEND"] = 1] = "APPEND";
+    /**
+     * turns on nonblocking mode, corresponds to
+     * %O_NONBLOCK/%O_NDELAY (see the documentation of the UNIX open()
+     * syscall)
+     */
     IOFlags[IOFlags["NONBLOCK"] = 2] = "NONBLOCK";
+    /**
+     * indicates that the io channel is readable.
+     * This flag cannot be changed.
+     */
     IOFlags[IOFlags["IS_READABLE"] = 4] = "IS_READABLE";
+    /**
+     * indicates that the io channel is writable.
+     * This flag cannot be changed.
+     */
     IOFlags[IOFlags["IS_WRITABLE"] = 8] = "IS_WRITABLE";
+    /**
+     * a misspelled version of `G_IO_FLAG_IS_WRITABLE`     that existed before the spelling was fixed in GLib 2.30. It is kept
+     * here for compatibility reasons. Deprecated since 2.30
+     */
     IOFlags[IOFlags["IS_WRITEABLE"] = 8] = "IS_WRITEABLE";
+    /**
+     * indicates that the io channel is seekable,
+     * i.e. that g_io_channel_seek_position() can be used on it.
+     * This flag cannot be changed.
+     */
     IOFlags[IOFlags["IS_SEEKABLE"] = 16] = "IS_SEEKABLE";
+    /** the mask that specifies all the valid flags. */
     IOFlags[IOFlags["MASK"] = 31] = "MASK";
+    /**
+     * the mask of the flags that are returned from
+     * g_io_channel_get_flags()
+     */
     IOFlags[IOFlags["GET_MASK"] = 31] = "GET_MASK";
+    /**
+     * the mask of the flags that the user can modify
+     * with g_io_channel_set_flags()
+     */
     IOFlags[IOFlags["SET_MASK"] = 3] = "SET_MASK";
 })(IOFlags || (IOFlags = {}));
+/** Flags which influence the parsing. */
 export var KeyFileFlags;
 (function (KeyFileFlags) {
+    /** No flags, default behaviour */
     KeyFileFlags[KeyFileFlags["NONE"] = 0] = "NONE";
+    /**
+     * 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.
+     */
     KeyFileFlags[KeyFileFlags["KEEP_COMMENTS"] = 1] = "KEEP_COMMENTS";
+    /**
+     * 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.
+     */
     KeyFileFlags[KeyFileFlags["KEEP_TRANSLATIONS"] = 2] = "KEEP_TRANSLATIONS";
 })(KeyFileFlags || (KeyFileFlags = {}));
+/**
+ * Flags specifying the level of log messages.
+ *
+ * It is possible to change how GLib treats messages of the various
+ * levels using [func@GLib.log_set_handler] and [func@GLib.log_set_fatal_mask].
+ */
 export var LogLevelFlags;
 (function (LogLevelFlags) {
+    /** internal flag */
     LogLevelFlags[LogLevelFlags["FLAG_RECURSION"] = 1] = "FLAG_RECURSION";
+    /** internal flag */
     LogLevelFlags[LogLevelFlags["FLAG_FATAL"] = 2] = "FLAG_FATAL";
+    /**
+     * log level for errors, see [func@GLib.error].
+     * This level is also used for messages produced by [func@GLib.assert].
+     */
     LogLevelFlags[LogLevelFlags["LEVEL_ERROR"] = 4] = "LEVEL_ERROR";
+    /**
+     * log level for critical warning messages, see
+     * [func@GLib.critical]. This level is also used for messages produced by
+     * [func@GLib.return_if_fail] and [func@GLib.return_val_if_fail].
+     */
     LogLevelFlags[LogLevelFlags["LEVEL_CRITICAL"] = 8] = "LEVEL_CRITICAL";
+    /** log level for warnings, see [func@GLib.warning] */
     LogLevelFlags[LogLevelFlags["LEVEL_WARNING"] = 16] = "LEVEL_WARNING";
+    /** log level for messages, see [func@GLib.message] */
     LogLevelFlags[LogLevelFlags["LEVEL_MESSAGE"] = 32] = "LEVEL_MESSAGE";
+    /** log level for informational messages, see [func@GLib.info] */
     LogLevelFlags[LogLevelFlags["LEVEL_INFO"] = 64] = "LEVEL_INFO";
+    /** log level for debug messages, see [func@GLib.debug] */
     LogLevelFlags[LogLevelFlags["LEVEL_DEBUG"] = 128] = "LEVEL_DEBUG";
+    /** a mask including all log levels */
     LogLevelFlags[LogLevelFlags["LEVEL_MASK"] = -4] = "LEVEL_MASK";
 })(LogLevelFlags || (LogLevelFlags = {}));
+/**
+ * Flags to pass to [ctor@GLib.MainContext.new_with_flags] which affect the
+ * behaviour of a [struct@GLib.MainContext].
+ */
 export var MainContextFlags;
 (function (MainContextFlags) {
+    /** Default behaviour. */
     MainContextFlags[MainContextFlags["NONE"] = 0] = "NONE";
+    /**
+     * Assume that polling for events will
+     * free the thread to process other jobs. That's useful if you're using
+     * `g_main_context_{prepare,query,check,dispatch}` to integrate GMainContext in
+     * other event loops.
+     */
     MainContextFlags[MainContextFlags["OWNERLESS_POLLING"] = 1] = "OWNERLESS_POLLING";
 })(MainContextFlags || (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 %G_MARKUP_COLLECT_OPTIONAL.
+ *
+ * It is likely that this enum will be extended in the future to
+ * support other types.
+ */
 export var MarkupCollectType;
 (function (MarkupCollectType) {
+    /**
+     * used to terminate the list of attributes
+     * to collect
+     */
     MarkupCollectType[MarkupCollectType["INVALID"] = 0] = "INVALID";
+    /**
+     * collect the string pointer directly from
+     * the attribute_values[] array. Expects a parameter of type (const
+     * char **). If %G_MARKUP_COLLECT_OPTIONAL is specified and the
+     * attribute isn't present then the pointer will be set to %NULL
+     */
     MarkupCollectType[MarkupCollectType["STRING"] = 1] = "STRING";
+    /**
+     * as with %G_MARKUP_COLLECT_STRING, but
+     * expects a parameter of type (char **) and g_strdup()s the
+     * returned pointer. The pointer must be freed with g_free()
+     */
     MarkupCollectType[MarkupCollectType["STRDUP"] = 2] = "STRDUP";
+    /**
+     * expects a parameter of type (`gboolean *`)
+     * and parses the attribute value as a boolean. Sets %FALSE if the
+     * attribute isn't present. Valid boolean values consist of
+     * (case-insensitive) "false", "f", "no", "n", "0" and "true", "t",
+     * "yes", "y", "1"
+     */
     MarkupCollectType[MarkupCollectType["BOOLEAN"] = 3] = "BOOLEAN";
+    /**
+     * as with %G_MARKUP_COLLECT_BOOLEAN, but
+     * in the case of a missing attribute a value is set that compares
+     * equal to neither %FALSE nor %TRUE %G_MARKUP_COLLECT_OPTIONAL is
+     * implied
+     */
     MarkupCollectType[MarkupCollectType["TRISTATE"] = 4] = "TRISTATE";
+    /**
+     * 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
+     */
     MarkupCollectType[MarkupCollectType["OPTIONAL"] = 65536] = "OPTIONAL";
 })(MarkupCollectType || (MarkupCollectType = {}));
+/** Flags that affect the behaviour of the parser. */
 export var MarkupParseFlags;
 (function (MarkupParseFlags) {
+    /** No special behaviour. Since: 2.74 */
     MarkupParseFlags[MarkupParseFlags["DEFAULT_FLAGS"] = 0] = "DEFAULT_FLAGS";
+    /** flag you should not use */
     MarkupParseFlags[MarkupParseFlags["DO_NOT_USE_THIS_UNSUPPORTED_FLAG"] = 1] = "DO_NOT_USE_THIS_UNSUPPORTED_FLAG";
+    /**
+     * When this flag is set, CDATA marked
+     * sections are not passed literally to the `passthrough` function of
+     * the parser. Instead, the content of the section (without the
+     * `<![CDATA[` and `]]>`) is
+     * passed to the `text` function. This flag was added in GLib 2.12
+     */
     MarkupParseFlags[MarkupParseFlags["TREAT_CDATA_AS_TEXT"] = 2] = "TREAT_CDATA_AS_TEXT";
+    /**
+     * 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
+     * #GMarkupParser implementation functions
+     */
     MarkupParseFlags[MarkupParseFlags["PREFIX_ERROR_POSITION"] = 4] = "PREFIX_ERROR_POSITION";
+    /**
+     * 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.
+     */
     MarkupParseFlags[MarkupParseFlags["IGNORE_QUALIFIED"] = 8] = "IGNORE_QUALIFIED";
 })(MarkupParseFlags || (MarkupParseFlags = {}));
+/** Flags which modify individual options. */
 export var OptionFlags;
 (function (OptionFlags) {
+    /** No flags. */
     OptionFlags[OptionFlags["NONE"] = 0] = "NONE";
+    /** The option doesn't appear in `--help` output. */
     OptionFlags[OptionFlags["HIDDEN"] = 1] = "HIDDEN";
+    /**
+     * The option appears in the main section of the
+     * `--help` output, even if it is defined in a group.
+     */
     OptionFlags[OptionFlags["IN_MAIN"] = 2] = "IN_MAIN";
+    /**
+     * For options of the %G_OPTION_ARG_NONE kind, this
+     * flag indicates that the sense of the option is reversed. i.e. %FALSE will
+     * be stored into the argument rather than %TRUE.
+     */
     OptionFlags[OptionFlags["REVERSE"] = 4] = "REVERSE";
+    /**
+     * For options of the %G_OPTION_ARG_CALLBACK kind,
+     * this flag indicates that the callback does not take any argument
+     * (like a %G_OPTION_ARG_NONE option). Since 2.8
+     */
     OptionFlags[OptionFlags["NO_ARG"] = 8] = "NO_ARG";
+    /**
+     * For options of the %G_OPTION_ARG_CALLBACK
+     * 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
+     */
     OptionFlags[OptionFlags["FILENAME"] = 16] = "FILENAME";
+    /**
+     * For options of the %G_OPTION_ARG_CALLBACK
+     * kind, this flag indicates that the argument supply is optional.
+     * If no argument is given then data of %GOptionParseFunc will be
+     * set to NULL. Since 2.8
+     */
     OptionFlags[OptionFlags["OPTIONAL_ARG"] = 32] = "OPTIONAL_ARG";
+    /**
+     * This flag turns off the automatic conflict
+     * resolution which prefixes long option names with `groupname-` 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.
+     */
     OptionFlags[OptionFlags["NOALIAS"] = 64] = "NOALIAS";
+    /**
+     * This flag marks the option as deprecated in the `--help`.
+     *
+     * 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.
+     */
     OptionFlags[OptionFlags["DEPRECATED"] = 128] = "DEPRECATED";
 })(OptionFlags || (OptionFlags = {}));
+/** Flags specifying compile-time options. */
 export var RegexCompileFlags;
 (function (RegexCompileFlags) {
+    /** No special options set. Since: 2.74 */
     RegexCompileFlags[RegexCompileFlags["DEFAULT"] = 0] = "DEFAULT";
+    /**
+     * Letters in the pattern match both upper- and
+     * lowercase letters. This option can be changed within a pattern
+     * by a "(?i)" option setting.
+     */
     RegexCompileFlags[RegexCompileFlags["CASELESS"] = 1] = "CASELESS";
+    /**
+     * 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 %G_REGEX_DOLLAR_ENDONLY is set). When
+     * %G_REGEX_MULTILINE 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.
+     */
     RegexCompileFlags[RegexCompileFlags["MULTILINE"] = 2] = "MULTILINE";
+    /**
+     * 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.
+     */
     RegexCompileFlags[RegexCompileFlags["DOTALL"] = 4] = "DOTALL";
+    /**
+     * 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.
+     */
     RegexCompileFlags[RegexCompileFlags["EXTENDED"] = 8] = "EXTENDED";
+    /**
+     * 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.
+     */
     RegexCompileFlags[RegexCompileFlags["ANCHORED"] = 16] = "ANCHORED";
+    /**
+     * 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 %G_REGEX_MULTILINE is set.
+     */
     RegexCompileFlags[RegexCompileFlags["DOLLAR_ENDONLY"] = 32] = "DOLLAR_ENDONLY";
+    /**
+     * 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.
+     */
     RegexCompileFlags[RegexCompileFlags["UNGREEDY"] = 512] = "UNGREEDY";
+    /**
+     * Usually strings must be valid UTF-8 strings, using this
+     * flag they are considered as a raw sequence of bytes.
+     */
     RegexCompileFlags[RegexCompileFlags["RAW"] = 2048] = "RAW";
+    /**
+     * 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).
+     */
     RegexCompileFlags[RegexCompileFlags["NO_AUTO_CAPTURE"] = 4096] = "NO_AUTO_CAPTURE";
+    /**
+     * 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.
+     */
     RegexCompileFlags[RegexCompileFlags["OPTIMIZE"] = 8192] = "OPTIMIZE";
+    /**
+     * Limits an unanchored pattern to match before (or at) the
+     * first newline. Since: 2.34
+     */
     RegexCompileFlags[RegexCompileFlags["FIRSTLINE"] = 262144] = "FIRSTLINE";
+    /**
+     * 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.
+     */
     RegexCompileFlags[RegexCompileFlags["DUPNAMES"] = 524288] = "DUPNAMES";
+    /**
+     * Usually any newline character or character sequence is
+     * recognized. If this option is set, the only recognized newline character
+     * is '\r'.
+     */
     RegexCompileFlags[RegexCompileFlags["NEWLINE_CR"] = 1048576] = "NEWLINE_CR";
+    /**
+     * Usually any newline character or character sequence is
+     * recognized. If this option is set, the only recognized newline character
+     * is '\n'.
+     */
     RegexCompileFlags[RegexCompileFlags["NEWLINE_LF"] = 2097152] = "NEWLINE_LF";
+    /**
+     * Usually any newline character or character sequence is
+     * recognized. If this option is set, the only recognized newline character
+     * sequence is '\r\n'.
+     */
     RegexCompileFlags[RegexCompileFlags["NEWLINE_CRLF"] = 3145728] = "NEWLINE_CRLF";
+    /**
+     * Usually any newline character or character sequence
+     * is recognized. If this option is set, the only recognized newline character
+     * sequences are '\r', '\n', and '\r\n'. Since: 2.34
+     */
     RegexCompileFlags[RegexCompileFlags["NEWLINE_ANYCRLF"] = 5242880] = "NEWLINE_ANYCRLF";
+    /**
+     * Usually any newline character or character sequence
+     * is recognised. If this option is set, then "\R" only recognizes the newline
+     * characters '\r', '\n' and '\r\n'. Since: 2.34
+     */
     RegexCompileFlags[RegexCompileFlags["BSR_ANYCRLF"] = 8388608] = "BSR_ANYCRLF";
+    /**
+     * Changes behaviour so that it is compatible with
+     * JavaScript rather than PCRE. Since GLib 2.74 this is no longer supported,
+     * as libpcre2 does not support it. Since: 2.34 Deprecated: 2.74
+     */
     RegexCompileFlags[RegexCompileFlags["JAVASCRIPT_COMPAT"] = 33554432] = "JAVASCRIPT_COMPAT";
 })(RegexCompileFlags || (RegexCompileFlags = {}));
+/** Flags specifying match-time options. */
 export var RegexMatchFlags;
 (function (RegexMatchFlags) {
+    /** No special options set. Since: 2.74 */
     RegexMatchFlags[RegexMatchFlags["DEFAULT"] = 0] = "DEFAULT";
+    /**
+     * 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.
+     */
     RegexMatchFlags[RegexMatchFlags["ANCHORED"] = 16] = "ANCHORED";
+    /**
+     * 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 %G_REGEX_MULTILINE (at
+     * compile time) causes circumflex never to match. This option affects
+     * only the behaviour of the circumflex metacharacter, it does not
+     * affect "\A".
+     */
     RegexMatchFlags[RegexMatchFlags["NOTBOL"] = 128] = "NOTBOL";
+    /**
+     * 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 %G_REGEX_MULTILINE (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".
+     */
     RegexMatchFlags[RegexMatchFlags["NOTEOL"] = 256] = "NOTEOL";
+    /**
+     * 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".
+     */
     RegexMatchFlags[RegexMatchFlags["NOTEMPTY"] = 1024] = "NOTEMPTY";
+    /**
+     * Turns on the partial matching feature, for more
+     * documentation on partial matching see g_match_info_is_partial_match().
+     */
     RegexMatchFlags[RegexMatchFlags["PARTIAL"] = 32768] = "PARTIAL";
+    /**
+     * Overrides the newline definition set when
+     * creating a new #GRegex, setting the '\r' character as line terminator.
+     */
     RegexMatchFlags[RegexMatchFlags["NEWLINE_CR"] = 1048576] = "NEWLINE_CR";
+    /**
+     * Overrides the newline definition set when
+     * creating a new #GRegex, setting the '\n' character as line terminator.
+     */
     RegexMatchFlags[RegexMatchFlags["NEWLINE_LF"] = 2097152] = "NEWLINE_LF";
+    /**
+     * Overrides the newline definition set when
+     * creating a new #GRegex, setting the '\r\n' characters sequence as line terminator.
+     */
     RegexMatchFlags[RegexMatchFlags["NEWLINE_CRLF"] = 3145728] = "NEWLINE_CRLF";
+    /**
+     * Overrides the newline definition set when
+     * creating a new #GRegex, 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.
+     */
     RegexMatchFlags[RegexMatchFlags["NEWLINE_ANY"] = 4194304] = "NEWLINE_ANY";
+    /**
+     * Overrides the newline definition set when
+     * creating a new #GRegex; any '\r', '\n', or '\r\n' character sequence
+     * is recognized as a newline. Since: 2.34
+     */
     RegexMatchFlags[RegexMatchFlags["NEWLINE_ANYCRLF"] = 5242880] = "NEWLINE_ANYCRLF";
+    /**
+     * Overrides the newline definition for "\R" set when
+     * creating a new #GRegex; only '\r', '\n', or '\r\n' character sequences
+     * are recognized as a newline by "\R". Since: 2.34
+     */
     RegexMatchFlags[RegexMatchFlags["BSR_ANYCRLF"] = 8388608] = "BSR_ANYCRLF";
+    /**
+     * Overrides the newline definition for "\R" set when
+     * creating a new #GRegex; 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
+     */
     RegexMatchFlags[RegexMatchFlags["BSR_ANY"] = 16777216] = "BSR_ANY";
+    /** An alias for %G_REGEX_MATCH_PARTIAL. Since: 2.34 */
     RegexMatchFlags[RegexMatchFlags["PARTIAL_SOFT"] = 32768] = "PARTIAL_SOFT";
+    /**
+     * Turns on the partial matching feature. In contrast to
+     * to %G_REGEX_MATCH_PARTIAL_SOFT, this stops matching as soon as a partial match
+     * is found, without continuing to search for a possible complete match. See
+     * g_match_info_is_partial_match() for more information. Since: 2.34
+     */
     RegexMatchFlags[RegexMatchFlags["PARTIAL_HARD"] = 134217728] = "PARTIAL_HARD";
+    /**
+     * Like %G_REGEX_MATCH_NOTEMPTY, but only applied to
+     * the start of the matched string. For anchored
+     * patterns this can only happen for pattern containing "\K". Since: 2.34
+     */
     RegexMatchFlags[RegexMatchFlags["NOTEMPTY_ATSTART"] = 268435456] = "NOTEMPTY_ATSTART";
 })(RegexMatchFlags || (RegexMatchFlags = {}));
+/** Flags passed to g_spawn_sync(), g_spawn_async() and g_spawn_async_with_pipes(). */
 export var SpawnFlags;
 (function (SpawnFlags) {
+    /** no flags, default behaviour */
     SpawnFlags[SpawnFlags["DEFAULT"] = 0] = "DEFAULT";
+    /**
+     * 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 exec() in the child.
+     */
     SpawnFlags[SpawnFlags["LEAVE_DESCRIPTORS_OPEN"] = 1] = "LEAVE_DESCRIPTORS_OPEN";
+    /**
+     * the child will not be automatically reaped;
+     * you must use g_child_watch_add() yourself (or call waitpid() or handle
+     * `SIGCHLD` yourself), or the child will become a zombie.
+     */
     SpawnFlags[SpawnFlags["DO_NOT_REAP_CHILD"] = 2] = "DO_NOT_REAP_CHILD";
+    /**
+     * `argv[0]` need not be an absolute path, it will be
+     * looked for in the user's `PATH`.
+     */
     SpawnFlags[SpawnFlags["SEARCH_PATH"] = 4] = "SEARCH_PATH";
+    /**
+     * the child's standard output will be discarded,
+     * instead of going to the same location as the parent's standard output.
+     */
     SpawnFlags[SpawnFlags["STDOUT_TO_DEV_NULL"] = 8] = "STDOUT_TO_DEV_NULL";
+    /** the child's standard error will be discarded. */
     SpawnFlags[SpawnFlags["STDERR_TO_DEV_NULL"] = 16] = "STDERR_TO_DEV_NULL";
+    /**
+     * the child will inherit the parent's standard
+     * input (by default, the child's standard input is attached to `/dev/null`).
+     */
     SpawnFlags[SpawnFlags["CHILD_INHERITS_STDIN"] = 32] = "CHILD_INHERITS_STDIN";
+    /**
+     * the first element of `argv` is the file to
+     * execute, while the remaining elements are the actual argument vector
+     * to pass to the file. Normally g_spawn_async_with_pipes() uses `argv[0]`
+     * as the file to execute, and passes all of `argv` to the child.
+     */
     SpawnFlags[SpawnFlags["FILE_AND_ARGV_ZERO"] = 64] = "FILE_AND_ARGV_ZERO";
+    /**
+     * if `argv[0]` is not an absolute path,
+     * it will be looked for in the `PATH` from the passed child environment.
+     * Since: 2.34
+     */
     SpawnFlags[SpawnFlags["SEARCH_PATH_FROM_ENVP"] = 128] = "SEARCH_PATH_FROM_ENVP";
+    /**
+     * create all pipes with the `O_CLOEXEC` flag set.
+     * Since: 2.40
+     */
     SpawnFlags[SpawnFlags["CLOEXEC_PIPES"] = 256] = "CLOEXEC_PIPES";
+    /** The child will inherit the parent's standard output. */
     SpawnFlags[SpawnFlags["CHILD_INHERITS_STDOUT"] = 512] = "CHILD_INHERITS_STDOUT";
+    /** The child will inherit the parent's standard error. */
     SpawnFlags[SpawnFlags["CHILD_INHERITS_STDERR"] = 1024] = "CHILD_INHERITS_STDERR";
+    /** The child's standard input is attached to `/dev/null`. */
     SpawnFlags[SpawnFlags["STDIN_FROM_DEV_NULL"] = 2048] = "STDIN_FROM_DEV_NULL";
 })(SpawnFlags || (SpawnFlags = {}));
+/**
+ * Flags to pass to [func@GLib.test_trap_subprocess] to control input and output.
+ *
+ * Note that in contrast with [func@GLib.test_trap_fork], the default
+ * behavior of [func@GLib.test_trap_subprocess] is to not show stdout
+ * and stderr.
+ */
 export var TestSubprocessFlags;
 (function (TestSubprocessFlags) {
+    /** Default behaviour. Since: 2.74 */
     TestSubprocessFlags[TestSubprocessFlags["DEFAULT"] = 0] = "DEFAULT";
+    /**
+     * If this flag is given, the child
+     * process will inherit the parent's stdin. Otherwise, the child's
+     * stdin is redirected to `/dev/null`.
+     */
     TestSubprocessFlags[TestSubprocessFlags["INHERIT_STDIN"] = 1] = "INHERIT_STDIN";
+    /**
+     * 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 [func@GLib.test_trap_assert_stdout].
+     */
     TestSubprocessFlags[TestSubprocessFlags["INHERIT_STDOUT"] = 2] = "INHERIT_STDOUT";
+    /**
+     * 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 [func@GLib.test_trap_assert_stderr].
+     */
     TestSubprocessFlags[TestSubprocessFlags["INHERIT_STDERR"] = 4] = "INHERIT_STDERR";
 })(TestSubprocessFlags || (TestSubprocessFlags = {}));
+/**
+ * Flags to pass to [func@GLib.test_trap_fork] to control input and output.
+ *
+ * Test traps are guards around forked tests. These flags determine what traps to set.
+ */
 export var TestTrapFlags;
 (function (TestTrapFlags) {
+    /** Default behaviour. Since: 2.74 */
     TestTrapFlags[TestTrapFlags["DEFAULT"] = 0] = "DEFAULT";
+    /**
+     * Redirect stdout of the test child to
+     * `/dev/null` so it cannot be observed on the console during test
+     * runs. The actual output is still captured though to allow later
+     * tests with g_test_trap_assert_stdout().
+     */
     TestTrapFlags[TestTrapFlags["SILENCE_STDOUT"] = 128] = "SILENCE_STDOUT";
+    /**
+     * Redirect stderr of the test child to
+     * `/dev/null` so it cannot be observed on the console during test
+     * runs. The actual output is still captured though to allow later
+     * tests with g_test_trap_assert_stderr().
+     */
     TestTrapFlags[TestTrapFlags["SILENCE_STDERR"] = 256] = "SILENCE_STDERR";
+    /**
+     * If this flag is given, stdin of the
+     * child process is shared with stdin of its parent process.
+     * It is redirected to `/dev/null` otherwise.
+     */
     TestTrapFlags[TestTrapFlags["INHERIT_STDIN"] = 512] = "INHERIT_STDIN";
 })(TestTrapFlags || (TestTrapFlags = {}));
+/**
+ * Specifies which nodes are visited during several of the tree
+ * functions, including g_node_traverse() and g_node_find().
+ */
 export var TraverseFlags;
 (function (TraverseFlags) {
+    /**
+     * only leaf nodes should be visited. This name has
+     * been introduced in 2.6, for older version use
+     * %G_TRAVERSE_LEAFS.
+     */
     TraverseFlags[TraverseFlags["LEAVES"] = 1] = "LEAVES";
+    /**
+     * only non-leaf nodes should be visited. This
+     * name has been introduced in 2.6, for older
+     * version use %G_TRAVERSE_NON_LEAFS.
+     */
     TraverseFlags[TraverseFlags["NON_LEAVES"] = 2] = "NON_LEAVES";
+    /** all nodes should be visited. */
     TraverseFlags[TraverseFlags["ALL"] = 3] = "ALL";
+    /** a mask of all traverse flags. */
     TraverseFlags[TraverseFlags["MASK"] = 3] = "MASK";
+    /** identical to %G_TRAVERSE_LEAVES. */
     TraverseFlags[TraverseFlags["LEAFS"] = 1] = "LEAFS";
+    /** identical to %G_TRAVERSE_NON_LEAVES. */
     TraverseFlags[TraverseFlags["NON_LEAFS"] = 2] = "NON_LEAFS";
 })(TraverseFlags || (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 g_uri_peek_scheme() on the URI string
+ * to check the scheme first, and use that to decide what flags to
+ * parse it with.
+ */
 export var UriFlags;
 (function (UriFlags) {
+    /** No flags set. */
     UriFlags[UriFlags["NONE"] = 0] = "NONE";
+    /**
+     * Parse the URI more relaxedly than the
+     * [RFC 3986](https://tools.ietf.org/html/rfc3986) grammar specifies,
+     * fixing up or ignoring common mistakes in URIs coming from external
+     * sources. This is also needed for some obscure URI schemes where `;`
+     * separates the host from the path. Don’t use this flag unless you need to.
+     */
     UriFlags[UriFlags["PARSE_RELAXED"] = 1] = "PARSE_RELAXED";
+    /**
+     * The userinfo field may contain a password,
+     * which will be separated from the username by `:`.
+     */
     UriFlags[UriFlags["HAS_PASSWORD"] = 2] = "HAS_PASSWORD";
+    /**
+     * The userinfo may contain additional
+     * authentication-related parameters, which will be separated from
+     * the username and/or password by `;`.
+     */
     UriFlags[UriFlags["HAS_AUTH_PARAMS"] = 4] = "HAS_AUTH_PARAMS";
+    /**
+     * When parsing a URI, this indicates that `%`-encoded
+     * characters in the userinfo, path, query, and fragment fields
+     * should not be decoded. (And likewise the host field if
+     * %G_URI_FLAGS_NON_DNS is also set.) When building a URI, it indicates
+     * that you have already `%`-encoded the components, and so #GUri
+     * should not do any encoding itself.
+     */
     UriFlags[UriFlags["ENCODED"] = 8] = "ENCODED";
+    /**
+     * The host component should not be assumed to be a
+     * DNS hostname or IP address (for example, for `smb` URIs with NetBIOS
+     * hostnames).
+     */
     UriFlags[UriFlags["NON_DNS"] = 16] = "NON_DNS";
+    /**
+     * Same as %G_URI_FLAGS_ENCODED, for the query
+     * field only.
+     */
     UriFlags[UriFlags["ENCODED_QUERY"] = 32] = "ENCODED_QUERY";
+    /** Same as %G_URI_FLAGS_ENCODED, for the path only. */
     UriFlags[UriFlags["ENCODED_PATH"] = 64] = "ENCODED_PATH";
+    /**
+     * Same as %G_URI_FLAGS_ENCODED, for the
+     * fragment only.
+     */
     UriFlags[UriFlags["ENCODED_FRAGMENT"] = 128] = "ENCODED_FRAGMENT";
+    /**
+     * A scheme-based normalization will be applied.
+     * For example, when parsing an HTTP URI changing omitted path to `/` and
+     * omitted port to `80`; and when building a URI, changing empty path to `/`
+     * and default port `80`). This only supports a subset of known schemes. (Since: 2.68)
+     */
     UriFlags[UriFlags["SCHEME_NORMALIZE"] = 256] = "SCHEME_NORMALIZE";
 })(UriFlags || (UriFlags = {}));
+/**
+ * Flags describing what parts of the URI to hide in
+ * g_uri_to_string_partial(). Note that %G_URI_HIDE_PASSWORD and
+ * %G_URI_HIDE_AUTH_PARAMS will only work if the #GUri was parsed with
+ * the corresponding flags.
+ */
 export var UriHideFlags;
 (function (UriHideFlags) {
+    /** No flags set. */
     UriHideFlags[UriHideFlags["NONE"] = 0] = "NONE";
+    /** Hide the userinfo. */
     UriHideFlags[UriHideFlags["USERINFO"] = 1] = "USERINFO";
+    /** Hide the password. */
     UriHideFlags[UriHideFlags["PASSWORD"] = 2] = "PASSWORD";
+    /** Hide the auth_params. */
     UriHideFlags[UriHideFlags["AUTH_PARAMS"] = 4] = "AUTH_PARAMS";
+    /** Hide the query. */
     UriHideFlags[UriHideFlags["QUERY"] = 8] = "QUERY";
+    /** Hide the fragment. */
     UriHideFlags[UriHideFlags["FRAGMENT"] = 16] = "FRAGMENT";
 })(UriHideFlags || (UriHideFlags = {}));
+/**
+ * Flags modifying the way parameters are handled by g_uri_parse_params() and
+ * #GUriParamsIter.
+ */
 export var UriParamsFlags;
 (function (UriParamsFlags) {
+    /** No flags set. */
     UriParamsFlags[UriParamsFlags["NONE"] = 0] = "NONE";
+    /** Parameter names are case insensitive. */
     UriParamsFlags[UriParamsFlags["CASE_INSENSITIVE"] = 1] = "CASE_INSENSITIVE";
+    /**
+     * Replace `+` with space character. Only useful for
+     * URLs on the web, using the `https` or `http` schemas.
+     */
     UriParamsFlags[UriParamsFlags["WWW_FORM"] = 2] = "WWW_FORM";
+    /** See %G_URI_FLAGS_PARSE_RELAXED. */
     UriParamsFlags[UriParamsFlags["PARSE_RELAXED"] = 4] = "PARSE_RELAXED";
 })(UriParamsFlags || (UriParamsFlags = {}));