@gtkx/ffi 0.10.5 → 0.11.0

package/dist/generated/glib/enums.js

@@ -7,7 +7,7 @@ export var BookmarkFileError;
     BookmarkFileError[BookmarkFileError["INVALID_VALUE"] = 1] = "INVALID_VALUE";
     /**
      * a requested application did
-     * not register a bookmark
+     *     not register a bookmark
      */
     BookmarkFileError[BookmarkFileError["APP_NOT_REGISTERED"] = 2] = "APP_NOT_REGISTERED";
     /** a requested URI was not found */
@@ -16,7 +16,7 @@ export var BookmarkFileError;
     BookmarkFileError[BookmarkFileError["READ"] = 4] = "READ";
     /**
      * the text being parsed was
-     * in an unknown encoding
+     *     in an unknown encoding
      */
     BookmarkFileError[BookmarkFileError["UNKNOWN_ENCODING"] = 5] = "UNKNOWN_ENCODING";
     /** an error occurred while writing */
@@ -49,13 +49,13 @@ export var ConvertError;
 (function (ConvertError) {
     /**
      * Conversion between the requested character
-     * sets is not supported.
+     *     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.
+     *    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. */
@@ -70,8 +70,8 @@ export var ConvertError;
     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
+     *     conversion output where a NUL-terminated string is expected.
+     *     Since: 2.56
      */
     ConvertError[ConvertError["EMBEDDED_NUL"] = 7] = "EMBEDDED_NUL";
 })(ConvertError || (ConvertError = {}));
@@ -185,140 +185,140 @@ 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.
+     *     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.
+     *     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.
+     *     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.
+     *     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.
+     *     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.
+     *     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.
+     *     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.
+     *     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.)
+     *     (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.
+     *     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.
+     *     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.
+     *     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.
+     *     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.
+     *     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).
+     *     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.
+     *     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'.
+     *     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.
+     *     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.
+     *     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.
+     *    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.
+     *    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.
+     *    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.
+     *    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 = {}));
@@ -376,7 +376,7 @@ export var KeyFileError;
 (function (KeyFileError) {
     /**
      * the text being parsed was in
-     * an unknown encoding
+     *   an unknown encoding
      */
     KeyFileError[KeyFileError["UNKNOWN_ENCODING"] = 0] = "UNKNOWN_ENCODING";
     /** document was ill-formed */
@@ -416,22 +416,22 @@ export var MarkupError;
     MarkupError[MarkupError["PARSE"] = 2] = "PARSE";
     /**
      * error should be set by #GMarkupParser
-     * functions; element wasn't known
+     *     functions; element wasn't known
      */
     MarkupError[MarkupError["UNKNOWN_ELEMENT"] = 3] = "UNKNOWN_ELEMENT";
     /**
      * error should be set by #GMarkupParser
-     * functions; attribute wasn't known
+     *     functions; attribute wasn't known
      */
     MarkupError[MarkupError["UNKNOWN_ATTRIBUTE"] = 4] = "UNKNOWN_ATTRIBUTE";
     /**
      * error should be set by #GMarkupParser
-     * functions; content was invalid
+     *     functions; content was invalid
      */
     MarkupError[MarkupError["INVALID_CONTENT"] = 5] = "INVALID_CONTENT";
     /**
      * error should be set by #GMarkupParser
-     * functions; a required attribute was missing
+     *     functions; a required attribute was missing
      */
     MarkupError[MarkupError["MISSING_ATTRIBUTE"] = 6] = "MISSING_ATTRIBUTE";
 })(MarkupError || (MarkupError = {}));
