@gtkx/ffi 0.1.45 → 0.1.46

package/dist/generated/glib/hash-table.d.ts

@@ -1,26 +1,259 @@
 import { Ref } from "@gtkx/native";
+/**
+ * The #GHashTable struct is an opaque data structure to represent a
+ * Hash Table. It should only be accessed via the
+ * following functions.
+ */
 export declare class HashTable {
     ptr: unknown;
     constructor();
     protected createPtr(_init: Record<string, unknown>): unknown;
+    /**
+     * This is a convenience function for using a #GHashTable as a set.  It
+     * is equivalent to calling g_hash_table_replace() with `key` as both the
+     * key and the value.
+     *
+     * In particular, this means that if `key` already exists in the hash table, then
+     * the old copy of `key` in the hash table is freed and `key` replaces it in the
+     * table.
+     *
+     * When a hash table only ever contains keys that have themselves as the
+     * corresponding value it is able to be stored more efficiently.  See
+     * the discussion in the section description.
+     *
+     * Starting from GLib 2.40, this function returns a boolean value to
+     * indicate whether the newly added value was already in the hash table
+     * or not.
+     * @param hashTable - a #GHashTable
+     * @param key - a key to insert
+     */
     static add(hashTable: HashTable, key?: number | null): boolean;
+    /**
+     * Checks if `key` is in @hash_table.
+     * @param hashTable - a #GHashTable
+     * @param key - a key to check
+     */
     static contains(hashTable: HashTable, key?: number | null): boolean;
+    /**
+     * Destroys all keys and values in the #GHashTable and decrements its
+     * reference count by 1. If keys and/or values are dynamically allocated,
+     * you should either free them first or create the #GHashTable with destroy
+     * notifiers using g_hash_table_new_full(). In the latter case the destroy
+     * functions you supplied will be called on all keys and values during the
+     * destruction phase.
+     * @param hashTable - a #GHashTable
+     */
     static destroy(hashTable: HashTable): void;
+    /**
+     * Calls the given function for key/value pairs in the #GHashTable
+     * until `predicate` returns %TRUE. The function is passed the key
+     * and value of each pair, and the given `user_data` parameter. The
+     * hash table may not be modified while iterating over it (you can't
+     * add/remove items).
+     *
+     * Note, that hash tables are really only optimized for forward
+     * lookups, i.e. g_hash_table_lookup(). So code that frequently issues
+     * g_hash_table_find() or g_hash_table_foreach() (e.g. in the order of
+     * once per every entry in a hash table) should probably be reworked
+     * to use additional or different data structures for reverse lookups
+     * (keep in mind that an O(n) find/foreach operation issued for all n
+     * values in a hash table ends up needing O(n*n) operations).
+     * @param hashTable - a #GHashTable
+     * @param predicate - function to test the key/value pairs for a certain property
+     * @param userData - user data to pass to the function
+     */
     static find(hashTable: HashTable, predicate: (...args: unknown[]) => unknown, userData?: number | null): number;
+    /**
+     * Calls the given function for each of the key/value pairs in the
+     * #GHashTable.  The function is passed the key and value of each
+     * pair, and the given `user_data` parameter.  The hash table may not
+     * be modified while iterating over it (you can't add/remove
+     * items). To remove all items matching a predicate, use
+     * g_hash_table_foreach_remove().
+     *
+     * The order in which g_hash_table_foreach() iterates over the keys/values in
+     * the hash table is not defined.
+     *
+     * See g_hash_table_find() for performance caveats for linear
+     * order searches in contrast to g_hash_table_lookup().
+     * @param hashTable - a #GHashTable
+     * @param func - the function to call for each key/value pair
+     * @param userData - user data to pass to the function
+     */
     static foreach(hashTable: HashTable, func: (...args: unknown[]) => unknown, userData?: number | null): void;
+    /**
+     * Calls the given function for each key/value pair in the
+     * #GHashTable. If the function returns %TRUE, then the key/value
+     * pair is removed from the #GHashTable. If you supplied key or
+     * value destroy functions when creating the #GHashTable, they are
+     * used to free the memory allocated for the removed keys and values.
+     *
+     * See #GHashTableIter for an alternative way to loop over the
+     * key/value pairs in the hash table.
+     * @param hashTable - a #GHashTable
+     * @param func - the function to call for each key/value pair
+     * @param userData - user data to pass to the function
+     */
     static foreachRemove(hashTable: HashTable, func: (...args: unknown[]) => unknown, userData?: number | null): number;
+    /**
+     * Calls the given function for each key/value pair in the
+     * #GHashTable. If the function returns %TRUE, then the key/value
+     * pair is removed from the #GHashTable, but no key or value
+     * destroy functions are called.
+     *
+     * See #GHashTableIter for an alternative way to loop over the
+     * key/value pairs in the hash table.
+     * @param hashTable - a #GHashTable
+     * @param func - the function to call for each key/value pair
+     * @param userData - user data to pass to the function
+     */
     static foreachSteal(hashTable: HashTable, func: (...args: unknown[]) => unknown, userData?: number | null): number;
+    /**
+     * Inserts a new key and value into a #GHashTable.
+     *
+     * If the key already exists in the #GHashTable its current
+     * value is replaced with the new value. If you supplied a
+     * `value_destroy_func` when creating the #GHashTable, the old
+     * value is freed using that function. If you supplied a
+     * `key_destroy_func` when creating the #GHashTable, the passed
+     * key is freed using that function.
+     *
+     * Starting from GLib 2.40, this function returns a boolean value to
+     * indicate whether the newly added value was already in the hash table
+     * or not.
+     * @param hashTable - a #GHashTable
+     * @param key - a key to insert
+     * @param value - the value to associate with the key
+     */
     static insert(hashTable: HashTable, key?: number | null, value?: number | null): boolean;
+    /**
+     * Looks up a key in a #GHashTable. Note that this function cannot
+     * distinguish between a key that is not present and one which is present
+     * and has the value %NULL. If you need this distinction, use
+     * g_hash_table_lookup_extended().
+     * @param hashTable - a #GHashTable
+     * @param key - the key to look up
+     */
     static lookup(hashTable: HashTable, key?: number | null): number;
+    /**
+     * Looks up a key in the #GHashTable, returning the original key and the
+     * associated value and a #gboolean which is %TRUE if the key was found. This
+     * is useful if you need to free the memory allocated for the original key,
+     * for example before calling g_hash_table_remove().
+     *
+     * You can actually pass %NULL for `lookup_key` to test
+     * whether the %NULL key exists, provided the hash and equal functions
+     * of `hash_table` are %NULL-safe.
+     * @param hashTable - a #GHashTable
+     * @param lookupKey - the key to look up
+     * @param origKey - return location for the original key
+     * @param value - return location for the value associated
+     */
     static lookupExtended(hashTable: HashTable, lookupKey?: number | null, origKey?: Ref<number> | null, value?: Ref<number> | null): boolean;
+    /**
+     * Creates a new #GHashTable like g_hash_table_new_full() with a reference
+     * count of 1.
+     *
+     * It inherits the hash function, the key equal function, the key destroy function,
+     * as well as the value destroy function, from @other_hash_table.
+     *
+     * The returned hash table will be empty; it will not contain the keys
+     * or values from @other_hash_table.
+     * @param otherHashTable - Another #GHashTable
+     */
     static newSimilar(otherHashTable: HashTable): HashTable;
+    /**
+     * Atomically increments the reference count of `hash_table` by one.
+     * This function is MT-safe and may be called from any thread.
+     * @param hashTable - a valid #GHashTable
+     */
     static ref(hashTable: HashTable): HashTable;
+    /**
+     * Removes a key and its associated value from a #GHashTable.
+     *
+     * If the #GHashTable was created using g_hash_table_new_full(), the
+     * key and value are freed using the supplied destroy functions, otherwise
+     * you have to make sure that any dynamically allocated values are freed
+     * yourself.
+     * @param hashTable - a #GHashTable
+     * @param key - the key to remove
+     */
     static remove(hashTable: HashTable, key?: number | null): boolean;
+    /**
+     * Removes all keys and their associated values from a #GHashTable.
+     *
+     * If the #GHashTable was created using g_hash_table_new_full(),
+     * the keys and values are freed using the supplied destroy functions,
+     * otherwise you have to make sure that any dynamically allocated
+     * values are freed yourself.
+     * @param hashTable - a #GHashTable
+     */
     static removeAll(hashTable: HashTable): void;
+    /**
+     * Inserts a new key and value into a #GHashTable similar to
+     * g_hash_table_insert(). The difference is that if the key
+     * already exists in the #GHashTable, it gets replaced by the
+     * new key. If you supplied a `value_destroy_func` when creating
+     * the #GHashTable, the old value is freed using that function.
+     * If you supplied a `key_destroy_func` when creating the
+     * #GHashTable, the old key is freed using that function.
+     *
+     * Starting from GLib 2.40, this function returns a boolean value to
+     * indicate whether the newly added value was already in the hash table
+     * or not.
+     * @param hashTable - a #GHashTable
+     * @param key - a key to insert
+     * @param value - the value to associate with the key
+     */
     static replace(hashTable: HashTable, key?: number | null, value?: number | null): boolean;
+    /**
+     * Returns the number of elements contained in the #GHashTable.
+     * @param hashTable - a #GHashTable
+     */
     static size(hashTable: HashTable): number;
+    /**
+     * Removes a key and its associated value from a #GHashTable without
+     * calling the key and value destroy functions.
+     * @param hashTable - a #GHashTable
+     * @param key - the key to remove
+     */
     static steal(hashTable: HashTable, key?: number | null): boolean;
+    /**
+     * Removes all keys and their associated values from a #GHashTable
+     * without calling the key and value destroy functions.
+     * @param hashTable - a #GHashTable
+     */
     static stealAll(hashTable: HashTable): void;
+    /**
+     * Looks up a key in the #GHashTable, stealing the original key and the
+     * associated value and returning %TRUE if the key was found. If the key was
+     * not found, %FALSE is returned.
+     *
+     * If found, the stolen key and value are removed from the hash table without
+     * calling the key and value destroy functions, and ownership is transferred to
+     * the caller of this method, as with g_hash_table_steal(). That is the case
+     * regardless whether `stolen_key` or `stolen_value` output parameters are
+     * requested.
+     *
+     * You can pass %NULL for @lookup_key, provided the hash and equal functions
+     * of `hash_table` are %NULL-safe.
+     *
+     * The dictionary implementation optimizes for having all values identical to
+     * their keys, for example by using g_hash_table_add(). Before 2.82, when
+     * stealing both the key and the value from such a dictionary, the value was
+     * %NULL. Since 2.82, the returned value and key will be the same.
+     * @param hashTable - a #GHashTable
+     * @param lookupKey - the key to look up
+     * @param stolenKey - return location for the
+     * @param stolenValue - return location
+     */
     static stealExtended(hashTable: HashTable, lookupKey?: number | null, stolenKey?: Ref<number> | null, stolenValue?: Ref<number> | null): boolean;
+    /**
+     * Atomically decrements the reference count of `hash_table` by one.
+     * If the reference count drops to 0, all keys and values will be
+     * destroyed, and all memory allocated by the hash table is released.
+     * This function is MT-safe and may be called from any thread.
+     * @param hashTable - a valid #GHashTable
+     */
     static unref(hashTable: HashTable): void;
 }

