@gtkx/ffi 0.1.45 → 0.1.46

package/dist/generated/glib/match-info.js

@@ -1,6 +1,10 @@
 import { call } from "@gtkx/native";
 import { NativeError, getObject } from "@gtkx/ffi";
 import { Regex } from "./regex.js";
+/**
+ * A GMatchInfo is an opaque struct used to return information about
+ * matches.
+ */
 export class MatchInfo {
     ptr;
     constructor() {
@@ -9,6 +13,25 @@ export class MatchInfo {
     createPtr(_init) {
         return null;
     }
+    /**
+     * Returns a new string containing the text in `string_to_expand` with
+     * references and escape sequences expanded. References refer to the last
+     * match done with `string` against `regex` and have the same syntax used by
+     * g_regex_replace().
+     *
+     * The `string_to_expand` must be UTF-8 encoded even if %G_REGEX_RAW was
+     * passed to g_regex_new().
+     *
+     * The backreferences are extracted from the string passed to the match
+     * function, so you cannot call this function after freeing the string.
+     *
+     * `match_info` may be %NULL in which case `string_to_expand` must not
+     * contain references. For instance "foo\n" does not refer to an actual
+     * pattern and '\n' merely will be replaced with \n character,
+     * while to expand "\0" (whole match) one needs the result of a match.
+     * Use g_regex_check_replacement() to find out whether `string_to_expand` contains references.
+     * @param stringToExpand - the string to expand
+     */
     expandReferences(stringToExpand) {
         const error = { value: null };
         const result = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_match_info_expand_references", [
@@ -37,6 +60,25 @@ export class MatchInfo {
         }
         return result;
     }
+    /**
+     * Retrieves the text matching the @match_num'th capturing
+     * parentheses. 0 is the full text of the match, 1 is the first paren
+     * set, 2 the second, and so on.
+     *
+     * If `match_num` is a valid sub pattern but it didn't match anything
+     * (e.g. sub pattern 1, matching "b" against "(a)?b") then an empty
+     * string is returned.
+     *
+     * If the match was obtained using the DFA algorithm, that is using
+     * g_regex_match_all() or g_regex_match_all_full(), the retrieved
+     * string is not that of a set of parentheses but that of a matched
+     * substring. Substrings are matched in reverse order of length, so
+     * 0 is the longest match.
+     *
+     * The string is fetched from the string passed to the match function,
+     * so you cannot call this function after freeing the string.
+     * @param matchNum - number of the sub expression
+     */
     fetch(matchNum) {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_match_info_fetch", [
             {
@@ -49,6 +91,24 @@ export class MatchInfo {
             },
         ], { type: "string" });
     }
+    /**
+     * Bundles up pointers to each of the matching substrings from a match
+     * and stores them in an array of gchar pointers. The first element in
+     * the returned array is the match number 0, i.e. the entire matched
+     * text.
+     *
+     * If a sub pattern didn't match anything (e.g. sub pattern 1, matching
+     * "b" against "(a)?b") then an empty string is inserted.
+     *
+     * If the last match was obtained using the DFA algorithm, that is using
+     * g_regex_match_all() or g_regex_match_all_full(), the retrieved
+     * strings are not that matched by sets of parentheses but that of the
+     * matched substring. Substrings are matched in reverse order of length,
+     * so the first one is the longest match.
+     *
+     * The strings are fetched from the string passed to the match function,
+     * so you cannot call this function after freeing the string.
+     */
     fetchAll() {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_match_info_fetch_all", [
             {
@@ -57,6 +117,17 @@ export class MatchInfo {
             },
         ], { type: "array", itemType: { type: "string" } });
     }
+    /**
+     * Retrieves the text matching the capturing parentheses named @name.
+     *
+     * If `name` is a valid sub pattern name but it didn't match anything
+     * (e.g. sub pattern `"X"`, matching `"b"` against `"(?P<X>a)?b"`)
+     * then an empty string is returned.
+     *
+     * The string is fetched from the string passed to the match function,
+     * so you cannot call this function after freeing the string.
+     * @param name - name of the subexpression
+     */
     fetchNamed(name) {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_match_info_fetch_named", [
             {
@@ -69,6 +140,19 @@ export class MatchInfo {
             },
         ], { type: "string" });
     }