@@ -446,31 +446,31 @@ export var NormalizeMode;
 (function (NormalizeMode) {
     /**
      * standardize differences that do not affect the
-     * text content, such as the above-mentioned accent representation
+     *     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
+     *     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
+     *     "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
+     *     forms rather than a maximally decomposed form
      */
     NormalizeMode[NormalizeMode["ALL_COMPOSE"] = 3] = "ALL_COMPOSE";
     /** another name for %G_NORMALIZE_ALL_COMPOSE */
@@ -513,35 +513,35 @@ export var OptionArg;
     OptionArg[OptionArg["INT"] = 2] = "INT";
     /**
      * The option provides a callback (of type #GOptionArgFunc)
-     * to parse the extra argument.
+     *   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.
+     *      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.
+     *   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.
+     *   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
+     *   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
+     *   %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 = {}));
@@ -550,8 +550,8 @@ 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().
+     *  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. */
@@ -568,14 +568,14 @@ export var RegexError;
     RegexError[RegexError["OPTIMIZE"] = 1] = "OPTIMIZE";
     /**
      * Replacement failed due to an ill-formed replacement
-     * string.
+     *     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
+     *     Since 2.16
      */
     RegexError[RegexError["INTERNAL"] = 4] = "INTERNAL";
     /** "\\" at end of pattern. Since 2.16 */
@@ -584,180 +584,180 @@ export var RegexError;
     RegexError[RegexError["MISSING_CONTROL_CHAR"] = 102] = "MISSING_CONTROL_CHAR";
     /**
      * Unrecognized character follows "\\".
-     * Since 2.16
+     *     Since 2.16
      */
     RegexError[RegexError["UNRECOGNIZED_ESCAPE"] = 103] = "UNRECOGNIZED_ESCAPE";
     /**
      * Numbers out of order in "{}"
-     * quantifier. Since 2.16
+     *     quantifier. Since 2.16
      */
     RegexError[RegexError["QUANTIFIERS_OUT_OF_ORDER"] = 104] = "QUANTIFIERS_OUT_OF_ORDER";
     /**
      * Number too big in "{}" quantifier.
-     * Since 2.16
+     *     Since 2.16
      */
     RegexError[RegexError["QUANTIFIER_TOO_BIG"] = 105] = "QUANTIFIER_TOO_BIG";
     /**
      * Missing terminating "]" for
-     * character class. Since 2.16
+     *     character class. Since 2.16
      */
     RegexError[RegexError["UNTERMINATED_CHARACTER_CLASS"] = 106] = "UNTERMINATED_CHARACTER_CLASS";
     /**
      * Invalid escape sequence
-     * in character class. Since 2.16
+     *     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
+     *     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
+     *     "(?<" or "(?P". Since 2.16
      */
     RegexError[RegexError["UNRECOGNIZED_CHARACTER"] = 112] = "UNRECOGNIZED_CHARACTER";
     /**
      * POSIX named classes are
-     * supported only within a class. Since 2.16
+     *     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
+     *     without opening "(". Since 2.16
      */
     RegexError[RegexError["UNMATCHED_PARENTHESIS"] = 114] = "UNMATCHED_PARENTHESIS";
     /**
      * Reference to non-existent
-     * subpattern. Since 2.16
+     *     subpattern. Since 2.16
      */
     RegexError[RegexError["INEXISTENT_SUBPATTERN_REFERENCE"] = 115] = "INEXISTENT_SUBPATTERN_REFERENCE";
     /**
      * Missing terminating ")" after comment.
-     * Since 2.16
+     *     Since 2.16
      */
     RegexError[RegexError["UNTERMINATED_COMMENT"] = 118] = "UNTERMINATED_COMMENT";
     /**
      * Regular expression too large.
-     * Since 2.16
+     *     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
+     *     fixed length. Since 2.16
      */
     RegexError[RegexError["VARIABLE_LENGTH_LOOKBEHIND"] = 125] = "VARIABLE_LENGTH_LOOKBEHIND";
     /**
      * Malformed number or name after "(?(".
-     * Since 2.16
+     *     Since 2.16
      */
     RegexError[RegexError["MALFORMED_CONDITION"] = 126] = "MALFORMED_CONDITION";
     /**
      * Conditional group contains
-     * more than two branches. Since 2.16
+     *     more than two branches. Since 2.16
      */
     RegexError[RegexError["TOO_MANY_CONDITIONAL_BRANCHES"] = 127] = "TOO_MANY_CONDITIONAL_BRANCHES";
     /**
      * Assertion expected after "(?(".
-     * Since 2.16
+     *     Since 2.16
      */
     RegexError[RegexError["ASSERTION_EXPECTED"] = 128] = "ASSERTION_EXPECTED";
     /**
      * Unknown POSIX class name.
-     * Since 2.16
+     *     Since 2.16
      */
     RegexError[RegexError["UNKNOWN_POSIX_CLASS_NAME"] = 130] = "UNKNOWN_POSIX_CLASS_NAME";
     /**
      * POSIX collating
-     * elements are not supported. Since 2.16
+     *     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
+     *     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
+     *     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
+     *     Since 2.16
      */
     RegexError[RegexError["INFINITE_LOOP"] = 140] = "INFINITE_LOOP";
     /**
      * Missing terminator
-     * in subpattern name. Since 2.16
+     *     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
+     *     the same name. Since 2.16
      */
     RegexError[RegexError["DUPLICATE_SUBPATTERN_NAME"] = 143] = "DUPLICATE_SUBPATTERN_NAME";
     /**
      * Malformed "\\P" or "\\p" sequence.
-     * Since 2.16
+     *     Since 2.16
      */
     RegexError[RegexError["MALFORMED_PROPERTY"] = 146] = "MALFORMED_PROPERTY";
     /**
      * Unknown property name after "\\P" or
-     * "\\p". Since 2.16
+     *     "\\p". Since 2.16
      */
     RegexError[RegexError["UNKNOWN_PROPERTY"] = 147] = "UNKNOWN_PROPERTY";
     /**
      * Subpattern name is too long
-     * (maximum 32 characters). Since 2.16
+     *     (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
+     *     10,000). Since 2.16
      */
     RegexError[RegexError["TOO_MANY_SUBPATTERNS"] = 149] = "TOO_MANY_SUBPATTERNS";
     /**
      * Octal value is greater than "\\377".
-     * Since 2.16
+     *     Since 2.16
      */
     RegexError[RegexError["INVALID_OCTAL_VALUE"] = 151] = "INVALID_OCTAL_VALUE";
     /**
      * "DEFINE" group contains more
-     * than one branch. Since 2.16
+     *     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
+     *     This error is never raised. Since: 2.16 Deprecated: 2.34
      */
     RegexError[RegexError["DEFINE_REPETION"] = 155] = "DEFINE_REPETION";
     /**
      * Inconsistent newline options.
-     * Since 2.16
+     *     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
+     *      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
+     *     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
+     *     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 */
@@ -768,27 +768,27 @@ export var RegexError;
     RegexError[RegexError["MISSING_DIGIT"] = 163] = "MISSING_DIGIT";
     /**
      * In JavaScript compatibility mode,
-     * "[" is an invalid data character. Since: 2.34
+     *     "[" 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
+     *     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
+     *     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
+     *     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
+     *     quoted name. Since: 2.34
      */
     RegexError[RegexError["MISSING_NAME"] = 169] = "MISSING_NAME";
     /** "\\N" is not supported in a class. Since: 2.34 */
@@ -797,12 +797,12 @@ export var RegexError;
     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
+     *     "(*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
+     *     too large. Since: 2.34
      */
     RegexError[RegexError["CHARACTER_VALUE_TOO_LARGE"] = 176] = "CHARACTER_VALUE_TOO_LARGE";
 })(RegexError || (RegexError = {}));