package/dist/generated/glib/hash-table.js

@@ -1,5 +1,10 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
+/**
+ * The #GHashTable struct is an opaque data structure to represent a
+ * Hash Table. It should only be accessed via the
+ * following functions.
+ */
 export class HashTable {
     ptr;
     constructor() {
@@ -8,6 +13,25 @@ export class HashTable {
     createPtr(_init) {
         return null;
     }
+    /**
+     * This is a convenience function for using a #GHashTable as a set.  It
+     * is equivalent to calling g_hash_table_replace() with `key` as both the
+     * key and the value.
+     *
+     * In particular, this means that if `key` already exists in the hash table, then
+     * the old copy of `key` in the hash table is freed and `key` replaces it in the
+     * table.
+     *
+     * When a hash table only ever contains keys that have themselves as the
+     * corresponding value it is able to be stored more efficiently.  See
+     * the discussion in the section description.
+     *
+     * Starting from GLib 2.40, this function returns a boolean value to
+     * indicate whether the newly added value was already in the hash table
+     * or not.
+     * @param hashTable - a #GHashTable
+     * @param key - a key to insert
+     */
     static add(hashTable, key) {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_hash_table_add", [
             {
@@ -26,6 +50,11 @@ export class HashTable {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Checks if `key` is in @hash_table.
+     * @param hashTable - a #GHashTable
+     * @param key - a key to check
+     */
     static contains(hashTable, key) {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_hash_table_contains", [
             {
@@ -44,6 +73,15 @@ export class HashTable {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Destroys all keys and values in the #GHashTable and decrements its
+     * reference count by 1. If keys and/or values are dynamically allocated,
+     * you should either free them first or create the #GHashTable with destroy
+     * notifiers using g_hash_table_new_full(). In the latter case the destroy
+     * functions you supplied will be called on all keys and values during the
+     * destruction phase.
+     * @param hashTable - a #GHashTable
+     */
     static destroy(hashTable) {
         call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_hash_table_destroy", [
             {
@@ -57,6 +95,24 @@ export class HashTable {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Calls the given function for key/value pairs in the #GHashTable
+     * until `predicate` returns %TRUE. The function is passed the key
+     * and value of each pair, and the given `user_data` parameter. The
+     * hash table may not be modified while iterating over it (you can't
+     * add/remove items).
+     *
+     * Note, that hash tables are really only optimized for forward
+     * lookups, i.e. g_hash_table_lookup(). So code that frequently issues
+     * g_hash_table_find() or g_hash_table_foreach() (e.g. in the order of
+     * once per every entry in a hash table) should probably be reworked
+     * to use additional or different data structures for reverse lookups
+     * (keep in mind that an O(n) find/foreach operation issued for all n
+     * values in a hash table ends up needing O(n*n) operations).
+     * @param hashTable - a #GHashTable
+     * @param predicate - function to test the key/value pairs for a certain property
+     * @param userData - user data to pass to the function
+     */
     static find(hashTable, predicate, userData) {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_hash_table_find", [
             {
@@ -79,6 +135,23 @@ export class HashTable {
             },
         ], { type: "int", size: 64, unsigned: true });
     }
+    /**
+     * Calls the given function for each of the key/value pairs in the
+     * #GHashTable.  The function is passed the key and value of each
+     * pair, and the given `user_data` parameter.  The hash table may not
+     * be modified while iterating over it (you can't add/remove
+     * items). To remove all items matching a predicate, use
+     * g_hash_table_foreach_remove().
+     *
+     * The order in which g_hash_table_foreach() iterates over the keys/values in
+     * the hash table is not defined.
+     *
+     * See g_hash_table_find() for performance caveats for linear
+     * order searches in contrast to g_hash_table_lookup().
+     * @param hashTable - a #GHashTable
+     * @param func - the function to call for each key/value pair
+     * @param userData - user data to pass to the function
+     */
     static foreach(hashTable, func, userData) {
         call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_hash_table_foreach", [
             {
@@ -101,6 +174,19 @@ export class HashTable {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Calls the given function for each key/value pair in the
+     * #GHashTable. If the function returns %TRUE, then the key/value
+     * pair is removed from the #GHashTable. If you supplied key or
+     * value destroy functions when creating the #GHashTable, they are
+     * used to free the memory allocated for the removed keys and values.
+     *
+     * See #GHashTableIter for an alternative way to loop over the
+     * key/value pairs in the hash table.
+     * @param hashTable - a #GHashTable
+     * @param func - the function to call for each key/value pair
+     * @param userData - user data to pass to the function
+     */
     static foreachRemove(hashTable, func, userData) {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_hash_table_foreach_remove", [
             {
@@ -123,6 +209,18 @@ export class HashTable {
             },
         ], { type: "int", size: 32, unsigned: true });
     }
+    /**
+     * Calls the given function for each key/value pair in the
+     * #GHashTable. If the function returns %TRUE, then the key/value
+     * pair is removed from the #GHashTable, but no key or value
+     * destroy functions are called.
+     *
+     * See #GHashTableIter for an alternative way to loop over the
+     * key/value pairs in the hash table.
+     * @param hashTable - a #GHashTable
+     * @param func - the function to call for each key/value pair
+     * @param userData - user data to pass to the function
+     */
     static foreachSteal(hashTable, func, userData) {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_hash_table_foreach_steal", [
             {
@@ -145,6 +243,23 @@ export class HashTable {
             },
         ], { type: "int", size: 32, unsigned: true });
     }
+    /**
+     * Inserts a new key and value into a #GHashTable.
+     *
+     * If the key already exists in the #GHashTable its current
+     * value is replaced with the new value. If you supplied a
+     * `value_destroy_func` when creating the #GHashTable, the old
+     * value is freed using that function. If you supplied a
+     * `key_destroy_func` when creating the #GHashTable, the passed
+     * key is freed using that function.
+     *
+     * Starting from GLib 2.40, this function returns a boolean value to
+     * indicate whether the newly added value was already in the hash table
+     * or not.
+     * @param hashTable - a #GHashTable
+     * @param key - a key to insert
+     * @param value - the value to associate with the key
+     */
     static insert(hashTable, key, value) {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_hash_table_insert", [
             {
@@ -168,6 +283,14 @@ export class HashTable {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Looks up a key in a #GHashTable. Note that this function cannot
+     * distinguish between a key that is not present and one which is present
+     * and has the value %NULL. If you need this distinction, use
+     * g_hash_table_lookup_extended().
+     * @param hashTable - a #GHashTable
+     * @param key - the key to look up
+     */
     static lookup(hashTable, key) {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_hash_table_lookup", [
             {
@@ -186,6 +309,20 @@ export class HashTable {
             },
         ], { type: "int", size: 64, unsigned: true });
     }
+    /**
+     * Looks up a key in the #GHashTable, returning the original key and the
+     * associated value and a #gboolean which is %TRUE if the key was found. This
+     * is useful if you need to free the memory allocated for the original key,
+     * for example before calling g_hash_table_remove().
+     *
+     * You can actually pass %NULL for `lookup_key` to test
+     * whether the %NULL key exists, provided the hash and equal functions
+     * of `hash_table` are %NULL-safe.
+     * @param hashTable - a #GHashTable
+     * @param lookupKey - the key to look up
+     * @param origKey - return location for the original key
+     * @param value - return location for the value associated
+     */
     static lookupExtended(hashTable, lookupKey, origKey, value) {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_hash_table_lookup_extended", [
             {
@@ -220,6 +357,17 @@ export class HashTable {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Creates a new #GHashTable like g_hash_table_new_full() with a reference
+     * count of 1.
+     *
+     * It inherits the hash function, the key equal function, the key destroy function,
+     * as well as the value destroy function, from @other_hash_table.
+     *
+     * The returned hash table will be empty; it will not contain the keys
+     * or values from @other_hash_table.
+     * @param otherHashTable - Another #GHashTable
+     */
     static newSimilar(otherHashTable) {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_hash_table_new_similar", [
             {
@@ -239,6 +387,11 @@ export class HashTable {
         });
         return getObject(ptr, HashTable);
     }
+    /**
+     * Atomically increments the reference count of `hash_table` by one.
+     * This function is MT-safe and may be called from any thread.
+     * @param hashTable - a valid #GHashTable
+     */
     static ref(hashTable) {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_hash_table_ref", [
             {
@@ -258,6 +411,16 @@ export class HashTable {
         });
         return getObject(ptr, HashTable);
     }
+    /**
+     * Removes a key and its associated value from a #GHashTable.
+     *
+     * If the #GHashTable was created using g_hash_table_new_full(), the
+     * key and value are freed using the supplied destroy functions, otherwise
+     * you have to make sure that any dynamically allocated values are freed
+     * yourself.
+     * @param hashTable - a #GHashTable
+     * @param key - the key to remove
+     */
     static remove(hashTable, key) {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_hash_table_remove", [
             {
@@ -276,6 +439,15 @@ export class HashTable {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Removes all keys and their associated values from a #GHashTable.
+     *
+     * If the #GHashTable was created using g_hash_table_new_full(),
+     * the keys and values are freed using the supplied destroy functions,
+     * otherwise you have to make sure that any dynamically allocated
+     * values are freed yourself.
+     * @param hashTable - a #GHashTable
+     */
     static removeAll(hashTable) {
         call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_hash_table_remove_all", [
             {
@@ -289,6 +461,22 @@ export class HashTable {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Inserts a new key and value into a #GHashTable similar to
+     * g_hash_table_insert(). The difference is that if the key
+     * already exists in the #GHashTable, it gets replaced by the
+     * new key. If you supplied a `value_destroy_func` when creating
+     * the #GHashTable, the old value is freed using that function.
+     * If you supplied a `key_destroy_func` when creating the
+     * #GHashTable, the old key is freed using that function.
+     *
+     * Starting from GLib 2.40, this function returns a boolean value to
+     * indicate whether the newly added value was already in the hash table
+     * or not.
+     * @param hashTable - a #GHashTable
+     * @param key - a key to insert
+     * @param value - the value to associate with the key
+     */
     static replace(hashTable, key, value) {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_hash_table_replace", [
             {
@@ -312,6 +500,10 @@ export class HashTable {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Returns the number of elements contained in the #GHashTable.
+     * @param hashTable - a #GHashTable
+     */
     static size(hashTable) {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_hash_table_size", [
             {
@@ -325,6 +517,12 @@ export class HashTable {
             },
         ], { type: "int", size: 32, unsigned: true });
     }
+    /**
+     * Removes a key and its associated value from a #GHashTable without
+     * calling the key and value destroy functions.
+     * @param hashTable - a #GHashTable
+     * @param key - the key to remove
+     */
     static steal(hashTable, key) {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_hash_table_steal", [
             {
@@ -343,6 +541,11 @@ export class HashTable {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Removes all keys and their associated values from a #GHashTable
+     * without calling the key and value destroy functions.
+     * @param hashTable - a #GHashTable
+     */
     static stealAll(hashTable) {
         call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_hash_table_steal_all", [
             {
@@ -356,6 +559,29 @@ export class HashTable {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Looks up a key in the #GHashTable, stealing the original key and the
+     * associated value and returning %TRUE if the key was found. If the key was
+     * not found, %FALSE is returned.
+     *
+     * If found, the stolen key and value are removed from the hash table without
+     * calling the key and value destroy functions, and ownership is transferred to
+     * the caller of this method, as with g_hash_table_steal(). That is the case
+     * regardless whether `stolen_key` or `stolen_value` output parameters are
+     * requested.
+     *
+     * You can pass %NULL for @lookup_key, provided the hash and equal functions
+     * of `hash_table` are %NULL-safe.
+     *
+     * The dictionary implementation optimizes for having all values identical to
+     * their keys, for example by using g_hash_table_add(). Before 2.82, when
+     * stealing both the key and the value from such a dictionary, the value was
+     * %NULL. Since 2.82, the returned value and key will be the same.
+     * @param hashTable - a #GHashTable
+     * @param lookupKey - the key to look up
+     * @param stolenKey - return location for the
+     * @param stolenValue - return location
+     */
     static stealExtended(hashTable, lookupKey, stolenKey, stolenValue) {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_hash_table_steal_extended", [
             {
@@ -390,6 +616,13 @@ export class HashTable {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Atomically decrements the reference count of `hash_table` by one.
+     * If the reference count drops to 0, all keys and values will be
+     * destroyed, and all memory allocated by the hash table is released.
+     * This function is MT-safe and may be called from any thread.
+     * @param hashTable - a valid #GHashTable
+     */
     static unref(hashTable) {
         call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_hash_table_unref", [
             {