+    /**
+     * Retrieves the position in bytes of the capturing parentheses named @name.
+     *
+     * If `name` is a valid sub pattern name but it didn't match anything
+     * (e.g. sub pattern `"X"`, matching `"b"` against `"(?P<X>a)?b"`)
+     * then `start_pos` and `end_pos` are set to -1 and %TRUE is returned.
+     *
+     * As `end_pos` is set to the byte after the final byte of the match (on success),
+     * the length of the match can be calculated as `end_pos - start_pos`.
+     * @param name - name of the subexpression
+     * @param startPos - pointer to location where to store
+     * @param endPos - pointer to location where to store
+     */
     fetchNamedPos(name, startPos, endPos) {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_match_info_fetch_named_pos", [
             {
@@ -97,6 +181,214 @@ export class MatchInfo {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Returns the start and end positions (in bytes) of a successfully matching
+     * capture parenthesis.
+     *
+     * Valid values for `match_num` are `0` for the full text of the match,
+     * `1` for the first paren set, `2` for the second, and so on.
+     *
+     * As `end_pos` is set to the byte after the final byte of the match (on success),
+     * the length of the match can be calculated as `end_pos - start_pos`.
+     *
+     * As a best practice, initialize `start_pos` and `end_pos` to identifiable
+     * values, such as `G_MAXINT`, so that you can test if
+     * `g_match_info_fetch_pos()` actually changed the value for a given
+     * capture parenthesis.
+     *
+     * The parameter `match_num` corresponds to a matched capture parenthesis. The
+     * actual value you use for `match_num` depends on the method used to generate
+     * @match_info. The following sections describe those methods.
+     *
+     * ## Methods Using Non-deterministic Finite Automata Matching
+     *
+     * The methods [method@GLib.Regex.match] and [method@GLib.Regex.match_full]
+     * return a [struct@GLib.MatchInfo] using traditional (greedy) pattern
+     * matching, also known as
+     * [Non-deterministic Finite Automaton](https://en.wikipedia.org/wiki/Nondeterministic_finite_automaton)
+     * (NFA) matching. You pass the returned `GMatchInfo` from these methods to
+     * `g_match_info_fetch_pos()` to determine the start and end positions
+     * of capture parentheses. The values for `match_num` correspond to the capture
+     * parentheses in order, with `0` corresponding to the entire matched string.
+     *
+     * `match_num` can refer to a capture parenthesis with no match. For example,
+     * the string `b` matches against the pattern `(a)?b`, but the capture
+     * parenthesis `(a)` has no match. In this case, `g_match_info_fetch_pos()`
+     * returns true and sets `start_pos` and `end_pos` to `-1` when called with
+     * `match_num` as `1` (for `(a)`).
+     *
+     * For an expanded example, a regex pattern is `(a)?(.*?)the (.*)`,
+     * and a candidate string is `glib regexes are the best`. In this scenario
+     * there are four capture parentheses numbered 0–3: an implicit one
+     * for the entire string, and three explicitly declared in the regex pattern.
+     *
+     * Given this example, the following table describes the return values
+     * from `g_match_info_fetch_pos()` for various values of @match_num.
+     *
+     * `match_num` | Contents | Return value | Returned `start_pos` | Returned `end_pos`
+     * ----------- | -------- | ------------ | -------------------- | ------------------
+     * 0 | Matches entire string | True | 0 | 25
+     * 1 | Does not match first character | True | -1 | -1
+     * 2 | All text before `the ` | True | 0 | 17
+     * 3 | All text after `the ` | True | 21 | 25
+     * 4 | Capture paren out of range | False | Unchanged | Unchanged
+     *
+     * The following code sample and output implements this example.
+     *
+     * ``` { .c }
+     * #include <glib.h>
+     *
+     * int
+     * main (int argc, char *argv[])
+     * {
+     * g_autoptr(GError) local_error = NULL;
+     * const char *regex_pattern = "(a)?(.*?)the (.*)";
+     * const char *test_string = "glib regexes are the best";
+     * g_autoptr(GRegex) regex = NULL;
+     *
+     * regex = g_regex_new (regex_pattern,
+     * G_REGEX_DEFAULT,
+     * G_REGEX_MATCH_DEFAULT,
+     * &local_error);
+     * if (regex == NULL)
+     * {
+     * g_printerr ("Error creating regex: %s\n", local_error->message);
+     * return 1;
+     * }
+     *
+     * g_autoptr(GMatchInfo) match_info = NULL;
+     * g_regex_match (regex, test_string, G_REGEX_MATCH_DEFAULT, &match_info);
+     *
+     * int n_matched_strings = g_match_info_get_match_count (match_info);
+     *
+     * // Print header line
+     * g_print ("match_num Contents                  Return value returned start_pos returned end_pos\n");
+     *
+     * // Iterate over each capture paren, including one that is out of range as a demonstration.
+     * for (int match_num = 0; match_num <= n_matched_strings; match_num++)
+     * {
+     * gboolean found_match;
+     * g_autofree char *paren_string = NULL;
+     * int start_pos = G_MAXINT;
+     * int end_pos = G_MAXINT;
+     *
+     * found_match = g_match_info_fetch_pos (match_info,
+     * match_num,
+     * &start_pos,
+     * &end_pos);
+     *
+     * // If no match, display N/A as the found string.
+     * if (start_pos == G_MAXINT || start_pos == -1)
+     * paren_string = g_strdup ("N/A");
+     * else
+     * paren_string = g_strndup (test_string + start_pos, end_pos - start_pos);
+     *
+     * g_print ("%-9d %-25s %-12d %-18d %d\n", match_num, paren_string, found_match, start_pos, end_pos);
+     * }
+     *
+     * return 0;
+     * }
+     * ```
+     *
+     * ```
+     * match_num Contents                  Return value returned start_pos returned end_pos
+     * 0         glib regexes are the best 1            0                  25
+     * 1         N/A                       1            -1                 -1
+     * 2         glib regexes are          1            0                  17
+     * 3         best                      1            21                 25
+     * 4         N/A                       0            2147483647         2147483647
+     * ```
+     * ## Methods Using Deterministic Finite Automata Matching
+     *
+     * The methods [method@GLib.Regex.match_all] and
+     * [method@GLib.Regex.match_all_full]
+     * return a `GMatchInfo` using
+     * [Deterministic Finite Automaton](https://en.wikipedia.org/wiki/Deterministic_finite_automaton)
+     * (DFA) pattern matching. This algorithm detects overlapping matches. You pass
+     * the returned `GMatchInfo` from these methods to `g_match_info_fetch_pos()`
+     * to determine the start and end positions of each overlapping match. Use the
+     * method [method@GLib.MatchInfo.get_match_count] to determine the number
+     * of overlapping matches.
+     *
+     * For example, a regex pattern is `<.*>`, and a candidate string is
+     * `<a> <b> <c>`. In this scenario there are three implicit capture
+     * parentheses: one for the entire string, one for `<a> <b>`, and one for `<a>`.
+     *
+     * Given this example, the following table describes the return values from
+     * `g_match_info_fetch_pos()` for various values of @match_num.
+     *
+     * `match_num` | Contents | Return value | Returned `start_pos` | Returned `end_pos`
+     * ----------- | -------- | ------------ | -------------------- | ------------------
+     * 0 | Matches entire string | True | 0 | 11
+     * 1 | Matches `<a> <b>` | True | 0 | 7
+     * 2 | Matches `<a>` | True | 0 | 3
+     * 3 | Capture paren out of range | False | Unchanged | Unchanged
+     *
+     * The following code sample and output implements this example.
+     *
+     * ``` { .c }
+     * #include <glib.h>
+     *
+     * int
+     * main (int argc, char *argv[])
+     * {
+     * g_autoptr(GError) local_error = NULL;
+     * const char *regex_pattern = "<.*>";
+     * const char *test_string = "<a> <b> <c>";
+     * g_autoptr(GRegex) regex = NULL;
+     *
+     * regex = g_regex_new (regex_pattern,
+     * G_REGEX_DEFAULT,
+     * G_REGEX_MATCH_DEFAULT,
+     * &local_error);
+     * if (regex == NULL)
+     * {
+     * g_printerr ("Error creating regex: %s\n", local_error->message);
+     * return -1;
+     * }
+     *
+     * g_autoptr(GMatchInfo) match_info = NULL;
+     * g_regex_match_all (regex, test_string, G_REGEX_MATCH_DEFAULT, &match_info);
+     *
+     * int n_matched_strings = g_match_info_get_match_count (match_info);
+     *
+     * // Print header line
+     * g_print ("match_num Contents                  Return value returned start_pos returned end_pos\n");
+     *
+     * // Iterate over each capture paren, including one that is out of range as a demonstration.
+     * for (int match_num = 0; match_num <= n_matched_strings; match_num++)
+     * {
+     * gboolean found_match;
+     * g_autofree char *paren_string = NULL;
+     * int start_pos = G_MAXINT;
+     * int end_pos = G_MAXINT;
+     *
+     * found_match = g_match_info_fetch_pos (match_info, match_num, &start_pos, &end_pos);
+     *
+     * // If no match, display N/A as the found string.
+     * if (start_pos == G_MAXINT || start_pos == -1)
+     * paren_string = g_strdup ("N/A");
+     * else
+     * paren_string = g_strndup (test_string + start_pos, end_pos - start_pos);
+     *
+     * g_print ("%-9d %-25s %-12d %-18d %d\n", match_num, paren_string, found_match, start_pos, end_pos);
+     * }
+     *
+     * return 0;
+     * }
+     * ```
+     *
+     * ```
+     * match_num Contents                  Return value returned start_pos returned end_pos
+     * 0         <a> <b> <c>               1            0                  11
+     * 1         <a> <b>                   1            0                  7
+     * 2         <a>                       1            0                  3
+     * 3         N/A                       0            2147483647         2147483647
+     * ```
+     * @param matchNum - number of the capture parenthesis
+     * @param startPos - pointer to location where to store
+     * @param endPos - pointer to location where to store
+     */
     fetchPos(matchNum, startPos, endPos) {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_match_info_fetch_pos", [
             {
@@ -125,6 +417,10 @@ export class MatchInfo {
             },
         ], { type: "boolean" });
     }
+    /**
+     * If `match_info` is not %NULL, calls g_match_info_unref(); otherwise does
+     * nothing.
+     */
     free() {
         call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_match_info_free", [
             {
@@ -133,6 +429,16 @@ export class MatchInfo {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Retrieves the number of matched substrings (including substring 0,
+     * that is the whole matched text), so 1 is returned if the pattern
+     * has no substrings in it and 0 is returned if the match failed.
+     *
+     * If the last match was obtained using the DFA algorithm, that is
+     * using g_regex_match_all() or g_regex_match_all_full(), the retrieved
+     * count is not that of the number of capturing parentheses but that of
+     * the number of matched substrings.
+     */
     getMatchCount() {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_match_info_get_match_count", [
             {
@@ -141,6 +447,11 @@ export class MatchInfo {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Returns #GRegex object used in @match_info. It belongs to Glib
+     * and must not be freed. Use g_regex_ref() if you need to keep it
+     * after you free `match_info` object.
+     */
     getRegex() {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_match_info_get_regex", [
             {
@@ -155,6 +466,11 @@ export class MatchInfo {
         });
         return getObject(ptr, Regex);
     }
+    /**
+     * Returns the string searched with @match_info. This is the
+     * string passed to g_regex_match() or g_regex_replace() so
+     * you may not free it before calling this function.
+     */
     getString() {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_match_info_get_string", [
             {
@@ -163,6 +479,41 @@ export class MatchInfo {
             },
         ], { type: "string", borrowed: true });
     }
+    /**
+     * Usually if the string passed to g_regex_match*() matches as far as
+     * it goes, but is too short to match the entire pattern, %FALSE is
+     * returned. There are circumstances where it might be helpful to
+     * distinguish this case from other cases in which there is no match.
+     *
+     * Consider, for example, an application where a human is required to
+     * type in data for a field with specific formatting requirements. An
+     * example might be a date in the form ddmmmyy, defined by the pattern
+     * "^\d?\d(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\d\d$".
+     * If the application sees the user’s keystrokes one by one, and can
+     * check that what has been typed so far is potentially valid, it is
+     * able to raise an error as soon as a mistake is made.
+     *
+     * GRegex supports the concept of partial matching by means of the
+     * %G_REGEX_MATCH_PARTIAL_SOFT and %G_REGEX_MATCH_PARTIAL_HARD flags.
+     * When they are used, the return code for
+     * g_regex_match() or g_regex_match_full() is, as usual, %TRUE
+     * for a complete match, %FALSE otherwise. But, when these functions
+     * return %FALSE, you can check if the match was partial calling
+     * g_match_info_is_partial_match().
+     *
+     * The difference between %G_REGEX_MATCH_PARTIAL_SOFT and
+     * %G_REGEX_MATCH_PARTIAL_HARD is that when a partial match is encountered
+     * with %G_REGEX_MATCH_PARTIAL_SOFT, matching continues to search for a
+     * possible complete match, while with %G_REGEX_MATCH_PARTIAL_HARD matching
+     * stops at the partial match.
+     * When both %G_REGEX_MATCH_PARTIAL_SOFT and %G_REGEX_MATCH_PARTIAL_HARD
+     * are set, the latter takes precedence.
+     *
+     * There were formerly some restrictions on the pattern for partial matching.
+     * The restrictions no longer apply.
+     *
+     * See pcrepartial(3) for more information on partial matching.
+     */
     isPartialMatch() {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_match_info_is_partial_match", [
             {
@@ -171,6 +522,9 @@ export class MatchInfo {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Returns whether the previous match operation succeeded.
+     */
     matches() {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_match_info_matches", [
             {
@@ -179,6 +533,14 @@ export class MatchInfo {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Scans for the next match using the same parameters of the previous
+     * call to g_regex_match_full() or g_regex_match() that returned
+     * @match_info.
+     *
+     * The match is done on the string passed to the match function, so you
+     * cannot free it before calling this function.
+     */
     next() {
         const error = { value: null };
         const result = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_match_info_next", [
@@ -203,6 +565,9 @@ export class MatchInfo {
         }
         return result;
     }
+    /**
+     * Increases reference count of `match_info` by 1.
+     */
     ref() {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_match_info_ref", [
             {
@@ -217,6 +582,10 @@ export class MatchInfo {
         });
         return getObject(ptr, MatchInfo);
     }
+    /**
+     * Decreases reference count of `match_info` by 1. When reference count drops
+     * to zero, it frees all the memory associated with the match_info structure.
+     */
     unref() {
         call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_match_info_unref", [
             {

package/dist/generated/glib/option-group.d.ts

@@ -1,12 +1,66 @@
+/**
+ * A `GOptionGroup` struct defines the options in a single
+ * group. The struct has only private fields and should not be directly accessed.
+ *
+ * All options in a group share the same translation function. Libraries which
+ * need to parse commandline options are expected to provide a function for
+ * getting a `GOptionGroup` holding their options, which
+ * the application can then add to its #GOptionContext.
+ */
 export declare class OptionGroup {
     ptr: unknown;
+    /**
+     * Creates a new #GOptionGroup.
+     *
+     * `description` is typically used to provide a title for the group. If so, it
+     * is recommended that it’s written in title case, and has a trailing colon so
+     * that it matches the style of built-in GLib group titles such as
+     * ‘Application Options:’.
+     * @param name - the name for the option group, this is used to provide
+     * @param description - a description for this group to be shown in
+     * @param helpDescription - a description for the `--help-``name` option.
+     * @param userData - user data that will be passed to the pre- and post-parse hooks,
+     * @param destroy - a function that will be called to free @user_data, or %NULL
+     */
     constructor(name: string, description: string, helpDescription: string, userData?: number | null, destroy?: (...args: unknown[]) => unknown | null);
     constructor(_args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * Adds the options specified in `entries` to @group.
+     * @param entries - a %NULL-terminated array of #GOptionEntrys
+     */
     addEntries(entries: number[]): void;
+    /**
+     * Frees a #GOptionGroup. Note that you must not free groups
+     * which have been added to a #GOptionContext.
+     */
     free(): void;
+    /**
+     * Increments the reference count of `group` by one.
+     */
     ref(): OptionGroup;
+    /**
+     * Sets the function which is used to translate user-visible strings,
+     * for `--help` output. Different groups can use different
+     * #GTranslateFuncs. If `func` is %NULL, strings are not translated.
+     *
+     * If you are using gettext(), you only need to set the translation
+     * domain, see g_option_group_set_translation_domain().
+     * @param func - the #GTranslateFunc, or %NULL
+     * @param data - user data to pass to @func, or %NULL
+     * @param destroyNotify - a function which gets called to free @data, or %NULL
+     */
     setTranslateFunc(func?: (...args: unknown[]) => unknown | null, data?: number | null, destroyNotify?: (...args: unknown[]) => unknown | null): void;
+    /**
+     * A convenience function to use gettext() for translating
+     * user-visible strings.
+     * @param domain - the domain to use
+     */
     setTranslationDomain(domain: string): void;
+    /**
+     * Decrements the reference count of `group` by one.
+     * If the reference count drops to 0, the `group` will be freed.
+     * and all memory allocated by the `group` is released.
+     */
     unref(): void;
 }

package/dist/generated/glib/option-group.js

@@ -1,5 +1,14 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
+/**
+ * A `GOptionGroup` struct defines the options in a single
+ * group. The struct has only private fields and should not be directly accessed.
+ *
+ * All options in a group share the same translation function. Libraries which
+ * need to parse commandline options are expected to provide a function for
+ * getting a `GOptionGroup` holding their options, which
+ * the application can then add to its #GOptionContext.
+ */
 export class OptionGroup {
     ptr;
     constructor(...args) {
@@ -33,6 +42,10 @@ export class OptionGroup {
             },
         ], { type: "boxed", borrowed: true, innerType: "GOptionGroup" });
     }
+    /**
+     * Adds the options specified in `entries` to @group.
+     * @param entries - a %NULL-terminated array of #GOptionEntrys
+     */
     addEntries(entries) {
         call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_option_group_add_entries", [
             {
@@ -48,6 +61,10 @@ export class OptionGroup {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Frees a #GOptionGroup. Note that you must not free groups
+     * which have been added to a #GOptionContext.
+     */
     free() {
         call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_option_group_free", [
             {
@@ -56,6 +73,9 @@ export class OptionGroup {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Increments the reference count of `group` by one.
+     */
     ref() {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_option_group_ref", [
             {
@@ -70,6 +90,17 @@ export class OptionGroup {
         });
         return getObject(ptr, OptionGroup);
     }
+    /**
+     * Sets the function which is used to translate user-visible strings,
+     * for `--help` output. Different groups can use different
+     * #GTranslateFuncs. If `func` is %NULL, strings are not translated.
+     *
+     * If you are using gettext(), you only need to set the translation
+     * domain, see g_option_group_set_translation_domain().
+     * @param func - the #GTranslateFunc, or %NULL
+     * @param data - user data to pass to @func, or %NULL
+     * @param destroyNotify - a function which gets called to free @data, or %NULL
+     */
     setTranslateFunc(func, data, destroyNotify) {
         call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_option_group_set_translate_func", [
             {
@@ -93,6 +124,11 @@ export class OptionGroup {
             },
         ], { type: "undefined" });
     }
+    /**
+     * A convenience function to use gettext() for translating
+     * user-visible strings.
+     * @param domain - the domain to use
+     */
     setTranslationDomain(domain) {
         call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_option_group_set_translation_domain", [
             {
@@ -105,6 +141,11 @@ export class OptionGroup {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Decrements the reference count of `group` by one.
+     * If the reference count drops to 0, the `group` will be freed.
+     * and all memory allocated by the `group` is released.
+     */
     unref() {
         call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_option_group_unref", [
             {