@@ -883,7 +883,7 @@ export var SpawnError;
     SpawnError[SpawnError["LIBBAD"] = 18] = "LIBBAD";
     /**
      * Some other fatal failure,
-     * `error->message` should explain.
+     *   `error->message` should explain.
      */
     SpawnError[SpawnError["FAILED"] = 19] = "FAILED";
 })(SpawnError || (SpawnError = {}));
@@ -940,7 +940,7 @@ export var ThreadError;
 (function (ThreadError) {
     /**
      * a thread couldn't be created due to resource
-     * shortage. Try again later.
+     *                        shortage. Try again later.
      */
     ThreadError[ThreadError["THREAD_ERROR_AGAIN"] = 0] = "THREAD_ERROR_AGAIN";
 })(ThreadError || (ThreadError = {}));
@@ -1035,21 +1035,21 @@ export var TokenType;
  * The different orders are illustrated here:
  *
  * - In order: A, B, C, D, E, F, G, H, I
- * ![Sorted binary tree, in-order traversal](https://docs.gtk.org/glib/Sorted_binary_tree_inorder.svg)
+ *   ![Sorted binary tree, in-order traversal](https://docs.gtk.org/glib/Sorted_binary_tree_inorder.svg)
  * - Pre order: F, B, A, D, C, E, G, I, H
- * ![Sorted binary tree, pre-order traversal](https://docs.gtk.org/glib/Sorted_binary_tree_preorder.svg)
+ *   ![Sorted binary tree, pre-order traversal](https://docs.gtk.org/glib/Sorted_binary_tree_preorder.svg)
  * - Post order: A, C, E, D, B, H, I, G, F
- * ![Sorted binary tree, post-order traversal](https://docs.gtk.org/glib/Sorted_binary_tree_postorder.svg)
+ *   ![Sorted binary tree, post-order traversal](https://docs.gtk.org/glib/Sorted_binary_tree_postorder.svg)
  * - Level order: F, B, G, A, D, I, C, E, H
- * ![Sorted binary tree, breadth-first level order traversal](https://docs.gtk.org/glib/Sorted_binary_tree_breadth-first_traversal.svg)
+ *   ![Sorted binary tree, breadth-first level order traversal](https://docs.gtk.org/glib/Sorted_binary_tree_breadth-first_traversal.svg)
  */
 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.
+     *              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. */
@@ -1058,11 +1058,11 @@ export var TraverseType;
     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.
+     *              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 = {}));
@@ -1148,9 +1148,7 @@ export var UnicodeBreakType;
     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.
-     */
+    /** 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";
@@ -1195,7 +1193,7 @@ export var UnicodeScript;
     UnicodeScript[UnicodeScript["COMMON"] = 0] = "COMMON";
     /**
      * a mark glyph that takes its script from the
-     * base glyph to which it is attached
+     *                               base glyph to which it is attached
      */
     UnicodeScript[UnicodeScript["INHERITED"] = 1] = "INHERITED";
     /** Arabic */
@@ -1620,7 +1618,7 @@ export var UriError;
 (function (UriError) {
     /**
      * Generic error if no more specific error is available.
-     * See the error message for details.
+     *     See the error message for details.
      */
     UriError[UriError["FAILED"] = 0] = "FAILED";
     /** The scheme of a URI could not be parsed. */
@@ -1695,14 +1693,14 @@ export var VariantClass;
     VariantClass[VariantClass["HANDLE"] = 104] = "HANDLE";
     /**
      * The #GVariant is a double precision floating
-     * point value.
+     *                          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.
+     *                               string.
      */
     VariantClass[VariantClass["OBJECT_PATH"] = 111] = "OBJECT_PATH";
     /** The #GVariant is a D-Bus signature string. */
@@ -1757,9 +1755,7 @@ export var VariantParseError;
     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)
-     */
+    /** 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;
@@ -1784,30 +1780,30 @@ export var FileSetContentsFlags;
 (function (FileSetContentsFlags) {
     /**
      * No guarantees about file consistency or durability.
-     * The most dangerous setting, which is slightly faster than other settings.
+     *   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.
+     *   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()`.
+     *   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.
+     *   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 = {}));
@@ -1816,8 +1812,8 @@ 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.
+     *     (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. */
@@ -1828,7 +1824,7 @@ export var FileTest;
     FileTest[FileTest["IS_EXECUTABLE"] = 8] = "IS_EXECUTABLE";
     /**
      * %TRUE if the file exists. It may or may not
-     * be a regular file.
+     *     be a regular file.
      */
     FileTest[FileTest["EXISTS"] = 16] = "EXISTS";
 })(FileTest || (FileTest = {}));
@@ -1839,31 +1835,31 @@ export var FormatSizeFlags;
     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)".
+     *     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.
+     *     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’.
+     *     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
+     *     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
+     *     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 = {}));
@@ -1876,7 +1872,7 @@ export var HookFlagMask;
     HookFlagMask[HookFlagMask["IN_CALL"] = 2] = "IN_CALL";
     /**
      * A mask covering all bits reserved for
-     * hook flags; see %G_HOOK_FLAG_USER_SHIFT
+     *   hook flags; see %G_HOOK_FLAG_USER_SHIFT
      */
     HookFlagMask[HookFlagMask["MASK"] = 15] = "MASK";
 })(HookFlagMask || (HookFlagMask = {}));
@@ -1896,7 +1892,7 @@ export var IOCondition;
     IOCondition[IOCondition["ERR"] = 8] = "ERR";
     /**
      * Hung up (the connection has been broken, usually for
-     * pipes and sockets).
+     *            pipes and sockets).
      */
     IOCondition[IOCondition["HUP"] = 16] = "HUP";
     /** Invalid request. The file descriptor is not open. */
@@ -1913,47 +1909,47 @@ export var IOFlags;
     IOFlags[IOFlags["NONE"] = 0] = "NONE";
     /**
      * turns on append mode, corresponds to %O_APPEND
-     * (see the documentation of the UNIX open() syscall)
+     *     (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)
+     *     %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.
+     *     This flag cannot be changed.
      */
     IOFlags[IOFlags["IS_READABLE"] = 4] = "IS_READABLE";
     /**
      * indicates that the io channel is writable.
-     * This flag cannot be changed.
+     *     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
+     *     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.
+     *     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()
+     *     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()
+     *     with g_io_channel_set_flags()
      */
     IOFlags[IOFlags["SET_MASK"] = 3] = "SET_MASK";
 })(IOFlags || (IOFlags = {}));
@@ -1964,16 +1960,16 @@ export var KeyFileFlags;
     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.
+     *   (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.
+     *   (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 = {}));
@@ -1991,13 +1987,13 @@ export var LogLevelFlags;
     LogLevelFlags[LogLevelFlags["FLAG_FATAL"] = 2] = "FLAG_FATAL";
     /**
      * log level for errors, see {@link GLib.error}.
-     * This level is also used for messages produced by {@link GLib.assert}.
+     *   This level is also used for messages produced by {@link GLib.assert}.
      */
     LogLevelFlags[LogLevelFlags["LEVEL_ERROR"] = 4] = "LEVEL_ERROR";
     /**
      * log level for critical warning messages, see
-     * {@link GLib.critical}. This level is also used for messages produced by
-     * {@link GLib.return_if_fail} and {@link GLib.return_val_if_fail}.
+     *   {@link GLib.critical}. This level is also used for messages produced by
+     *   {@link GLib.return_if_fail} and {@link GLib.return_val_if_fail}.
      */
     LogLevelFlags[LogLevelFlags["LEVEL_CRITICAL"] = 8] = "LEVEL_CRITICAL";
     /** log level for warnings, see {@link GLib.warning} */
@@ -2039,41 +2035,41 @@ export var MarkupCollectType;
 (function (MarkupCollectType) {
     /**
      * used to terminate the list of attributes
-     * to collect
+     *     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
+     *     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()
+     *     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"
+     *     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
+     *     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
+     *     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 = {}));
@@ -2086,25 +2082,25 @@ export var MarkupParseFlags;
     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
+     *     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
+     *     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.
+     *     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 = {}));
@@ -2117,41 +2113,41 @@ export var OptionFlags;
     OptionFlags[OptionFlags["HIDDEN"] = 1] = "HIDDEN";
     /**
      * The option appears in the main section of the
-     * `--help` output, even if it is defined in a group.
+     *   `--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.
+     *   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
+     *   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
+     *   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
+     *   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.
+     *   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";
     /**
@@ -2170,130 +2166,130 @@ export var RegexCompileFlags;
     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.
+     *     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.
+     *     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.
+     *     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.
+     *     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.
+     *     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.
+     *     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.
+     *     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.
+     *     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).
+     *     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.
+     *     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
+     *     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.
+     *     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'.
+     *     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'.
+     *     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'.
+     *     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
+     *     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
+     *     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
+     *     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 = {}));
@@ -2304,104 +2300,104 @@ export var RegexMatchFlags;
     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.
+     *     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".
+     *     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".
+     *     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".
+     *     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().
+     *     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.
+     *     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.
+     *     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.
+     *     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.
+     *     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
+     *     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
+     *     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
+     *     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
+     *     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
+     *     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 = {}));
@@ -2412,49 +2408,49 @@ export var SpawnFlags;
     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.
+     *     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.
+     *     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`.
+     *     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.
+     *     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`).
+     *     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.
+     *     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
+     *     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
+     *     Since: 2.40
      */
     SpawnFlags[SpawnFlags["CLOEXEC_PIPES"] = 256] = "CLOEXEC_PIPES";
     /** The child will inherit the parent's standard output. */
@@ -2477,22 +2473,22 @@ export var TestSubprocessFlags;
     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`.
+     *   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 {@link GLib.test_trap_assert_stdout}.
+     *   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 {@link 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 {@link GLib.test_trap_assert_stderr}.
+     *   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 {@link GLib.test_trap_assert_stderr}.
      */
     TestSubprocessFlags[TestSubprocessFlags["INHERIT_STDERR"] = 4] = "INHERIT_STDERR";
 })(TestSubprocessFlags || (TestSubprocessFlags = {}));
@@ -2507,22 +2503,22 @@ export var TestTrapFlags;
     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().
+     *     `/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().
+     *     `/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.
+     *     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 = {}));
@@ -2534,14 +2530,14 @@ 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.
+     *                     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.
+     *                         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. */
@@ -2567,55 +2563,55 @@ export var UriFlags;
     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.
+     *     [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 `:`.
+     *     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 `;`.
+     *     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.
+     *     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).
+     *     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.
+     *     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.
+     *     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)
+     *     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 = {}));
@@ -2652,7 +2648,7 @@ export var UriParamsFlags;
     UriParamsFlags[UriParamsFlags["CASE_INSENSITIVE"] = 1] = "CASE_INSENSITIVE";
     /**
      * Replace `+` with space character. Only useful for
-     * URLs on the web, using the `https` or `http` schemas.
+     *     URLs on the web, using the `https` or `http` schemas.
      */
     UriParamsFlags[UriParamsFlags["WWW_FORM"] = 2] = "WWW_FORM";
     /** See %G_URI_FLAGS_PARSE_RELAXED. */