@gtkx/ffi 0.1.45 → 0.1.46

package/dist/generated/gobject/functions.js

@@ -3,6 +3,11 @@ import { getObject } from "@gtkx/ffi";
 import { Closure } from "./closure.js";
 import { ParamSpec } from "./param-spec.js";
 import { TypePlugin } from "./type-plugin.js";
+/**
+ * Provide a copy of a boxed structure `src_boxed` which is of type @boxed_type.
+ * @param boxedType - The type of @src_boxed.
+ * @param srcBoxed - The boxed structure to be copied.
+ */
 export const boxedCopy = (boxedType, srcBoxed) => {
     return call("libgobject-2.0.so.0", "g_boxed_copy", [
         {
@@ -15,6 +20,11 @@ export const boxedCopy = (boxedType, srcBoxed) => {
         },
     ], { type: "int", size: 64, unsigned: true });
 };
+/**
+ * Free the boxed structure `boxed` which is of type @boxed_type.
+ * @param boxedType - The type of @boxed.
+ * @param boxed - The boxed structure to be freed.
+ */
 export const boxedFree = (boxedType, boxed) => {
     call("libgobject-2.0.so.0", "g_boxed_free", [
         {
@@ -27,6 +37,20 @@ export const boxedFree = (boxedType, boxed) => {
         },
     ], { type: "undefined" });
 };
+/**
+ * This function creates a new %G_TYPE_BOXED derived type id for a new
+ * boxed type with name @name.
+ *
+ * Boxed type handling functions have to be provided to copy and free
+ * opaque boxed structures of this type.
+ *
+ * For the general case, it is recommended to use G_DEFINE_BOXED_TYPE()
+ * instead of calling g_boxed_type_register_static() directly. The macro
+ * will create the appropriate `*_get_type()` function for the boxed type.
+ * @param name - Name of the new boxed type.
+ * @param boxedCopy - Boxed structure copy function.
+ * @param boxedFree - Boxed structure free function.
+ */
 export const boxedTypeRegisterStatic = (name, boxedCopy, boxedFree) => {
     return call("libgobject-2.0.so.0", "g_boxed_type_register_static", [
         {
@@ -43,6 +67,18 @@ export const boxedTypeRegisterStatic = (name, boxedCopy, boxedFree) => {
         },
     ], { type: "int", size: 64, unsigned: true });
 };
+/**
+ * A #GClosureMarshal function for use with signals with handlers that
+ * take two boxed pointers as arguments and return a boolean.  If you
+ * have such a signal, you will probably also need to use an
+ * accumulator, such as g_signal_accumulator_true_handled().
+ * @param closure - A #GClosure.
+ * @param returnValue - A #GValue to store the return value. May be %NULL
+ * @param nParamValues - The length of the `param_values` array.
+ * @param paramValues - An array of #GValues holding the arguments
+ * @param invocationHint - The invocation hint given as the last argument to
+ * @param marshalData - Additional data specified when registering the
+ */
 export const cclosureMarshal_BOOLEAN__BOXED_BOXED = (closure, returnValue, nParamValues, paramValues, invocationHint, marshalData) => {
     call("libgobject-2.0.so.0", "g_cclosure_marshal_BOOLEAN__BOXED_BOXED", [
         {
@@ -88,6 +124,18 @@ export const cclosureMarshal_BOOLEAN__BOXED_BOXED = (closure, returnValue, nPara
         },
     ], { type: "undefined" });
 };
+/**
+ * A #GClosureMarshal function for use with signals with handlers that
+ * take a flags type as an argument and return a boolean.  If you have
+ * such a signal, you will probably also need to use an accumulator,
+ * such as g_signal_accumulator_true_handled().
+ * @param closure - A #GClosure.
+ * @param returnValue - A #GValue to store the return value. May be %NULL
+ * @param nParamValues - The length of the `param_values` array.
+ * @param paramValues - An array of #GValues holding the arguments
+ * @param invocationHint - The invocation hint given as the last argument to
+ * @param marshalData - Additional data specified when registering the
+ */
 export const cclosureMarshal_BOOLEAN__FLAGS = (closure, returnValue, nParamValues, paramValues, invocationHint, marshalData) => {
     call("libgobject-2.0.so.0", "g_cclosure_marshal_BOOLEAN__FLAGS", [
         {
@@ -133,6 +181,17 @@ export const cclosureMarshal_BOOLEAN__FLAGS = (closure, returnValue, nParamValue
         },
     ], { type: "undefined" });
 };
+/**
+ * A #GClosureMarshal function for use with signals with handlers that
+ * take a #GObject and a pointer and produce a string.  It is highly
+ * unlikely that your signal handler fits this description.
+ * @param closure - A #GClosure.
+ * @param returnValue - A #GValue to store the return value. May be %NULL
+ * @param nParamValues - The length of the `param_values` array.
+ * @param paramValues - An array of #GValues holding the arguments
+ * @param invocationHint - The invocation hint given as the last argument to
+ * @param marshalData - Additional data specified when registering the
+ */
 export const cclosureMarshal_STRING__OBJECT_POINTER = (closure, returnValue, nParamValues, paramValues, invocationHint, marshalData) => {
     call("libgobject-2.0.so.0", "g_cclosure_marshal_STRING__OBJECT_POINTER", [
         {
@@ -178,6 +237,16 @@ export const cclosureMarshal_STRING__OBJECT_POINTER = (closure, returnValue, nPa
         },
     ], { type: "undefined" });
 };
+/**
+ * A #GClosureMarshal function for use with signals with a single
+ * boolean argument.
+ * @param closure - A #GClosure.
+ * @param returnValue - A #GValue to store the return value. May be %NULL
+ * @param nParamValues - The length of the `param_values` array.
+ * @param paramValues - An array of #GValues holding the arguments
+ * @param invocationHint - The invocation hint given as the last argument to
+ * @param marshalData - Additional data specified when registering the
+ */
 export const cclosureMarshal_VOID__BOOLEAN = (closure, returnValue, nParamValues, paramValues, invocationHint, marshalData) => {
     call("libgobject-2.0.so.0", "g_cclosure_marshal_VOID__BOOLEAN", [
         {
@@ -223,6 +292,16 @@ export const cclosureMarshal_VOID__BOOLEAN = (closure, returnValue, nParamValues
         },
     ], { type: "undefined" });
 };
+/**
+ * A #GClosureMarshal function for use with signals with a single
+ * argument which is any boxed pointer type.
+ * @param closure - A #GClosure.
+ * @param returnValue - A #GValue to store the return value. May be %NULL
+ * @param nParamValues - The length of the `param_values` array.
+ * @param paramValues - An array of #GValues holding the arguments
+ * @param invocationHint - The invocation hint given as the last argument to
+ * @param marshalData - Additional data specified when registering the
+ */
 export const cclosureMarshal_VOID__BOXED = (closure, returnValue, nParamValues, paramValues, invocationHint, marshalData) => {
     call("libgobject-2.0.so.0", "g_cclosure_marshal_VOID__BOXED", [
         {
@@ -268,6 +347,16 @@ export const cclosureMarshal_VOID__BOXED = (closure, returnValue, nParamValues,
         },
     ], { type: "undefined" });
 };
+/**
+ * A #GClosureMarshal function for use with signals with a single
+ * character argument.
+ * @param closure - A #GClosure.
+ * @param returnValue - A #GValue to store the return value. May be %NULL
+ * @param nParamValues - The length of the `param_values` array.
+ * @param paramValues - An array of #GValues holding the arguments
+ * @param invocationHint - The invocation hint given as the last argument to
+ * @param marshalData - Additional data specified when registering the
+ */
 export const cclosureMarshal_VOID__CHAR = (closure, returnValue, nParamValues, paramValues, invocationHint, marshalData) => {
     call("libgobject-2.0.so.0", "g_cclosure_marshal_VOID__CHAR", [
         {
@@ -313,6 +402,16 @@ export const cclosureMarshal_VOID__CHAR = (closure, returnValue, nParamValues, p
         },
     ], { type: "undefined" });
 };
+/**
+ * A #GClosureMarshal function for use with signals with one
+ * double-precision floating point argument.
+ * @param closure - A #GClosure.
+ * @param returnValue - A #GValue to store the return value. May be %NULL
+ * @param nParamValues - The length of the `param_values` array.
+ * @param paramValues - An array of #GValues holding the arguments
+ * @param invocationHint - The invocation hint given as the last argument to
+ * @param marshalData - Additional data specified when registering the
+ */
 export const cclosureMarshal_VOID__DOUBLE = (closure, returnValue, nParamValues, paramValues, invocationHint, marshalData) => {
     call("libgobject-2.0.so.0", "g_cclosure_marshal_VOID__DOUBLE", [
         {
@@ -358,6 +457,16 @@ export const cclosureMarshal_VOID__DOUBLE = (closure, returnValue, nParamValues,
         },
     ], { type: "undefined" });
 };
+/**
+ * A #GClosureMarshal function for use with signals with a single
+ * argument with an enumerated type.
+ * @param closure - A #GClosure.
+ * @param returnValue - A #GValue to store the return value. May be %NULL
+ * @param nParamValues - The length of the `param_values` array.
+ * @param paramValues - An array of #GValues holding the arguments
+ * @param invocationHint - The invocation hint given as the last argument to
+ * @param marshalData - Additional data specified when registering the
+ */
 export const cclosureMarshal_VOID__ENUM = (closure, returnValue, nParamValues, paramValues, invocationHint, marshalData) => {
     call("libgobject-2.0.so.0", "g_cclosure_marshal_VOID__ENUM", [
         {
@@ -403,6 +512,16 @@ export const cclosureMarshal_VOID__ENUM = (closure, returnValue, nParamValues, p
         },
     ], { type: "undefined" });
 };
+/**
+ * A #GClosureMarshal function for use with signals with a single
+ * argument with a flags types.
+ * @param closure - A #GClosure.
+ * @param returnValue - A #GValue to store the return value. May be %NULL
+ * @param nParamValues - The length of the `param_values` array.
+ * @param paramValues - An array of #GValues holding the arguments
+ * @param invocationHint - The invocation hint given as the last argument to
+ * @param marshalData - Additional data specified when registering the
+ */
 export const cclosureMarshal_VOID__FLAGS = (closure, returnValue, nParamValues, paramValues, invocationHint, marshalData) => {
     call("libgobject-2.0.so.0", "g_cclosure_marshal_VOID__FLAGS", [
         {
@@ -448,6 +567,16 @@ export const cclosureMarshal_VOID__FLAGS = (closure, returnValue, nParamValues,
         },
     ], { type: "undefined" });
 };
+/**
+ * A #GClosureMarshal function for use with signals with one
+ * single-precision floating point argument.
+ * @param closure - A #GClosure.
+ * @param returnValue - A #GValue to store the return value. May be %NULL
+ * @param nParamValues - The length of the `param_values` array.
+ * @param paramValues - An array of #GValues holding the arguments
+ * @param invocationHint - The invocation hint given as the last argument to
+ * @param marshalData - Additional data specified when registering the
+ */
 export const cclosureMarshal_VOID__FLOAT = (closure, returnValue, nParamValues, paramValues, invocationHint, marshalData) => {
     call("libgobject-2.0.so.0", "g_cclosure_marshal_VOID__FLOAT", [
         {
@@ -493,6 +622,16 @@ export const cclosureMarshal_VOID__FLOAT = (closure, returnValue, nParamValues,
         },
     ], { type: "undefined" });
 };
+/**
+ * A #GClosureMarshal function for use with signals with a single
+ * integer argument.
+ * @param closure - A #GClosure.
+ * @param returnValue - A #GValue to store the return value. May be %NULL
+ * @param nParamValues - The length of the `param_values` array.
+ * @param paramValues - An array of #GValues holding the arguments
+ * @param invocationHint - The invocation hint given as the last argument to
+ * @param marshalData - Additional data specified when registering the
+ */
 export const cclosureMarshal_VOID__INT = (closure, returnValue, nParamValues, paramValues, invocationHint, marshalData) => {
     call("libgobject-2.0.so.0", "g_cclosure_marshal_VOID__INT", [
         {
@@ -538,6 +677,16 @@ export const cclosureMarshal_VOID__INT = (closure, returnValue, nParamValues, pa
         },
     ], { type: "undefined" });
 };
+/**
+ * A #GClosureMarshal function for use with signals with with a single
+ * long integer argument.
+ * @param closure - A #GClosure.
+ * @param returnValue - A #GValue to store the return value. May be %NULL
+ * @param nParamValues - The length of the `param_values` array.
+ * @param paramValues - An array of #GValues holding the arguments
+ * @param invocationHint - The invocation hint given as the last argument to
+ * @param marshalData - Additional data specified when registering the
+ */
 export const cclosureMarshal_VOID__LONG = (closure, returnValue, nParamValues, paramValues, invocationHint, marshalData) => {
     call("libgobject-2.0.so.0", "g_cclosure_marshal_VOID__LONG", [
         {
@@ -583,6 +732,16 @@ export const cclosureMarshal_VOID__LONG = (closure, returnValue, nParamValues, p
         },
     ], { type: "undefined" });
 };
+/**
+ * A #GClosureMarshal function for use with signals with a single
+ * #GObject argument.
+ * @param closure - A #GClosure.
+ * @param returnValue - A #GValue to store the return value. May be %NULL
+ * @param nParamValues - The length of the `param_values` array.
+ * @param paramValues - An array of #GValues holding the arguments
+ * @param invocationHint - The invocation hint given as the last argument to
+ * @param marshalData - Additional data specified when registering the
+ */
 export const cclosureMarshal_VOID__OBJECT = (closure, returnValue, nParamValues, paramValues, invocationHint, marshalData) => {
     call("libgobject-2.0.so.0", "g_cclosure_marshal_VOID__OBJECT", [
         {
@@ -628,6 +787,16 @@ export const cclosureMarshal_VOID__OBJECT = (closure, returnValue, nParamValues,
         },
     ], { type: "undefined" });
 };
+/**
+ * A #GClosureMarshal function for use with signals with a single
+ * argument of type #GParamSpec.
+ * @param closure - A #GClosure.
+ * @param returnValue - A #GValue to store the return value. May be %NULL
+ * @param nParamValues - The length of the `param_values` array.
+ * @param paramValues - An array of #GValues holding the arguments
+ * @param invocationHint - The invocation hint given as the last argument to
+ * @param marshalData - Additional data specified when registering the
+ */
 export const cclosureMarshal_VOID__PARAM = (closure, returnValue, nParamValues, paramValues, invocationHint, marshalData) => {
     call("libgobject-2.0.so.0", "g_cclosure_marshal_VOID__PARAM", [
         {
@@ -673,6 +842,20 @@ export const cclosureMarshal_VOID__PARAM = (closure, returnValue, nParamValues,
         },
     ], { type: "undefined" });
 };
+/**
+ * A #GClosureMarshal function for use with signals with a single raw
+ * pointer argument type.
+ *
+ * If it is possible, it is better to use one of the more specific
+ * functions such as g_cclosure_marshal_VOID__OBJECT() or
+ * g_cclosure_marshal_VOID__OBJECT().
+ * @param closure - A #GClosure.
+ * @param returnValue - A #GValue to store the return value. May be %NULL
+ * @param nParamValues - The length of the `param_values` array.
+ * @param paramValues - An array of #GValues holding the arguments
+ * @param invocationHint - The invocation hint given as the last argument to
+ * @param marshalData - Additional data specified when registering the
+ */
 export const cclosureMarshal_VOID__POINTER = (closure, returnValue, nParamValues, paramValues, invocationHint, marshalData) => {
     call("libgobject-2.0.so.0", "g_cclosure_marshal_VOID__POINTER", [
         {
@@ -718,6 +901,16 @@ export const cclosureMarshal_VOID__POINTER = (closure, returnValue, nParamValues
         },
     ], { type: "undefined" });
 };
+/**
+ * A #GClosureMarshal function for use with signals with a single string
+ * argument.
+ * @param closure - A #GClosure.
+ * @param returnValue - A #GValue to store the return value. May be %NULL
+ * @param nParamValues - The length of the `param_values` array.
+ * @param paramValues - An array of #GValues holding the arguments
+ * @param invocationHint - The invocation hint given as the last argument to
+ * @param marshalData - Additional data specified when registering the
+ */
 export const cclosureMarshal_VOID__STRING = (closure, returnValue, nParamValues, paramValues, invocationHint, marshalData) => {
     call("libgobject-2.0.so.0", "g_cclosure_marshal_VOID__STRING", [
         {
@@ -763,6 +956,16 @@ export const cclosureMarshal_VOID__STRING = (closure, returnValue, nParamValues,
         },
     ], { type: "undefined" });
 };
+/**
+ * A #GClosureMarshal function for use with signals with a single
+ * unsigned character argument.
+ * @param closure - A #GClosure.
+ * @param returnValue - A #GValue to store the return value. May be %NULL
+ * @param nParamValues - The length of the `param_values` array.
+ * @param paramValues - An array of #GValues holding the arguments
+ * @param invocationHint - The invocation hint given as the last argument to
+ * @param marshalData - Additional data specified when registering the
+ */
 export const cclosureMarshal_VOID__UCHAR = (closure, returnValue, nParamValues, paramValues, invocationHint, marshalData) => {
     call("libgobject-2.0.so.0", "g_cclosure_marshal_VOID__UCHAR", [
         {
@@ -808,6 +1011,16 @@ export const cclosureMarshal_VOID__UCHAR = (closure, returnValue, nParamValues,
         },
     ], { type: "undefined" });
 };
+/**
+ * A #GClosureMarshal function for use with signals with with a single
+ * unsigned integer argument.
+ * @param closure - A #GClosure.
+ * @param returnValue - A #GValue to store the return value. May be %NULL
+ * @param nParamValues - The length of the `param_values` array.
+ * @param paramValues - An array of #GValues holding the arguments
+ * @param invocationHint - The invocation hint given as the last argument to
+ * @param marshalData - Additional data specified when registering the
+ */
 export const cclosureMarshal_VOID__UINT = (closure, returnValue, nParamValues, paramValues, invocationHint, marshalData) => {
     call("libgobject-2.0.so.0", "g_cclosure_marshal_VOID__UINT", [
         {
@@ -853,6 +1066,16 @@ export const cclosureMarshal_VOID__UINT = (closure, returnValue, nParamValues, p
         },
     ], { type: "undefined" });
 };
+/**
+ * A #GClosureMarshal function for use with signals with an unsigned int
+ * and a pointer as arguments.
+ * @param closure - A #GClosure.
+ * @param returnValue - A #GValue to store the return value. May be %NULL
+ * @param nParamValues - The length of the `param_values` array.
+ * @param paramValues - An array of #GValues holding the arguments
+ * @param invocationHint - The invocation hint given as the last argument to
+ * @param marshalData - Additional data specified when registering the
+ */
 export const cclosureMarshal_VOID__UINT_POINTER = (closure, returnValue, nParamValues, paramValues, invocationHint, marshalData) => {
     call("libgobject-2.0.so.0", "g_cclosure_marshal_VOID__UINT_POINTER", [
         {
@@ -898,6 +1121,16 @@ export const cclosureMarshal_VOID__UINT_POINTER = (closure, returnValue, nParamV
         },
     ], { type: "undefined" });
 };
+/**
+ * A #GClosureMarshal function for use with signals with a single
+ * unsigned long integer argument.
+ * @param closure - A #GClosure.
+ * @param returnValue - A #GValue to store the return value. May be %NULL
+ * @param nParamValues - The length of the `param_values` array.
+ * @param paramValues - An array of #GValues holding the arguments
+ * @param invocationHint - The invocation hint given as the last argument to
+ * @param marshalData - Additional data specified when registering the
+ */
 export const cclosureMarshal_VOID__ULONG = (closure, returnValue, nParamValues, paramValues, invocationHint, marshalData) => {
     call("libgobject-2.0.so.0", "g_cclosure_marshal_VOID__ULONG", [
         {
@@ -943,6 +1176,16 @@ export const cclosureMarshal_VOID__ULONG = (closure, returnValue, nParamValues,
         },
     ], { type: "undefined" });
 };
+/**
+ * A #GClosureMarshal function for use with signals with a single
+ * #GVariant argument.
+ * @param closure - A #GClosure.
+ * @param returnValue - A #GValue to store the return value. May be %NULL
+ * @param nParamValues - The length of the `param_values` array.
+ * @param paramValues - An array of #GValues holding the arguments
+ * @param invocationHint - The invocation hint given as the last argument to
+ * @param marshalData - Additional data specified when registering the
+ */
 export const cclosureMarshal_VOID__VARIANT = (closure, returnValue, nParamValues, paramValues, invocationHint, marshalData) => {
     call("libgobject-2.0.so.0", "g_cclosure_marshal_VOID__VARIANT", [
         {
@@ -988,6 +1231,15 @@ export const cclosureMarshal_VOID__VARIANT = (closure, returnValue, nParamValues
         },
     ], { type: "undefined" });
 };
+/**
+ * A #GClosureMarshal function for use with signals with no arguments.
+ * @param closure - A #GClosure.
+ * @param returnValue - A #GValue to store the return value. May be %NULL
+ * @param nParamValues - The length of the `param_values` array.
+ * @param paramValues - An array of #GValues holding the arguments
+ * @param invocationHint - The invocation hint given as the last argument to
+ * @param marshalData - Additional data specified when registering the
+ */
 export const cclosureMarshal_VOID__VOID = (closure, returnValue, nParamValues, paramValues, invocationHint, marshalData) => {
     call("libgobject-2.0.so.0", "g_cclosure_marshal_VOID__VOID", [
         {
@@ -1033,6 +1285,19 @@ export const cclosureMarshal_VOID__VOID = (closure, returnValue, nParamValues, p
         },
     ], { type: "undefined" });
 };
+/**
+ * A generic marshaller function implemented via
+ * [libffi](http://sourceware.org/libffi/).
+ *
+ * Normally this function is not passed explicitly to g_signal_new(),
+ * but used automatically by GLib when specifying a %NULL marshaller.
+ * @param closure - A #GClosure.
+ * @param returnGvalue - A #GValue to store the return value. May be %NULL
+ * @param nParamValues - The length of the `param_values` array.
+ * @param paramValues - An array of #GValues holding the arguments
+ * @param invocationHint - The invocation hint given as the last argument to
+ * @param marshalData - Additional data specified when registering the
+ */
 export const cclosureMarshalGeneric = (closure, returnGvalue, nParamValues, paramValues, invocationHint, marshalData) => {
     call("libgobject-2.0.so.0", "g_cclosure_marshal_generic", [
         {
@@ -1078,6 +1343,18 @@ export const cclosureMarshalGeneric = (closure, returnGvalue, nParamValues, para
         },
     ], { type: "undefined" });
 };
+/**
+ * Disconnects a handler from `instance` so it will not be called during
+ * any future or currently ongoing emissions of the signal it has been
+ * connected to. The `handler_id_ptr` is then set to zero, which is never a valid handler ID value (see g_signal_connect()).
+ *
+ * If the handler ID is 0 then this function does nothing.
+ *
+ * There is also a macro version of this function so that the code
+ * will be inlined.
+ * @param handlerIdPtr - A pointer to a handler ID (of type #gulong) of the handler to be disconnected.
+ * @param instance - The instance to remove the signal handler from.
+ */
 export const clearSignalHandler = (handlerIdPtr, instance) => {
     call("libgobject-2.0.so.0", "g_clear_signal_handler", [
         {
@@ -1090,6 +1367,31 @@ export const clearSignalHandler = (handlerIdPtr, instance) => {
         },
     ], { type: "undefined" });
 };
+/**
+ * This function is meant to be called from the `complete_type_info`
+ * function of a #GTypePlugin implementation, as in the following
+ * example:
+ *
+ * |[<!-- language="C" -->
+ * static void
+ * my_enum_complete_type_info (GTypePlugin     *plugin,
+ * GType            g_type,
+ * GTypeInfo       *info,
+ * GTypeValueTable *value_table)
+ * {
+ * static const GEnumValue values[] = {
+ * { MY_ENUM_FOO, "MY_ENUM_FOO", "foo" },
+ * { MY_ENUM_BAR, "MY_ENUM_BAR", "bar" },
+ * { 0, NULL, NULL }
+ * };
+ *
+ * g_enum_complete_type_info (type, info, values);
+ * }
+ * ]|
+ * @param gEnumType - the type identifier of the type being completed
+ * @param info - the #GTypeInfo struct to be filled in
+ * @param constValues - An array of #GEnumValue
+ */
 export const enumCompleteTypeInfo = (gEnumType, info, constValues) => {
     call("libgobject-2.0.so.0", "g_enum_complete_type_info", [
         {
@@ -1112,6 +1414,11 @@ export const enumCompleteTypeInfo = (gEnumType, info, constValues) => {
         },
     ], { type: "undefined" });
 };
+/**
+ * Returns the #GEnumValue for a value.
+ * @param enumClass - a #GEnumClass
+ * @param value - the value to look up
+ */
 export const enumGetValue = (enumClass, value) => {
     return call("libgobject-2.0.so.0", "g_enum_get_value", [
         {
@@ -1124,6 +1431,11 @@ export const enumGetValue = (enumClass, value) => {
         },
     ], { type: "int", size: 64, unsigned: true });
 };
+/**
+ * Looks up a #GEnumValue by name.
+ * @param enumClass - a #GEnumClass
+ * @param name - the name to look up
+ */
 export const enumGetValueByName = (enumClass, name) => {
     return call("libgobject-2.0.so.0", "g_enum_get_value_by_name", [
         {
@@ -1136,6 +1448,11 @@ export const enumGetValueByName = (enumClass, name) => {
         },
     ], { type: "int", size: 64, unsigned: true });
 };
+/**
+ * Looks up a #GEnumValue by nickname.
+ * @param enumClass - a #GEnumClass
+ * @param nick - the nickname to look up
+ */
 export const enumGetValueByNick = (enumClass, nick) => {
     return call("libgobject-2.0.so.0", "g_enum_get_value_by_nick", [
         {
@@ -1148,6 +1465,15 @@ export const enumGetValueByNick = (enumClass, nick) => {
         },
     ], { type: "int", size: 64, unsigned: true });
 };
+/**
+ * Registers a new static enumeration type with the name @name.
+ *
+ * It is normally more convenient to let [glib-mkenums][glib-mkenums],
+ * generate a my_enum_get_type() function from a usual C enumeration
+ * definition  than to write one yourself using g_enum_register_static().
+ * @param name - A nul-terminated string used as the name of the new type.
+ * @param constStaticValues - An array of
+ */
 export const enumRegisterStatic = (name, constStaticValues) => {
     return call("libgobject-2.0.so.0", "g_enum_register_static", [
         {
@@ -1163,6 +1489,14 @@ export const enumRegisterStatic = (name, constStaticValues) => {
         },
     ], { type: "int", size: 64, unsigned: true });
 };
+/**
+ * Pretty-prints `value` in the form of the enum’s name.
+ *
+ * This is intended to be used for debugging purposes. The format of the output
+ * may change in the future.
+ * @param gEnumType - the type identifier of a #GEnumClass type
+ * @param value - the value
+ */
 export const enumToString = (gEnumType, value) => {
     return call("libgobject-2.0.so.0", "g_enum_to_string", [
         {
@@ -1175,6 +1509,14 @@ export const enumToString = (gEnumType, value) => {
         },
     ], { type: "string" });
 };
+/**
+ * This function is meant to be called from the complete_type_info()
+ * function of a #GTypePlugin implementation, see the example for
+ * g_enum_complete_type_info() above.
+ * @param gFlagsType - the type identifier of the type being completed
+ * @param info - the #GTypeInfo struct to be filled in
+ * @param constValues - An array of #GFlagsValue
+ */
 export const flagsCompleteTypeInfo = (gFlagsType, info, constValues) => {
     call("libgobject-2.0.so.0", "g_flags_complete_type_info", [
         {
@@ -1197,6 +1539,11 @@ export const flagsCompleteTypeInfo = (gFlagsType, info, constValues) => {
         },
     ], { type: "undefined" });
 };
+/**
+ * Returns the first #GFlagsValue which is set in @value.
+ * @param flagsClass - a #GFlagsClass
+ * @param value - the value
+ */
 export const flagsGetFirstValue = (flagsClass, value) => {
     return call("libgobject-2.0.so.0", "g_flags_get_first_value", [
         {
@@ -1209,6 +1556,11 @@ export const flagsGetFirstValue = (flagsClass, value) => {
         },
     ], { type: "int", size: 64, unsigned: true });
 };
+/**
+ * Looks up a #GFlagsValue by name.
+ * @param flagsClass - a #GFlagsClass
+ * @param name - the name to look up
+ */
 export const flagsGetValueByName = (flagsClass, name) => {
     return call("libgobject-2.0.so.0", "g_flags_get_value_by_name", [
         {
@@ -1221,6 +1573,11 @@ export const flagsGetValueByName = (flagsClass, name) => {
         },
     ], { type: "int", size: 64, unsigned: true });
 };
+/**
+ * Looks up a #GFlagsValue by nickname.
+ * @param flagsClass - a #GFlagsClass
+ * @param nick - the nickname to look up
+ */
 export const flagsGetValueByNick = (flagsClass, nick) => {
     return call("libgobject-2.0.so.0", "g_flags_get_value_by_nick", [
         {
@@ -1233,6 +1590,15 @@ export const flagsGetValueByNick = (flagsClass, nick) => {
         },
     ], { type: "int", size: 64, unsigned: true });
 };
+/**
+ * Registers a new static flags type with the name @name.
+ *
+ * It is normally more convenient to let [glib-mkenums][glib-mkenums]
+ * generate a my_flags_get_type() function from a usual C enumeration
+ * definition than to write one yourself using g_flags_register_static().
+ * @param name - A nul-terminated string used as the name of the new type.
+ * @param constStaticValues - An array of
+ */
 export const flagsRegisterStatic = (name, constStaticValues) => {
     return call("libgobject-2.0.so.0", "g_flags_register_static", [
         {
@@ -1248,6 +1614,15 @@ export const flagsRegisterStatic = (name, constStaticValues) => {
         },
     ], { type: "int", size: 64, unsigned: true });
 };
+/**
+ * Pretty-prints `value` in the form of the flag names separated by ` | ` and
+ * sorted. Any extra bits will be shown at the end as a hexadecimal number.
+ *
+ * This is intended to be used for debugging purposes. The format of the output
+ * may change in the future.
+ * @param flagsType - the type identifier of a #GFlagsClass type
+ * @param value - the value
+ */
 export const flagsToString = (flagsType, value) => {
     return call("libgobject-2.0.so.0", "g_flags_to_string", [
         {
@@ -1267,6 +1642,20 @@ export const gtypeGetType = () => {
         unsigned: true,
     });
 };
+/**
+ * Creates a new #GParamSpecBoolean instance specifying a %G_TYPE_BOOLEAN
+ * property. In many cases, it may be more appropriate to use an enum with
+ * g_param_spec_enum(), both to improve code clarity by using explicitly named
+ * values, and to allow for more values to be added in future without breaking
+ * API.
+ *
+ * See g_param_spec_internal() for details on property names.
+ * @param name - canonical name of the property specified
+ * @param nick - nick name for the property specified
+ * @param blurb - description of the property specified
+ * @param defaultValue - default value for the property specified
+ * @param flags - flags for the property specified
+ */
 export const paramSpecBoolean = (name, defaultValue, flags, nick, blurb) => {
     const ptr = call("libgobject-2.0.so.0", "g_param_spec_boolean", [
         {
@@ -1294,6 +1683,17 @@ export const paramSpecBoolean = (name, defaultValue, flags, nick, blurb) => {
     ], { type: "gobject", borrowed: true });
     return getObject(ptr, ParamSpec);
 };
+/**
+ * Creates a new #GParamSpecBoxed instance specifying a %G_TYPE_BOXED
+ * derived property.
+ *
+ * See g_param_spec_internal() for details on property names.
+ * @param name - canonical name of the property specified
+ * @param nick - nick name for the property specified
+ * @param blurb - description of the property specified
+ * @param boxedType - %G_TYPE_BOXED derived type of this property
+ * @param flags - flags for the property specified
+ */
 export const paramSpecBoxed = (name, boxedType, flags, nick, blurb) => {
     const ptr = call("libgobject-2.0.so.0", "g_param_spec_boxed", [
         {
@@ -1321,6 +1721,16 @@ export const paramSpecBoxed = (name, boxedType, flags, nick, blurb) => {
     ], { type: "gobject", borrowed: true });
     return getObject(ptr, ParamSpec);
 };
+/**
+ * Creates a new #GParamSpecChar instance specifying a %G_TYPE_CHAR property.
+ * @param name - canonical name of the property specified
+ * @param nick - nick name for the property specified
+ * @param blurb - description of the property specified
+ * @param minimum - minimum value for the property specified
+ * @param maximum - maximum value for the property specified
+ * @param defaultValue - default value for the property specified
+ * @param flags - flags for the property specified
+ */
 export const paramSpecChar = (name, minimum, maximum, defaultValue, flags, nick, blurb) => {
     const ptr = call("libgobject-2.0.so.0", "g_param_spec_char", [
         {
@@ -1356,6 +1766,19 @@ export const paramSpecChar = (name, minimum, maximum, defaultValue, flags, nick,
     ], { type: "gobject", borrowed: true });
     return getObject(ptr, ParamSpec);
 };
+/**
+ * Creates a new #GParamSpecDouble instance specifying a %G_TYPE_DOUBLE
+ * property.
+ *
+ * See g_param_spec_internal() for details on property names.
+ * @param name - canonical name of the property specified
+ * @param nick - nick name for the property specified
+ * @param blurb - description of the property specified
+ * @param minimum - minimum value for the property specified
+ * @param maximum - maximum value for the property specified
+ * @param defaultValue - default value for the property specified
+ * @param flags - flags for the property specified
+ */
 export const paramSpecDouble = (name, minimum, maximum, defaultValue, flags, nick, blurb) => {
     const ptr = call("libgobject-2.0.so.0", "g_param_spec_double", [
         {
@@ -1391,6 +1814,18 @@ export const paramSpecDouble = (name, minimum, maximum, defaultValue, flags, nic
     ], { type: "gobject", borrowed: true });
     return getObject(ptr, ParamSpec);
 };
+/**
+ * Creates a new #GParamSpecEnum instance specifying a %G_TYPE_ENUM
+ * property.
+ *
+ * See g_param_spec_internal() for details on property names.
+ * @param name - canonical name of the property specified
+ * @param nick - nick name for the property specified
+ * @param blurb - description of the property specified
+ * @param enumType - a #GType derived from %G_TYPE_ENUM
+ * @param defaultValue - default value for the property specified
+ * @param flags - flags for the property specified
+ */
 export const paramSpecEnum = (name, enumType, defaultValue, flags, nick, blurb) => {
     const ptr = call("libgobject-2.0.so.0", "g_param_spec_enum", [
         {
@@ -1422,6 +1857,18 @@ export const paramSpecEnum = (name, enumType, defaultValue, flags, nick, blurb)
     ], { type: "gobject", borrowed: true });
     return getObject(ptr, ParamSpec);
 };
+/**
+ * Creates a new #GParamSpecFlags instance specifying a %G_TYPE_FLAGS
+ * property.
+ *
+ * See g_param_spec_internal() for details on property names.
+ * @param name - canonical name of the property specified
+ * @param nick - nick name for the property specified
+ * @param blurb - description of the property specified
+ * @param flagsType - a #GType derived from %G_TYPE_FLAGS
+ * @param defaultValue - default value for the property specified
+ * @param flags - flags for the property specified
+ */
 export const paramSpecFlags = (name, flagsType, defaultValue, flags, nick, blurb) => {
     const ptr = call("libgobject-2.0.so.0", "g_param_spec_flags", [
         {
@@ -1453,6 +1900,18 @@ export const paramSpecFlags = (name, flagsType, defaultValue, flags, nick, blurb
     ], { type: "gobject", borrowed: true });
     return getObject(ptr, ParamSpec);
 };
+/**
+ * Creates a new #GParamSpecFloat instance specifying a %G_TYPE_FLOAT property.
+ *
+ * See g_param_spec_internal() for details on property names.
+ * @param name - canonical name of the property specified
+ * @param nick - nick name for the property specified
+ * @param blurb - description of the property specified
+ * @param minimum - minimum value for the property specified
+ * @param maximum - maximum value for the property specified
+ * @param defaultValue - default value for the property specified
+ * @param flags - flags for the property specified
+ */
 export const paramSpecFloat = (name, minimum, maximum, defaultValue, flags, nick, blurb) => {
     const ptr = call("libgobject-2.0.so.0", "g_param_spec_float", [
         {
@@ -1488,6 +1947,17 @@ export const paramSpecFloat = (name, minimum, maximum, defaultValue, flags, nick
     ], { type: "gobject", borrowed: true });
     return getObject(ptr, ParamSpec);
 };
+/**
+ * Creates a new #GParamSpecGType instance specifying a
+ * %G_TYPE_GTYPE property.
+ *
+ * See g_param_spec_internal() for details on property names.
+ * @param name - canonical name of the property specified
+ * @param nick - nick name for the property specified
+ * @param blurb - description of the property specified
+ * @param isAType - a #GType whose subtypes are allowed as values
+ * @param flags - flags for the property specified
+ */
 export const paramSpecGtype = (name, isAType, flags, nick, blurb) => {
     const ptr = call("libgobject-2.0.so.0", "g_param_spec_gtype", [
         {
@@ -1515,6 +1985,18 @@ export const paramSpecGtype = (name, isAType, flags, nick, blurb) => {
     ], { type: "gobject", borrowed: true });
     return getObject(ptr, ParamSpec);
 };
+/**
+ * Creates a new #GParamSpecInt instance specifying a %G_TYPE_INT property.
+ *
+ * See g_param_spec_internal() for details on property names.
+ * @param name - canonical name of the property specified
+ * @param nick - nick name for the property specified
+ * @param blurb - description of the property specified
+ * @param minimum - minimum value for the property specified
+ * @param maximum - maximum value for the property specified
+ * @param defaultValue - default value for the property specified
+ * @param flags - flags for the property specified
+ */
 export const paramSpecInt = (name, minimum, maximum, defaultValue, flags, nick, blurb) => {
     const ptr = call("libgobject-2.0.so.0", "g_param_spec_int", [
         {
@@ -1550,6 +2032,18 @@ export const paramSpecInt = (name, minimum, maximum, defaultValue, flags, nick,
     ], { type: "gobject", borrowed: true });
     return getObject(ptr, ParamSpec);
 };
+/**
+ * Creates a new #GParamSpecInt64 instance specifying a %G_TYPE_INT64 property.
+ *
+ * See g_param_spec_internal() for details on property names.
+ * @param name - canonical name of the property specified
+ * @param nick - nick name for the property specified
+ * @param blurb - description of the property specified
+ * @param minimum - minimum value for the property specified
+ * @param maximum - maximum value for the property specified
+ * @param defaultValue - default value for the property specified
+ * @param flags - flags for the property specified
+ */
 export const paramSpecInt64 = (name, minimum, maximum, defaultValue, flags, nick, blurb) => {
     const ptr = call("libgobject-2.0.so.0", "g_param_spec_int64", [
         {
@@ -1585,6 +2079,18 @@ export const paramSpecInt64 = (name, minimum, maximum, defaultValue, flags, nick
     ], { type: "gobject", borrowed: true });
     return getObject(ptr, ParamSpec);
 };
+/**
+ * Creates a new #GParamSpecLong instance specifying a %G_TYPE_LONG property.
+ *
+ * See g_param_spec_internal() for details on property names.
+ * @param name - canonical name of the property specified
+ * @param nick - nick name for the property specified
+ * @param blurb - description of the property specified
+ * @param minimum - minimum value for the property specified
+ * @param maximum - maximum value for the property specified
+ * @param defaultValue - default value for the property specified
+ * @param flags - flags for the property specified
+ */
 export const paramSpecLong = (name, minimum, maximum, defaultValue, flags, nick, blurb) => {
     const ptr = call("libgobject-2.0.so.0", "g_param_spec_long", [
         {
@@ -1620,6 +2126,17 @@ export const paramSpecLong = (name, minimum, maximum, defaultValue, flags, nick,
     ], { type: "gobject", borrowed: true });
     return getObject(ptr, ParamSpec);
 };
+/**
+ * Creates a new #GParamSpecBoxed instance specifying a %G_TYPE_OBJECT
+ * derived property.
+ *
+ * See g_param_spec_internal() for details on property names.
+ * @param name - canonical name of the property specified
+ * @param nick - nick name for the property specified
+ * @param blurb - description of the property specified
+ * @param objectType - %G_TYPE_OBJECT derived type of this property
+ * @param flags - flags for the property specified
+ */
 export const paramSpecObject = (name, objectType, flags, nick, blurb) => {
     const ptr = call("libgobject-2.0.so.0", "g_param_spec_object", [
         {
@@ -1647,6 +2164,17 @@ export const paramSpecObject = (name, objectType, flags, nick, blurb) => {
     ], { type: "gobject", borrowed: true });
     return getObject(ptr, ParamSpec);
 };
+/**
+ * Creates a new #GParamSpecParam instance specifying a %G_TYPE_PARAM
+ * property.
+ *
+ * See g_param_spec_internal() for details on property names.
+ * @param name - canonical name of the property specified
+ * @param nick - nick name for the property specified
+ * @param blurb - description of the property specified
+ * @param paramType - a #GType derived from %G_TYPE_PARAM
+ * @param flags - flags for the property specified
+ */
 export const paramSpecParam = (name, paramType, flags, nick, blurb) => {
     const ptr = call("libgobject-2.0.so.0", "g_param_spec_param", [
         {
@@ -1674,6 +2202,17 @@ export const paramSpecParam = (name, paramType, flags, nick, blurb) => {
     ], { type: "gobject", borrowed: true });
     return getObject(ptr, ParamSpec);
 };
+/**
+ * Creates a new #GParamSpecPointer instance specifying a pointer property.
+ * Where possible, it is better to use g_param_spec_object() or
+ * g_param_spec_boxed() to expose memory management information.
+ *
+ * See g_param_spec_internal() for details on property names.
+ * @param name - canonical name of the property specified
+ * @param nick - nick name for the property specified
+ * @param blurb - description of the property specified
+ * @param flags - flags for the property specified
+ */
 export const paramSpecPointer = (name, flags, nick, blurb) => {
     const ptr = call("libgobject-2.0.so.0", "g_param_spec_pointer", [
         {
@@ -1697,6 +2236,16 @@ export const paramSpecPointer = (name, flags, nick, blurb) => {
     ], { type: "gobject", borrowed: true });
     return getObject(ptr, ParamSpec);
 };
+/**
+ * Creates a new #GParamSpecString instance.
+ *
+ * See g_param_spec_internal() for details on property names.
+ * @param name - canonical name of the property specified
+ * @param nick - nick name for the property specified
+ * @param blurb - description of the property specified
+ * @param defaultValue - default value for the property specified
+ * @param flags - flags for the property specified
+ */
 export const paramSpecString = (name, flags, nick, blurb, defaultValue) => {
     const ptr = call("libgobject-2.0.so.0", "g_param_spec_string", [
         {
@@ -1725,6 +2274,16 @@ export const paramSpecString = (name, flags, nick, blurb, defaultValue) => {
     ], { type: "gobject", borrowed: true });
     return getObject(ptr, ParamSpec);
 };
+/**
+ * Creates a new #GParamSpecUChar instance specifying a %G_TYPE_UCHAR property.
+ * @param name - canonical name of the property specified
+ * @param nick - nick name for the property specified
+ * @param blurb - description of the property specified
+ * @param minimum - minimum value for the property specified
+ * @param maximum - maximum value for the property specified
+ * @param defaultValue - default value for the property specified
+ * @param flags - flags for the property specified
+ */
 export const paramSpecUchar = (name, minimum, maximum, defaultValue, flags, nick, blurb) => {
     const ptr = call("libgobject-2.0.so.0", "g_param_spec_uchar", [
         {
@@ -1760,6 +2319,18 @@ export const paramSpecUchar = (name, minimum, maximum, defaultValue, flags, nick
     ], { type: "gobject", borrowed: true });
     return getObject(ptr, ParamSpec);
 };
+/**
+ * Creates a new #GParamSpecUInt instance specifying a %G_TYPE_UINT property.
+ *
+ * See g_param_spec_internal() for details on property names.
+ * @param name - canonical name of the property specified
+ * @param nick - nick name for the property specified
+ * @param blurb - description of the property specified
+ * @param minimum - minimum value for the property specified
+ * @param maximum - maximum value for the property specified
+ * @param defaultValue - default value for the property specified
+ * @param flags - flags for the property specified
+ */
 export const paramSpecUint = (name, minimum, maximum, defaultValue, flags, nick, blurb) => {
     const ptr = call("libgobject-2.0.so.0", "g_param_spec_uint", [
         {
@@ -1795,6 +2366,19 @@ export const paramSpecUint = (name, minimum, maximum, defaultValue, flags, nick,
     ], { type: "gobject", borrowed: true });
     return getObject(ptr, ParamSpec);
 };
+/**
+ * Creates a new #GParamSpecUInt64 instance specifying a %G_TYPE_UINT64
+ * property.
+ *
+ * See g_param_spec_internal() for details on property names.
+ * @param name - canonical name of the property specified
+ * @param nick - nick name for the property specified
+ * @param blurb - description of the property specified
+ * @param minimum - minimum value for the property specified
+ * @param maximum - maximum value for the property specified
+ * @param defaultValue - default value for the property specified
+ * @param flags - flags for the property specified
+ */
 export const paramSpecUint64 = (name, minimum, maximum, defaultValue, flags, nick, blurb) => {
     const ptr = call("libgobject-2.0.so.0", "g_param_spec_uint64", [
         {
@@ -1830,6 +2414,19 @@ export const paramSpecUint64 = (name, minimum, maximum, defaultValue, flags, nic
     ], { type: "gobject", borrowed: true });
     return getObject(ptr, ParamSpec);
 };
+/**
+ * Creates a new #GParamSpecULong instance specifying a %G_TYPE_ULONG
+ * property.
+ *
+ * See g_param_spec_internal() for details on property names.
+ * @param name - canonical name of the property specified
+ * @param nick - nick name for the property specified
+ * @param blurb - description of the property specified
+ * @param minimum - minimum value for the property specified
+ * @param maximum - maximum value for the property specified
+ * @param defaultValue - default value for the property specified
+ * @param flags - flags for the property specified
+ */
 export const paramSpecUlong = (name, minimum, maximum, defaultValue, flags, nick, blurb) => {
     const ptr = call("libgobject-2.0.so.0", "g_param_spec_ulong", [
         {
@@ -1865,6 +2462,18 @@ export const paramSpecUlong = (name, minimum, maximum, defaultValue, flags, nick
     ], { type: "gobject", borrowed: true });
     return getObject(ptr, ParamSpec);
 };
+/**
+ * Creates a new #GParamSpecUnichar instance specifying a %G_TYPE_UINT
+ * property. #GValue structures for this property can be accessed with
+ * g_value_set_uint() and g_value_get_uint().
+ *
+ * See g_param_spec_internal() for details on property names.
+ * @param name - canonical name of the property specified
+ * @param nick - nick name for the property specified
+ * @param blurb - description of the property specified
+ * @param defaultValue - default value for the property specified
+ * @param flags - flags for the property specified
+ */
 export const paramSpecUnichar = (name, defaultValue, flags, nick, blurb) => {
     const ptr = call("libgobject-2.0.so.0", "g_param_spec_unichar", [
         {
@@ -1892,6 +2501,20 @@ export const paramSpecUnichar = (name, defaultValue, flags, nick, blurb) => {
     ], { type: "gobject", borrowed: true });
     return getObject(ptr, ParamSpec);
 };
+/**
+ * Creates a new #GParamSpecVariant instance specifying a #GVariant
+ * property.
+ *
+ * If `default_value` is floating, it is consumed.
+ *
+ * See g_param_spec_internal() for details on property names.
+ * @param name - canonical name of the property specified
+ * @param nick - nick name for the property specified
+ * @param blurb - description of the property specified
+ * @param type - a #GVariantType
+ * @param defaultValue - a #GVariant of type `type` to
+ * @param flags - flags for the property specified
+ */
 export const paramSpecVariant = (name, type, flags, nick, blurb, defaultValue) => {
     const ptr = call("libgobject-2.0.so.0", "g_param_spec_variant", [
         {
@@ -1933,6 +2556,16 @@ export const paramSpecVariant = (name, type, flags, nick, blurb, defaultValue) =
     ], { type: "gobject", borrowed: true });
     return getObject(ptr, ParamSpec);
 };
+/**
+ * Registers `name` as the name of a new static type derived
+ * from %G_TYPE_PARAM.
+ *
+ * The type system uses the information contained in the #GParamSpecTypeInfo
+ * structure pointed to by `info` to manage the #GParamSpec type and its
+ * instances.
+ * @param name - 0-terminated string used as the name of the new #GParamSpec type.
+ * @param pspecInfo - The #GParamSpecTypeInfo for this #GParamSpec type.
+ */
 export const paramTypeRegisterStatic = (name, pspecInfo) => {
     return call("libgobject-2.0.so.0", "g_param_type_register_static", [
         {
@@ -1945,6 +2578,19 @@ export const paramTypeRegisterStatic = (name, pspecInfo) => {
         },
     ], { type: "int", size: 64, unsigned: true });
 };
+/**
+ * Transforms `src_value` into `dest_value` if possible, and then
+ * validates @dest_value, in order for it to conform to @pspec.  If
+ * `strict_validation` is %TRUE this function will only succeed if the
+ * transformed `dest_value` complied to `pspec` without modifications.
+ *
+ * See also g_value_type_transformable(), g_value_transform() and
+ * g_param_value_validate().
+ * @param pspec - a valid #GParamSpec
+ * @param srcValue - source #GValue
+ * @param destValue - destination #GValue of correct type for @pspec
+ * @param strictValidation - %TRUE requires `dest_value` to conform to `pspec` without modifications
+ */
 export const paramValueConvert = (pspec, srcValue, destValue, strictValidation) => {
     return call("libgobject-2.0.so.0", "g_param_value_convert", [
         {
@@ -1975,6 +2621,11 @@ export const paramValueConvert = (pspec, srcValue, destValue, strictValidation)
         },
     ], { type: "boolean" });
 };
+/**
+ * Checks whether `value` contains the default value as specified in @pspec.
+ * @param pspec - a valid #GParamSpec
+ * @param value - a #GValue of correct type for @pspec
+ */
 export const paramValueDefaults = (pspec, value) => {
     return call("libgobject-2.0.so.0", "g_param_value_defaults", [
         {
@@ -1992,6 +2643,12 @@ export const paramValueDefaults = (pspec, value) => {
         },
     ], { type: "boolean" });
 };
+/**
+ * Return whether the contents of `value` comply with the specifications
+ * set out by @pspec.
+ * @param pspec - a valid #GParamSpec
+ * @param value - a #GValue of correct type for @pspec
+ */
 export const paramValueIsValid = (pspec, value) => {
     return call("libgobject-2.0.so.0", "g_param_value_is_valid", [
         {
@@ -2009,6 +2666,11 @@ export const paramValueIsValid = (pspec, value) => {
         },
     ], { type: "boolean" });
 };
+/**
+ * Sets `value` to its default value as specified in @pspec.
+ * @param pspec - a valid #GParamSpec
+ * @param value - a #GValue of correct type for @pspec; since 2.64, you
+ */
 export const paramValueSetDefault = (pspec, value) => {
     call("libgobject-2.0.so.0", "g_param_value_set_default", [
         {
@@ -2026,6 +2688,16 @@ export const paramValueSetDefault = (pspec, value) => {
         },
     ], { type: "undefined" });
 };
+/**
+ * Ensures that the contents of `value` comply with the specifications
+ * set out by @pspec. For example, a #GParamSpecInt might require
+ * that integers stored in `value` may not be smaller than -42 and not be
+ * greater than +42. If `value` contains an integer outside of this range,
+ * it is modified accordingly, so the resulting value will fit into the
+ * range -42 .. +42.
+ * @param pspec - a valid #GParamSpec
+ * @param value - a #GValue of correct type for @pspec
+ */
 export const paramValueValidate = (pspec, value) => {
     return call("libgobject-2.0.so.0", "g_param_value_validate", [
         {
@@ -2043,6 +2715,14 @@ export const paramValueValidate = (pspec, value) => {
         },
     ], { type: "boolean" });
 };
+/**
+ * Compares `value1` with `value2` according to @pspec, and return -1, 0 or +1,
+ * if `value1` is found to be less than, equal to or greater than @value2,
+ * respectively.
+ * @param pspec - a valid #GParamSpec
+ * @param value1 - a #GValue of correct type for @pspec
+ * @param value2 - a #GValue of correct type for @pspec
+ */
 export const paramValuesCmp = (pspec, value1, value2) => {
     return call("libgobject-2.0.so.0", "g_param_values_cmp", [
         {
@@ -2069,6 +2749,11 @@ export const paramValuesCmp = (pspec, value1, value2) => {
         },
     ], { type: "int", size: 32, unsigned: false });
 };
+/**
+ * Creates a new %G_TYPE_POINTER derived type id for a new
+ * pointer type with name @name.
+ * @param name - the name of the new pointer type.
+ */
 export const pointerTypeRegisterStatic = (name) => {
     return call("libgobject-2.0.so.0", "g_pointer_type_register_static", [
         {
@@ -2077,6 +2762,22 @@ export const pointerTypeRegisterStatic = (name) => {
         },
     ], { type: "int", size: 64, unsigned: true });
 };
+/**
+ * A predefined #GSignalAccumulator for signals intended to be used as a
+ * hook for application code to provide a particular value.  Usually
+ * only one such value is desired and multiple handlers for the same
+ * signal don't make much sense (except for the case of the default
+ * handler defined in the class structure, in which case you will
+ * usually want the signal connection to override the class handler).
+ *
+ * This accumulator will use the return value from the first signal
+ * handler that is run as the return value for the signal and not run
+ * any further handlers (ie: the first handler "wins").
+ * @param ihint - standard #GSignalAccumulator parameter
+ * @param returnAccu - standard #GSignalAccumulator parameter
+ * @param handlerReturn - standard #GSignalAccumulator parameter
+ * @param dummy - standard #GSignalAccumulator parameter
+ */
 export const signalAccumulatorFirstWins = (ihint, returnAccu, handlerReturn, dummy) => {
     return call("libgobject-2.0.so.0", "g_signal_accumulator_first_wins", [
         {
@@ -2108,6 +2809,19 @@ export const signalAccumulatorFirstWins = (ihint, returnAccu, handlerReturn, dum
         },
     ], { type: "boolean" });
 };
+/**
+ * A predefined #GSignalAccumulator for signals that return a
+ * boolean values. The behavior that this accumulator gives is
+ * that a return of %TRUE stops the signal emission: no further
+ * callbacks will be invoked, while a return of %FALSE allows
+ * the emission to continue. The idea here is that a %TRUE return
+ * indicates that the callback handled the signal, and no further
+ * handling is needed.
+ * @param ihint - standard #GSignalAccumulator parameter
+ * @param returnAccu - standard #GSignalAccumulator parameter
+ * @param handlerReturn - standard #GSignalAccumulator parameter
+ * @param dummy - standard #GSignalAccumulator parameter
+ */
 export const signalAccumulatorTrueHandled = (ihint, returnAccu, handlerReturn, dummy) => {
     return call("libgobject-2.0.so.0", "g_signal_accumulator_true_handled", [
         {
@@ -2139,6 +2853,16 @@ export const signalAccumulatorTrueHandled = (ihint, returnAccu, handlerReturn, d
         },
     ], { type: "boolean" });
 };
+/**
+ * Adds an emission hook for a signal, which will get called for any emission
+ * of that signal, independent of the instance. This is possible only
+ * for signals which don't have %G_SIGNAL_NO_HOOKS flag set.
+ * @param signalId - the signal identifier, as returned by g_signal_lookup().
+ * @param detail - the detail on which to call the hook.
+ * @param hookFunc - a #GSignalEmissionHook function.
+ * @param hookData - user data for @hook_func.
+ * @param dataDestroy - a #GDestroyNotify for @hook_data.
+ */
 export const signalAddEmissionHook = (signalId, detail, hookFunc, hookData, dataDestroy) => {
     return call("libgobject-2.0.so.0", "g_signal_add_emission_hook", [
         {
@@ -2165,6 +2889,14 @@ export const signalAddEmissionHook = (signalId, detail, hookFunc, hookData, data
         },
     ], { type: "int", size: 64, unsigned: true });
 };
+/**
+ * Calls the original class closure of a signal. This function should only
+ * be called from an overridden class closure; see
+ * g_signal_override_class_closure() and
+ * g_signal_override_class_handler().
+ * @param instanceAndParams - the argument list of the signal emission.
+ * @param returnValue - Location for the return value.
+ */
 export const signalChainFromOverridden = (instanceAndParams, returnValue) => {
     call("libgobject-2.0.so.0", "g_signal_chain_from_overridden", [
         {
@@ -2189,6 +2921,24 @@ export const signalChainFromOverridden = (instanceAndParams, returnValue) => {
         },
     ], { type: "undefined" });
 };
+/**
+ * Connects a closure to a signal for a particular object.
+ *
+ * If `closure` is a floating reference (see g_closure_sink()), this function
+ * takes ownership of @closure.
+ *
+ * This function cannot fail. If the given signal name doesn’t exist,
+ * a critical warning is emitted. No validation is performed on the
+ * ‘detail’ string when specified in @detailed_signal, other than a
+ * non-empty check.
+ *
+ * Refer to the signals documentation for more
+ * details.
+ * @param instance - the instance to connect to.
+ * @param detailedSignal - a string of the form "signal-name::detail".
+ * @param closure - the closure to connect.
+ * @param after - whether the handler should be called before or after the
+ */
 export const signalConnectClosure = (instance, detailedSignal, closure, after) => {
     return call("libgobject-2.0.so.0", "g_signal_connect_closure", [
         {
@@ -2214,6 +2964,25 @@ export const signalConnectClosure = (instance, detailedSignal, closure, after) =
         },
     ], { type: "int", size: 64, unsigned: true });
 };
+/**
+ * Connects a closure to a signal for a particular object.
+ *
+ * If `closure` is a floating reference (see g_closure_sink()), this function
+ * takes ownership of @closure.
+ *
+ * This function cannot fail. If the given signal name doesn’t exist,
+ * a critical warning is emitted. No validation is performed on the
+ * ‘detail’ string when specified in @detailed_signal, other than a
+ * non-empty check.
+ *
+ * Refer to the signals documentation for more
+ * details.
+ * @param instance - the instance to connect to.
+ * @param signalId - the id of the signal.
+ * @param detail - the detail.
+ * @param closure - the closure to connect.
+ * @param after - whether the handler should be called before or after the
+ */
 export const signalConnectClosureById = (instance, signalId, detail, closure, after) => {
     return call("libgobject-2.0.so.0", "g_signal_connect_closure_by_id", [
         {
@@ -2243,6 +3012,17 @@ export const signalConnectClosureById = (instance, signalId, detail, closure, af
         },
     ], { type: "int", size: 64, unsigned: true });
 };
+/**
+ * Emits a signal. Signal emission is done synchronously.
+ * The method will only return control after all handlers are called or signal emission was stopped.
+ *
+ * Note that g_signal_emitv() doesn't change `return_value` if no handlers are
+ * connected, in contrast to g_signal_emit() and g_signal_emit_valist().
+ * @param instanceAndParams - argument list for the signal emission.
+ * @param signalId - the signal id
+ * @param detail - the detail
+ * @param returnValue - Location to
+ */
 export const signalEmitv = (instanceAndParams, signalId, detail, returnValue) => {
     call("libgobject-2.0.so.0", "g_signal_emitv", [
         {
@@ -2277,6 +3057,10 @@ export const signalEmitv = (instanceAndParams, signalId, detail, returnValue) =>
         },
     ], { type: "undefined" });
 };
+/**
+ * Returns the invocation hint of the innermost signal emission of instance.
+ * @param instance - the instance to query
+ */
 export const signalGetInvocationHint = (instance) => {
     return call("libgobject-2.0.so.0", "g_signal_get_invocation_hint", [
         {
@@ -2285,6 +3069,18 @@ export const signalGetInvocationHint = (instance) => {
         },
     ], { type: "int", size: 64, unsigned: true });
 };
+/**
+ * Blocks a handler of an instance so it will not be called during any
+ * signal emissions unless it is unblocked again. Thus "blocking" a
+ * signal handler means to temporarily deactivate it, a signal handler
+ * has to be unblocked exactly the same amount of times it has been
+ * blocked before to become active again.
+ *
+ * The `handler_id` has to be a valid signal handler id, connected to a
+ * signal of @instance.
+ * @param instance - The instance to block the signal handler of.
+ * @param handlerId - Handler id of the handler to be blocked.
+ */
 export const signalHandlerBlock = (instance, handlerId) => {
     call("libgobject-2.0.so.0", "g_signal_handler_block", [
         {
@@ -2297,6 +3093,16 @@ export const signalHandlerBlock = (instance, handlerId) => {
         },
     ], { type: "undefined" });
 };
+/**
+ * Disconnects a handler from an instance so it will not be called during
+ * any future or currently ongoing emissions of the signal it has been
+ * connected to. The `handler_id` becomes invalid and may be reused.
+ *
+ * The `handler_id` has to be a valid signal handler id, connected to a
+ * signal of @instance.
+ * @param instance - The instance to remove the signal handler from.
+ * @param handlerId - Handler id of the handler to be disconnected.
+ */
 export const signalHandlerDisconnect = (instance, handlerId) => {
     call("libgobject-2.0.so.0", "g_signal_handler_disconnect", [
         {
@@ -2309,6 +3115,20 @@ export const signalHandlerDisconnect = (instance, handlerId) => {
         },
     ], { type: "undefined" });
 };
+/**
+ * Finds the first signal handler that matches certain selection criteria.
+ * The criteria mask is passed as an OR-ed combination of #GSignalMatchType
+ * flags, and the criteria values are passed as arguments.
+ * The match `mask` has to be non-0 for successful matches.
+ * If no handler was found, 0 is returned.
+ * @param instance - The instance owning the signal handler to be found.
+ * @param mask - Mask indicating which of @signal_id, @detail, @closure, `func`  and/or `data` the handler has to match.
+ * @param signalId - Signal the handler has to be connected to.
+ * @param detail - Signal detail the handler has to be connected to.
+ * @param closure - The closure the handler will invoke.
+ * @param func - The C closure callback of the handler (useless for non-C closures).
+ * @param data - The closure data of the handler's closure.
+ */
 export const signalHandlerFind = (instance, mask, signalId, detail, closure, func, data) => {
     return call("libgobject-2.0.so.0", "g_signal_handler_find", [
         {
@@ -2349,6 +3169,11 @@ export const signalHandlerFind = (instance, mask, signalId, detail, closure, fun
         },
     ], { type: "int", size: 64, unsigned: true });
 };
+/**
+ * Returns whether `handler_id` is the ID of a handler connected to @instance.
+ * @param instance - The instance where a signal handler is sought.
+ * @param handlerId - the handler ID.
+ */
 export const signalHandlerIsConnected = (instance, handlerId) => {
     return call("libgobject-2.0.so.0", "g_signal_handler_is_connected", [
         {
@@ -2361,6 +3186,23 @@ export const signalHandlerIsConnected = (instance, handlerId) => {
         },
     ], { type: "boolean" });
 };
+/**
+ * Undoes the effect of a previous g_signal_handler_block() call.  A
+ * blocked handler is skipped during signal emissions and will not be
+ * invoked, unblocking it (for exactly the amount of times it has been
+ * blocked before) reverts its "blocked" state, so the handler will be
+ * recognized by the signal system and is called upon future or
+ * currently ongoing signal emissions (since the order in which
+ * handlers are called during signal emissions is deterministic,
+ * whether the unblocked handler in question is called as part of a
+ * currently ongoing emission depends on how far that emission has
+ * proceeded yet).
+ *
+ * The `handler_id` has to be a valid id of a signal handler that is
+ * connected to a signal of `instance` and is currently blocked.
+ * @param instance - The instance to unblock the signal handler of.
+ * @param handlerId - Handler id of the handler to be unblocked.
+ */
 export const signalHandlerUnblock = (instance, handlerId) => {
     call("libgobject-2.0.so.0", "g_signal_handler_unblock", [
         {
@@ -2373,6 +3215,28 @@ export const signalHandlerUnblock = (instance, handlerId) => {
         },
     ], { type: "undefined" });
 };
+/**
+ * Blocks all handlers on an instance that match a certain selection criteria.
+ *
+ * The criteria mask is passed as a combination of #GSignalMatchType flags, and
+ * the criteria values are passed as arguments. A handler must match on all
+ * flags set in `mask` to be blocked (i.e. the match is conjunctive).
+ *
+ * Passing at least one of the %G_SIGNAL_MATCH_ID, %G_SIGNAL_MATCH_CLOSURE,
+ * %G_SIGNAL_MATCH_FUNC
+ * or %G_SIGNAL_MATCH_DATA match flags is required for successful matches.
+ * If no handlers were found, 0 is returned, the number of blocked handlers
+ * otherwise.
+ *
+ * Support for %G_SIGNAL_MATCH_ID was added in GLib 2.78.
+ * @param instance - The instance to block handlers from.
+ * @param mask - Mask indicating which of @signal_id, @detail, @closure, `func`  and/or `data` the handlers have to match.
+ * @param signalId - Signal the handlers have to be connected to.
+ * @param detail - Signal detail the handlers have to be connected to.
+ * @param closure - The closure the handlers will invoke.
+ * @param func - The C closure callback of the handlers (useless for non-C closures).
+ * @param data - The closure data of the handlers' closures.
+ */
 export const signalHandlersBlockMatched = (instance, mask, signalId, detail, closure, func, data) => {
     return call("libgobject-2.0.so.0", "g_signal_handlers_block_matched", [
         {
@@ -2413,6 +3277,12 @@ export const signalHandlersBlockMatched = (instance, mask, signalId, detail, clo
         },
     ], { type: "int", size: 32, unsigned: true });
 };
+/**
+ * Destroy all signal handlers of a type instance. This function is
+ * an implementation detail of the #GObject dispose implementation,
+ * and should not be used outside of the type system.
+ * @param instance - The instance whose signal handlers are destroyed
+ */
 export const signalHandlersDestroy = (instance) => {
     call("libgobject-2.0.so.0", "g_signal_handlers_destroy", [
         {
@@ -2421,6 +3291,29 @@ export const signalHandlersDestroy = (instance) => {
         },
     ], { type: "undefined" });
 };
+/**
+ * Disconnects all handlers on an instance that match a certain
+ * selection criteria.
+ *
+ * The criteria mask is passed as a combination of #GSignalMatchType flags, and
+ * the criteria values are passed as arguments. A handler must match on all
+ * flags set in `mask` to be disconnected (i.e. the match is conjunctive).
+ *
+ * Passing at least one of the %G_SIGNAL_MATCH_ID, %G_SIGNAL_MATCH_CLOSURE,
+ * %G_SIGNAL_MATCH_FUNC or
+ * %G_SIGNAL_MATCH_DATA match flags is required for successful
+ * matches.  If no handlers were found, 0 is returned, the number of
+ * disconnected handlers otherwise.
+ *
+ * Support for %G_SIGNAL_MATCH_ID was added in GLib 2.78.
+ * @param instance - The instance to remove handlers from.
+ * @param mask - Mask indicating which of @signal_id, @detail, @closure, `func`  and/or `data` the handlers have to match.
+ * @param signalId - Signal the handlers have to be connected to.
+ * @param detail - Signal detail the handlers have to be connected to.
+ * @param closure - The closure the handlers will invoke.
+ * @param func - The C closure callback of the handlers (useless for non-C closures).
+ * @param data - The closure data of the handlers' closures.
+ */
 export const signalHandlersDisconnectMatched = (instance, mask, signalId, detail, closure, func, data) => {
     return call("libgobject-2.0.so.0", "g_signal_handlers_disconnect_matched", [
         {
@@ -2461,6 +3354,30 @@ export const signalHandlersDisconnectMatched = (instance, mask, signalId, detail
         },
     ], { type: "int", size: 32, unsigned: true });
 };
+/**
+ * Unblocks all handlers on an instance that match a certain selection
+ * criteria.
+ *
+ * The criteria mask is passed as a combination of #GSignalMatchType flags, and
+ * the criteria values are passed as arguments. A handler must match on all
+ * flags set in `mask` to be unblocked (i.e. the match is conjunctive).
+ *
+ * Passing at least one of the %G_SIGNAL_MATCH_ID, %G_SIGNAL_MATCH_CLOSURE,
+ * %G_SIGNAL_MATCH_FUNC
+ * or %G_SIGNAL_MATCH_DATA match flags is required for successful matches.
+ * If no handlers were found, 0 is returned, the number of unblocked handlers
+ * otherwise. The match criteria should not apply to any handlers that are
+ * not currently blocked.
+ *
+ * Support for %G_SIGNAL_MATCH_ID was added in GLib 2.78.
+ * @param instance - The instance to unblock handlers from.
+ * @param mask - Mask indicating which of @signal_id, @detail, @closure, `func`  and/or `data` the handlers have to match.
+ * @param signalId - Signal the handlers have to be connected to.
+ * @param detail - Signal detail the handlers have to be connected to.
+ * @param closure - The closure the handlers will invoke.
+ * @param func - The C closure callback of the handlers (useless for non-C closures).
+ * @param data - The closure data of the handlers' closures.
+ */
 export const signalHandlersUnblockMatched = (instance, mask, signalId, detail, closure, func, data) => {
     return call("libgobject-2.0.so.0", "g_signal_handlers_unblock_matched", [
         {
@@ -2501,6 +3418,28 @@ export const signalHandlersUnblockMatched = (instance, mask, signalId, detail, c
         },
     ], { type: "int", size: 32, unsigned: true });
 };
+/**
+ * Returns whether there are any handlers connected to `instance` for the
+ * given signal id and detail.
+ *
+ * If `detail` is 0 then it will only match handlers that were connected
+ * without detail.  If `detail` is non-zero then it will match handlers
+ * connected both without detail and with the given detail.  This is
+ * consistent with how a signal emitted with `detail` would be delivered
+ * to those handlers.
+ *
+ * Since 2.46 this also checks for a non-default class closure being
+ * installed, as this is basically always what you want.
+ *
+ * One example of when you might use this is when the arguments to the
+ * signal are difficult to compute. A class implementor may opt to not
+ * emit the signal if no one is attached anyway, thus saving the cost
+ * of building the arguments.
+ * @param instance - the object whose signal handlers are sought.
+ * @param signalId - the signal id.
+ * @param detail - the detail.
+ * @param mayBeBlocked - whether blocked handlers should count as match.
+ */
 export const signalHasHandlerPending = (instance, signalId, detail, mayBeBlocked) => {
     return call("libgobject-2.0.so.0", "g_signal_has_handler_pending", [
         {
@@ -2521,6 +3460,14 @@ export const signalHasHandlerPending = (instance, signalId, detail, mayBeBlocked
         },
     ], { type: "boolean" });
 };
+/**
+ * Validate a signal name. This can be useful for dynamically-generated signals
+ * which need to be validated at run-time before actually trying to create them.
+ *
+ * See [func@GObject.signal_new] for details of the rules for valid names.
+ * The rules for signal names are the same as those for property names.
+ * @param name - the canonical name of the signal
+ */
 export const signalIsValidName = (name) => {
     return call("libgobject-2.0.so.0", "g_signal_is_valid_name", [
         {
@@ -2529,6 +3476,13 @@ export const signalIsValidName = (name) => {
         },
     ], { type: "boolean" });
 };
+/**
+ * Lists the signals by id that a certain instance or interface type
+ * created. Further information about the signals can be acquired through
+ * g_signal_query().
+ * @param itype - Instance or interface type.
+ * @param nIds - Location to store the number of signal ids for @itype.
+ */
 export const signalListIds = (itype, nIds) => {
     return call("libgobject-2.0.so.0", "g_signal_list_ids", [
         {
@@ -2544,6 +3498,21 @@ export const signalListIds = (itype, nIds) => {
         },
     ], { type: "array", itemType: { type: "int", size: 32, unsigned: true } });
 };
+/**
+ * Given the name of the signal and the type of object it connects to, gets
+ * the signal's identifying integer. Emitting the signal by number is
+ * somewhat faster than using the name each time.
+ *
+ * Also tries the ancestors of the given type.
+ *
+ * The type class passed as `itype` must already have been instantiated (for
+ * example, using g_type_class_ref()) for this function to work, as signals are
+ * always installed during class initialization.
+ *
+ * See g_signal_new() for details on allowed signal names.
+ * @param name - the signal's name.
+ * @param itype - the type that the signal operates on.
+ */
 export const signalLookup = (name, itype) => {
     return call("libgobject-2.0.so.0", "g_signal_lookup", [
         {
@@ -2556,6 +3525,12 @@ export const signalLookup = (name, itype) => {
         },
     ], { type: "int", size: 32, unsigned: true });
 };
+/**
+ * Given the signal's identifier, finds its name.
+ *
+ * Two different signals may have the same name, if they have differing types.
+ * @param signalId - the signal's identifying number.
+ */
 export const signalName = (signalId) => {
     return call("libgobject-2.0.so.0", "g_signal_name", [
         {
@@ -2564,6 +3539,18 @@ export const signalName = (signalId) => {
         },
     ], { type: "string", borrowed: true });
 };
+/**
+ * Overrides the class closure (i.e. the default handler) for the given signal
+ * for emissions on instances of @instance_type. `instance_type` must be derived
+ * from the type to which the signal belongs.
+ *
+ * See g_signal_chain_from_overridden() and
+ * g_signal_chain_from_overridden_handler() for how to chain up to the
+ * parent class closure from inside the overridden one.
+ * @param signalId - the signal id
+ * @param instanceType - the instance type on which to override the class closure
+ * @param classClosure - the closure.
+ */
 export const signalOverrideClassClosure = (signalId, instanceType, classClosure) => {
     call("libgobject-2.0.so.0", "g_signal_override_class_closure", [
         {
@@ -2585,6 +3572,19 @@ export const signalOverrideClassClosure = (signalId, instanceType, classClosure)
         },
     ], { type: "undefined" });
 };
+/**
+ * Overrides the class closure (i.e. the default handler) for the
+ * given signal for emissions on instances of `instance_type` with
+ * callback @class_handler. `instance_type` must be derived from the
+ * type to which the signal belongs.
+ *
+ * See g_signal_chain_from_overridden() and
+ * g_signal_chain_from_overridden_handler() for how to chain up to the
+ * parent class closure from inside the overridden one.
+ * @param signalName - the name for the signal
+ * @param instanceType - the instance type on which to override the class handler
+ * @param classHandler - the handler.
+ */
 export const signalOverrideClassHandler = (signalName, instanceType, classHandler) => {
     call("libgobject-2.0.so.0", "g_signal_override_class_handler", [
         {
@@ -2601,6 +3601,14 @@ export const signalOverrideClassHandler = (signalName, instanceType, classHandle
         },
     ], { type: "undefined" });
 };
+/**
+ * Internal function to parse a signal name into its `signal_id` and `detail` quark.
+ * @param detailedSignal - a string of the form "signal-name::detail".
+ * @param itype - The interface/instance type that introduced "signal-name".
+ * @param signalIdP - Location to store the signal id.
+ * @param detailP - Location to store the detail quark.
+ * @param forceDetailQuark - %TRUE forces creation of a #GQuark for the detail.
+ */
 export const signalParseName = (detailedSignal, itype, signalIdP, detailP, forceDetailQuark) => {
     return call("libgobject-2.0.so.0", "g_signal_parse_name", [
         {
@@ -2631,6 +3639,16 @@ export const signalParseName = (detailedSignal, itype, signalIdP, detailP, force
         },
     ], { type: "boolean" });
 };
+/**
+ * Queries the signal system for in-depth information about a
+ * specific signal. This function will fill in a user-provided
+ * structure to hold signal-specific information. If an invalid
+ * signal id is passed in, the `signal_id` member of the #GSignalQuery
+ * is 0. All members filled into the #GSignalQuery structure should
+ * be considered constant and have to be left untouched.
+ * @param signalId - The signal id of the signal to query information for.
+ * @param query - A user provided structure that is
+ */
 export const signalQuery = (signalId, query) => {
     call("libgobject-2.0.so.0", "g_signal_query", [
         {
@@ -2646,6 +3664,11 @@ export const signalQuery = (signalId, query) => {
         },
     ], { type: "undefined" });
 };
+/**
+ * Deletes an emission hook.
+ * @param signalId - the id of the signal
+ * @param hookId - the id of the emission hook, as returned by
+ */
 export const signalRemoveEmissionHook = (signalId, hookId) => {
     call("libgobject-2.0.so.0", "g_signal_remove_emission_hook", [
         {
@@ -2658,6 +3681,18 @@ export const signalRemoveEmissionHook = (signalId, hookId) => {
         },
     ], { type: "undefined" });
 };
+/**
+ * Stops a signal's current emission.
+ *
+ * This will prevent the default method from running, if the signal was
+ * %G_SIGNAL_RUN_LAST and you connected normally (i.e. without the "after"
+ * flag).
+ *
+ * Prints a warning if used on a signal which isn't being emitted.
+ * @param instance - the object whose signal handlers you wish to stop.
+ * @param signalId - the signal identifier, as returned by g_signal_lookup().
+ * @param detail - the detail which the signal was emitted with.
+ */
 export const signalStopEmission = (instance, signalId, detail) => {
     call("libgobject-2.0.so.0", "g_signal_stop_emission", [
         {
@@ -2674,6 +3709,14 @@ export const signalStopEmission = (instance, signalId, detail) => {
         },
     ], { type: "undefined" });
 };
+/**
+ * Stops a signal's current emission.
+ *
+ * This is just like g_signal_stop_emission() except it will look up the
+ * signal id for you.
+ * @param instance - the object whose signal handlers you wish to stop.
+ * @param detailedSignal - a string of the form "signal-name::detail".
+ */
 export const signalStopEmissionByName = (instance, detailedSignal) => {
     call("libgobject-2.0.so.0", "g_signal_stop_emission_by_name", [
         {
@@ -2686,6 +3729,13 @@ export const signalStopEmissionByName = (instance, detailedSignal) => {
         },
     ], { type: "undefined" });
 };
+/**
+ * Creates a new closure which invokes the function found at the offset
+ * `struct_offset` in the class structure of the interface or classed type
+ * identified by @itype.
+ * @param itype - the #GType identifier of an interface or classed type
+ * @param structOffset - the offset of the member function of @itype's class
+ */
 export const signalTypeCclosureNew = (itype, structOffset) => {
     const ptr = call("libgobject-2.0.so.0", "g_signal_type_cclosure_new", [
         {
@@ -2704,6 +3754,14 @@ export const signalTypeCclosureNew = (itype, structOffset) => {
     });
     return getObject(ptr, Closure);
 };
+/**
+ * Set the callback for a source as a #GClosure.
+ *
+ * If the source is not one of the standard GLib types, the `closure_callback` and `closure_marshal` fields of the #GSourceFuncs structure must have been
+ * filled in with pointers to appropriate functions.
+ * @param source - the source
+ * @param closure - a #GClosure
+ */
 export const sourceSetClosure = (source, closure) => {
     call("libgobject-2.0.so.0", "g_source_set_closure", [
         {
@@ -2726,6 +3784,19 @@ export const sourceSetClosure = (source, closure) => {
         },
     ], { type: "undefined" });
 };
+/**
+ * Sets a dummy callback for @source. The callback will do nothing, and
+ * if the source expects a #gboolean return value, it will return %TRUE.
+ * (If the source expects any other type of return value, it will return
+ * a 0/%NULL value; whatever g_value_init() initializes a #GValue to for
+ * that type.)
+ *
+ * If the source is not one of the standard GLib types, the
+ * `closure_callback` and `closure_marshal` fields of the #GSourceFuncs
+ * structure must have been filled in with pointers to appropriate
+ * functions.
+ * @param source - the source
+ */
 export const sourceSetDummyCallback = (source) => {
     call("libgobject-2.0.so.0", "g_source_set_dummy_callback", [
         {
@@ -2739,6 +3810,13 @@ export const sourceSetDummyCallback = (source) => {
         },
     ], { type: "undefined" });
 };
+/**
+ * Return a newly allocated string, which describes the contents of a
+ * #GValue.  The main purpose of this function is to describe #GValue
+ * contents for debugging output, the way in which the contents are
+ * described may change between different GLib versions.
+ * @param value - #GValue which contents are to be described.
+ */
 export const strdupValueContents = (value) => {
     return call("libgobject-2.0.so.0", "g_strdup_value_contents", [
         {
@@ -2752,6 +3830,20 @@ export const strdupValueContents = (value) => {
         },
     ], { type: "string" });
 };
+/**
+ * Registers a private class structure for a classed type;
+ * when the class is allocated, the private structures for
+ * the class and all of its parent types are allocated
+ * sequentially in the same memory block as the public
+ * structures, and are zero-filled.
+ *
+ * This function should be called in the
+ * type's get_type() function after the type is registered.
+ * The private structure can be retrieved using the
+ * G_TYPE_CLASS_GET_PRIVATE() macro.
+ * @param classType - GType of a classed type
+ * @param privateSize - size of private structure
+ */
 export const typeAddClassPrivate = (classType, privateSize) => {
     call("libgobject-2.0.so.0", "g_type_add_class_private", [
         {
@@ -2776,6 +3868,13 @@ export const typeAddInstancePrivate = (classType, privateSize) => {
         },
     ], { type: "int", size: 32, unsigned: false });
 };
+/**
+ * Adds `interface_type` to the dynamic @instance_type. The information
+ * contained in the #GTypePlugin structure pointed to by `plugin` is used to manage the relationship.
+ * @param instanceType - #GType value of an instantiatable type
+ * @param interfaceType - #GType value of an interface type
+ * @param plugin - #GTypePlugin structure to retrieve the #GInterfaceInfo from
+ */
 export const typeAddInterfaceDynamic = (instanceType, interfaceType, plugin) => {
     call("libgobject-2.0.so.0", "g_type_add_interface_dynamic", [
         {
@@ -2792,6 +3891,14 @@ export const typeAddInterfaceDynamic = (instanceType, interfaceType, plugin) =>
         },
     ], { type: "undefined" });
 };
+/**
+ * Adds `interface_type` to the static @instance_type.
+ * The information contained in the #GInterfaceInfo structure
+ * pointed to by `info` is used to manage the relationship.
+ * @param instanceType - #GType value of an instantiatable type
+ * @param interfaceType - #GType value of an interface type
+ * @param info - #GInterfaceInfo structure for this
+ */
 export const typeAddInterfaceStatic = (instanceType, interfaceType, info) => {
     call("libgobject-2.0.so.0", "g_type_add_interface_static", [
         {
@@ -2820,6 +3927,11 @@ export const typeCheckClassIsA = (gClass, isAType) => {
         },
     ], { type: "boolean" });
 };
+/**
+ * Private helper function to aid implementation of the
+ * G_TYPE_CHECK_INSTANCE() macro.
+ * @param instance - a valid #GTypeInstance structure
+ */
 export const typeCheckInstance = (instance) => {
     return call("libgobject-2.0.so.0", "g_type_check_instance", [
         {
@@ -2890,6 +4002,12 @@ export const typeCheckValueHolds = (value, type) => {
         },
     ], { type: "boolean" });
 };
+/**
+ * Return a newly allocated and 0-terminated array of type IDs, listing
+ * the child types of @type.
+ * @param type - the parent type
+ * @param nChildren - location to store the length of
+ */
 export const typeChildren = (type, nChildren) => {
     return call("libgobject-2.0.so.0", "g_type_children", [
         {
@@ -2919,6 +4037,15 @@ export const typeClassAdjustPrivateOffset = (privateSizeOrOffset, gClass) => {
         },
     ], { type: "undefined" });
 };
+/**
+ * Retrieves the type class of the given @type.
+ *
+ * This function will create the class on demand if it does not exist
+ * already.
+ *
+ * If you don't want to create the class, use g_type_class_peek() instead.
+ * @param type - type ID of a classed type
+ */
 export const typeClassGet = (type) => {
     return call("libgobject-2.0.so.0", "g_type_class_get", [
         {
@@ -2927,6 +4054,17 @@ export const typeClassGet = (type) => {
         },
     ], { type: "int", size: 64, unsigned: true });
 };
+/**
+ * Retrieves the class for a give type.
+ *
+ * This function is essentially the same as g_type_class_get(),
+ * except that the class may have not been instantiated yet.
+ *
+ * As a consequence, this function may return %NULL if the class
+ * of the type passed in does not currently exist (hasn't been
+ * referenced before).
+ * @param type - type ID of a classed type
+ */
 export const typeClassPeek = (type) => {
     return call("libgobject-2.0.so.0", "g_type_class_peek", [
         {
@@ -2935,6 +4073,11 @@ export const typeClassPeek = (type) => {
         },
     ], { type: "int", size: 64, unsigned: true });
 };
+/**
+ * A more efficient version of g_type_class_peek() which works only for
+ * static types.
+ * @param type - type ID of a classed type
+ */
 export const typeClassPeekStatic = (type) => {
     return call("libgobject-2.0.so.0", "g_type_class_peek_static", [
         {
@@ -2943,6 +4086,13 @@ export const typeClassPeekStatic = (type) => {
         },
     ], { type: "int", size: 64, unsigned: true });
 };
+/**
+ * Increments the reference count of the class structure belonging to
+ * @type.
+ *
+ * This function will demand-create the class if it doesn't exist already.
+ * @param type - type ID of a classed type
+ */
 export const typeClassRef = (type) => {
     return call("libgobject-2.0.so.0", "g_type_class_ref", [
         {
@@ -2951,6 +4101,22 @@ export const typeClassRef = (type) => {
         },
     ], { type: "int", size: 64, unsigned: true });
 };
+/**
+ * Returns the default interface vtable for the given @g_type.
+ *
+ * If the type is not currently in use, then the default vtable
+ * for the type will be created and initialized by calling
+ * the base interface init and default vtable init functions for
+ * the type (the `base_init` and `class_init` members of #GTypeInfo).
+ *
+ * If you don't want to create the interface vtable, you should use
+ * g_type_default_interface_peek() instead.
+ *
+ * Calling g_type_default_interface_get() is useful when you
+ * want to make sure that signals and properties for an interface
+ * have been installed.
+ * @param gType - an interface type
+ */
 export const typeDefaultInterfaceGet = (gType) => {
     return call("libgobject-2.0.so.0", "g_type_default_interface_get", [
         {
@@ -2959,6 +4125,11 @@ export const typeDefaultInterfaceGet = (gType) => {
         },
     ], { type: "int", size: 64, unsigned: true });
 };
+/**
+ * If the interface type `g_type` is currently in use, returns its
+ * default interface vtable.
+ * @param gType - an interface type
+ */
 export const typeDefaultInterfacePeek = (gType) => {
     return call("libgobject-2.0.so.0", "g_type_default_interface_peek", [
         {
@@ -2967,6 +4138,19 @@ export const typeDefaultInterfacePeek = (gType) => {
         },
     ], { type: "int", size: 64, unsigned: true });
 };
+/**
+ * Increments the reference count for the interface type @g_type,
+ * and returns the default interface vtable for the type.
+ *
+ * If the type is not currently in use, then the default vtable
+ * for the type will be created and initialized by calling
+ * the base interface init and default vtable init functions for
+ * the type (the `base_init` and `class_init` members of #GTypeInfo).
+ * Calling g_type_default_interface_ref() is useful when you
+ * want to make sure that signals and properties for an interface
+ * have been installed.
+ * @param gType - an interface type
+ */
 export const typeDefaultInterfaceRef = (gType) => {
     return call("libgobject-2.0.so.0", "g_type_default_interface_ref", [
         {
@@ -2975,6 +4159,15 @@ export const typeDefaultInterfaceRef = (gType) => {
         },
     ], { type: "int", size: 64, unsigned: true });
 };
+/**
+ * Decrements the reference count for the type corresponding to the
+ * interface default vtable @g_iface.
+ *
+ * If the type is dynamic, then when no one is using the interface and all
+ * references have been released, the finalize function for the interface's
+ * default vtable (the `class_finalize` member of #GTypeInfo) will be called.
+ * @param gIface - the default vtable
+ */
 export const typeDefaultInterfaceUnref = (gIface) => {
     call("libgobject-2.0.so.0", "g_type_default_interface_unref", [
         {
@@ -2983,6 +4176,11 @@ export const typeDefaultInterfaceUnref = (gIface) => {
         },
     ], { type: "undefined" });
 };
+/**
+ * Returns the length of the ancestry of the passed in type. This
+ * includes the type itself, so that e.g. a fundamental type has depth 1.
+ * @param type - a #GType
+ */
 export const typeDepth = (type) => {
     return call("libgobject-2.0.so.0", "g_type_depth", [
         {
@@ -2991,6 +4189,21 @@ export const typeDepth = (type) => {
         },
     ], { type: "int", size: 32, unsigned: true });
 };
+/**
+ * Ensures that the indicated `type` has been registered with the
+ * type system, and its _class_init() method has been run.
+ *
+ * In theory, simply calling the type's _get_type() method (or using
+ * the corresponding macro) is supposed take care of this. However,
+ * _get_type() methods are often marked %G_GNUC_CONST for performance
+ * reasons, even though this is technically incorrect (since
+ * %G_GNUC_CONST requires that the function not have side effects,
+ * which _get_type() methods do on the first call). As a result, if
+ * you write a bare call to a _get_type() macro, it may get optimized
+ * out by the compiler. Using g_type_ensure() guarantees that the
+ * type's _get_type() method is called.
+ * @param type - a #GType
+ */
 export const typeEnsure = (type) => {
     call("libgobject-2.0.so.0", "g_type_ensure", [
         {
@@ -2999,6 +4212,14 @@ export const typeEnsure = (type) => {
         },
     ], { type: "undefined" });
 };
+/**
+ * Frees an instance of a type, returning it to the instance pool for
+ * the type, if there is one.
+ *
+ * Like g_type_create_instance(), this function is reserved for
+ * implementors of fundamental types.
+ * @param instance - an instance of a type
+ */
 export const typeFreeInstance = (instance) => {
     call("libgobject-2.0.so.0", "g_type_free_instance", [
         {
@@ -3007,6 +4228,13 @@ export const typeFreeInstance = (instance) => {
         },
     ], { type: "undefined" });
 };
+/**
+ * Look up the type ID from a given type name, returning 0 if no type
+ * has been registered under this name (this is the preferred method
+ * to find out by name whether a specific type has been registered
+ * yet).
+ * @param name - type name to look up
+ */
 export const typeFromName = (name) => {
     return call("libgobject-2.0.so.0", "g_type_from_name", [
         {
@@ -3015,6 +4243,11 @@ export const typeFromName = (name) => {
         },
     ], { type: "int", size: 64, unsigned: true });
 };
+/**
+ * Internal function, used to extract the fundamental type ID portion.
+ * Use G_TYPE_FUNDAMENTAL() instead.
+ * @param typeId - valid type ID
+ */
 export const typeFundamental = (typeId) => {
     return call("libgobject-2.0.so.0", "g_type_fundamental", [
         {
@@ -3023,6 +4256,12 @@ export const typeFundamental = (typeId) => {
         },
     ], { type: "int", size: 64, unsigned: true });
 };
+/**
+ * Returns the next free fundamental type id which can be used to
+ * register a new fundamental type with g_type_register_fundamental().
+ * The returned type ID represents the highest currently registered
+ * fundamental type identifier.
+ */
 export const typeFundamentalNext = () => {
     return call("libgobject-2.0.so.0", "g_type_fundamental_next", [], {
         type: "int",
@@ -3030,6 +4269,13 @@ export const typeFundamentalNext = () => {
         unsigned: true,
     });
 };
+/**
+ * Returns the number of instances allocated of the particular type;
+ * this is only available if GLib is built with debugging support and
+ * the `instance-count` debug flag is set (by setting the `GOBJECT_DEBUG`
+ * variable to include `instance-count`).
+ * @param type - a #GType
+ */
 export const typeGetInstanceCount = (type) => {
     return call("libgobject-2.0.so.0", "g_type_get_instance_count", [
         {
@@ -3038,6 +4284,10 @@ export const typeGetInstanceCount = (type) => {
         },
     ], { type: "int", size: 32, unsigned: false });
 };
+/**
+ * Returns the #GTypePlugin structure for @type.
+ * @param type - #GType to retrieve the plugin for
+ */
 export const typeGetPlugin = (type) => {
     const ptr = call("libgobject-2.0.so.0", "g_type_get_plugin", [
         {
@@ -3047,6 +4297,15 @@ export const typeGetPlugin = (type) => {
     ], { type: "gobject", borrowed: true });
     return getObject(ptr, TypePlugin);
 };
+/**
+ * Obtains data which has previously been attached to `type` with g_type_set_qdata().
+ *
+ * Note that this does not take subtyping into account; data
+ * attached to one type with g_type_set_qdata() cannot
+ * be retrieved from a subtype using g_type_get_qdata().
+ * @param type - a #GType
+ * @param quark - a #GQuark id to identify the data
+ */
 export const typeGetQdata = (type, quark) => {
     return call("libgobject-2.0.so.0", "g_type_get_qdata", [
         {
@@ -3059,12 +4318,33 @@ export const typeGetQdata = (type, quark) => {
         },
     ], { type: "int", size: 64, unsigned: true });
 };
+/**
+ * Returns an opaque serial number that represents the state of the set
+ * of registered types. Any time a type is registered this serial changes,
+ * which means you can cache information based on type lookups (such as
+ * g_type_from_name()) and know if the cache is still valid at a later
+ * time by comparing the current serial with the one at the type lookup.
+ */
 export const typeGetTypeRegistrationSerial = () => {
     return call("libgobject-2.0.so.0", "g_type_get_type_registration_serial", [], { type: "int", size: 32, unsigned: true });
 };
+/**
+ * This function used to initialise the type system.  Since GLib 2.36,
+ * the type system is initialised automatically and this function does
+ * nothing.
+ */
 export const typeInit = () => {
     call("libgobject-2.0.so.0", "g_type_init", [], { type: "undefined" });
 };
+/**
+ * This function used to initialise the type system with debugging
+ * flags.  Since GLib 2.36, the type system is initialised automatically
+ * and this function does nothing.
+ *
+ * If you need to enable debugging features, use the `GOBJECT_DEBUG`
+ * environment variable.
+ * @param debugFlags - bitwise combination of #GTypeDebugFlags values for
+ */
 export const typeInitWithDebugFlags = (debugFlags) => {
     call("libgobject-2.0.so.0", "g_type_init_with_debug_flags", [
         {
@@ -3073,6 +4353,15 @@ export const typeInitWithDebugFlags = (debugFlags) => {
         },
     ], { type: "undefined" });
 };
+/**
+ * Adds `prerequisite_type` to the list of prerequisites of @interface_type.
+ * This means that any type implementing `interface_type` must also implement
+ * @prerequisite_type. Prerequisites can be thought of as an alternative to
+ * interface derivation (which GType doesn't support). An interface can have
+ * at most one instantiatable prerequisite type.
+ * @param interfaceType - #GType value of an interface type
+ * @param prerequisiteType - #GType value of an interface or instantiatable type
+ */
 export const typeInterfaceAddPrerequisite = (interfaceType, prerequisiteType) => {
     call("libgobject-2.0.so.0", "g_type_interface_add_prerequisite", [
         {
@@ -3085,6 +4374,14 @@ export const typeInterfaceAddPrerequisite = (interfaceType, prerequisiteType) =>
         },
     ], { type: "undefined" });
 };
+/**
+ * Returns the #GTypePlugin structure for the dynamic interface
+ * `interface_type` which has been added to @instance_type, or %NULL
+ * if `interface_type` has not been added to `instance_type` or does
+ * not have a #GTypePlugin structure. See g_type_add_interface_dynamic().
+ * @param instanceType - #GType of an instantiatable type
+ * @param interfaceType - #GType of an interface type
+ */
 export const typeInterfaceGetPlugin = (instanceType, interfaceType) => {
     const ptr = call("libgobject-2.0.so.0", "g_type_interface_get_plugin", [
         {
@@ -3098,6 +4395,15 @@ export const typeInterfaceGetPlugin = (instanceType, interfaceType) => {
     ], { type: "gobject", borrowed: true });
     return getObject(ptr, TypePlugin);
 };
+/**
+ * Returns the most specific instantiatable prerequisite of an
+ * interface type. If the interface type has no instantiatable
+ * prerequisite, %G_TYPE_INVALID is returned.
+ *
+ * See g_type_interface_add_prerequisite() for more information
+ * about prerequisites.
+ * @param interfaceType - an interface type
+ */
 export const typeInterfaceInstantiatablePrerequisite = (interfaceType) => {
     return call("libgobject-2.0.so.0", "g_type_interface_instantiatable_prerequisite", [
         {
@@ -3106,6 +4412,12 @@ export const typeInterfaceInstantiatablePrerequisite = (interfaceType) => {
         },
     ], { type: "int", size: 64, unsigned: true });
 };
+/**
+ * Returns the #GTypeInterface structure of an interface to which the
+ * passed in class conforms.
+ * @param instanceClass - a #GTypeClass structure
+ * @param ifaceType - an interface ID which this class conforms to
+ */
 export const typeInterfacePeek = (instanceClass, ifaceType) => {
     return call("libgobject-2.0.so.0", "g_type_interface_peek", [
         {
@@ -3118,6 +4430,11 @@ export const typeInterfacePeek = (instanceClass, ifaceType) => {
         },
     ], { type: "int", size: 64, unsigned: true });
 };
+/**
+ * Returns the prerequisites of an interfaces type.
+ * @param interfaceType - an interface type
+ * @param nPrerequisites - location to return the number
+ */
 export const typeInterfacePrerequisites = (interfaceType, nPrerequisites) => {
     return call("libgobject-2.0.so.0", "g_type_interface_prerequisites", [
         {
@@ -3134,6 +4451,12 @@ export const typeInterfacePrerequisites = (interfaceType, nPrerequisites) => {
         },
     ], { type: "array", itemType: { type: "int", size: 64, unsigned: true } });
 };
+/**
+ * Return a newly allocated and 0-terminated array of type IDs, listing
+ * the interface types that `type` conforms to.
+ * @param type - the type to list interface types for
+ * @param nInterfaces - location to store the length of
+ */
 export const typeInterfaces = (type, nInterfaces) => {
     return call("libgobject-2.0.so.0", "g_type_interfaces", [
         {
@@ -3150,6 +4473,13 @@ export const typeInterfaces = (type, nInterfaces) => {
         },
     ], { type: "array", itemType: { type: "int", size: 64, unsigned: true } });
 };
+/**
+ * If `is_a_type` is a derivable type, check whether `type` is a
+ * descendant of @is_a_type. If `is_a_type` is an interface, check
+ * whether `type` conforms to it.
+ * @param type - type to check ancestry for
+ * @param isAType - possible ancestor of `type` or interface that `type`     could conform to
+ */
 export const typeIsA = (type, isAType) => {
     return call("libgobject-2.0.so.0", "g_type_is_a", [
         {
@@ -3162,6 +4492,15 @@ export const typeIsA = (type, isAType) => {
         },
     ], { type: "boolean" });
 };
+/**
+ * Get the unique name that is assigned to a type ID.
+ *
+ * Note that this function (like all other GType API) cannot cope with
+ * invalid type IDs. %G_TYPE_INVALID may be passed to this function, as
+ * may be any other validly registered type ID, but randomized type IDs
+ * should not be passed in and will most likely lead to a crash.
+ * @param type - type to return name for
+ */
 export const typeName = (type) => {
     return call("libgobject-2.0.so.0", "g_type_name", [
         {
@@ -3186,6 +4525,17 @@ export const typeNameFromInstance = (instance) => {
         },
     ], { type: "string", borrowed: true });
 };
+/**
+ * Given a `leaf_type` and a `root_type` which is contained in its
+ * ancestry, return the type that `root_type` is the immediate parent
+ * of. In other words, this function determines the type that is
+ * derived directly from `root_type` which is also a base class of
+ * @leaf_type.  Given a root type and a leaf type, this function can
+ * be used to determine the types and order in which the leaf type is
+ * descended from the root type.
+ * @param leafType - descendant of `root_type` and the type to be returned
+ * @param rootType - immediate parent of the returned type
+ */
 export const typeNextBase = (leafType, rootType) => {
     return call("libgobject-2.0.so.0", "g_type_next_base", [
         {
@@ -3198,6 +4548,11 @@ export const typeNextBase = (leafType, rootType) => {
         },
     ], { type: "int", size: 64, unsigned: true });
 };
+/**
+ * Return the direct parent type of the passed in type. If the passed
+ * in type has no parent, i.e. is a fundamental type, 0 is returned.
+ * @param type - the derived type
+ */
 export const typeParent = (type) => {
     return call("libgobject-2.0.so.0", "g_type_parent", [
         {
@@ -3206,6 +4561,10 @@ export const typeParent = (type) => {
         },
     ], { type: "int", size: 64, unsigned: true });
 };
+/**
+ * Get the corresponding quark of the type IDs name.
+ * @param type - type to return quark of type name for
+ */
 export const typeQname = (type) => {
     return call("libgobject-2.0.so.0", "g_type_qname", [
         {
@@ -3214,6 +4573,20 @@ export const typeQname = (type) => {
         },
     ], { type: "int", size: 32, unsigned: true });
 };
+/**
+ * Queries the type system for information about a specific type.
+ *
+ * This function will fill in a user-provided structure to hold
+ * type-specific information. If an invalid #GType is passed in, the
+ * `type` member of the #GTypeQuery is 0. All members filled into the
+ * #GTypeQuery structure should be considered constant and have to be
+ * left untouched.
+ *
+ * Since GLib 2.78, this function allows queries on dynamic types. Previously
+ * it only supported static types.
+ * @param type - #GType of a static, classed type
+ * @param query - a user provided structure that is
+ */
 export const typeQuery = (type, query) => {
     call("libgobject-2.0.so.0", "g_type_query", [
         {
@@ -3229,6 +4602,17 @@ export const typeQuery = (type, query) => {
         },
     ], { type: "undefined" });
 };
+/**
+ * Registers `type_name` as the name of a new dynamic type derived from
+ * @parent_type.  The type system uses the information contained in the
+ * #GTypePlugin structure pointed to by `plugin` to manage the type and its
+ * instances (if not abstract).  The value of `flags` determines the nature
+ * (e.g. abstract or not) of the type.
+ * @param parentType - type from which this type will be derived
+ * @param typeName - 0-terminated string used as the name of the new type
+ * @param plugin - #GTypePlugin structure to retrieve the #GTypeInfo from
+ * @param flags - bitwise combination of #GTypeFlags values
+ */
 export const typeRegisterDynamic = (parentType, typeName, plugin, flags) => {
     return call("libgobject-2.0.so.0", "g_type_register_dynamic", [
         {
@@ -3249,6 +4633,20 @@ export const typeRegisterDynamic = (parentType, typeName, plugin, flags) => {
         },
     ], { type: "int", size: 64, unsigned: true });
 };
+/**
+ * Registers `type_id` as the predefined identifier and `type_name` as the
+ * name of a fundamental type. If `type_id` is already registered, or a
+ * type named `type_name` is already registered, the behaviour is undefined.
+ * The type system uses the information contained in the #GTypeInfo structure
+ * pointed to by `info` and the #GTypeFundamentalInfo structure pointed to by
+ * `finfo` to manage the type and its instances. The value of `flags` determines
+ * additional characteristics of the fundamental type.
+ * @param typeId - a predefined type identifier
+ * @param typeName - 0-terminated string used as the name of the new type
+ * @param info - #GTypeInfo structure for this type
+ * @param finfo - #GTypeFundamentalInfo structure for this type
+ * @param flags - bitwise combination of #GTypeFlags values
+ */
 export const typeRegisterFundamental = (typeId, typeName, info, finfo, flags) => {
     return call("libgobject-2.0.so.0", "g_type_register_fundamental", [
         {
@@ -3273,6 +4671,17 @@ export const typeRegisterFundamental = (typeId, typeName, info, finfo, flags) =>
         },
     ], { type: "int", size: 64, unsigned: true });
 };
+/**
+ * Registers `type_name` as the name of a new static type derived from
+ * @parent_type. The type system uses the information contained in the
+ * #GTypeInfo structure pointed to by `info` to manage the type and its
+ * instances (if not abstract). The value of `flags` determines the nature
+ * (e.g. abstract or not) of the type.
+ * @param parentType - type from which this type will be derived
+ * @param typeName - 0-terminated string used as the name of the new type
+ * @param info - #GTypeInfo structure for this type
+ * @param flags - bitwise combination of #GTypeFlags values
+ */
 export const typeRegisterStatic = (parentType, typeName, info, flags) => {
     return call("libgobject-2.0.so.0", "g_type_register_static", [
         {
@@ -3293,6 +4702,12 @@ export const typeRegisterStatic = (parentType, typeName, info, flags) => {
         },
     ], { type: "int", size: 64, unsigned: true });
 };
+/**
+ * Attaches arbitrary data to a type.
+ * @param type - a #GType
+ * @param quark - a #GQuark id to identify the data
+ * @param data - the data
+ */
 export const typeSetQdata = (type, quark, data) => {
     call("libgobject-2.0.so.0", "g_type_set_qdata", [
         {
@@ -3322,6 +4737,12 @@ export const typeTestFlags = (type, flags) => {
         },
     ], { type: "boolean" });
 };
+/**
+ * Checks whether a [method@GObject.Value.copy] is able to copy values of type
+ * `src_type` into values of type @dest_type.
+ * @param srcType - source type to be copied
+ * @param destType - destination type for copying
+ */
 export const valueTypeCompatible = (srcType, destType) => {
     return call("libgobject-2.0.so.0", "g_value_type_compatible", [
         {
@@ -3334,6 +4755,16 @@ export const valueTypeCompatible = (srcType, destType) => {
         },
     ], { type: "boolean" });
 };
+/**
+ * Checks whether [method@GObject.Value.transform] is able to transform values
+ * of type `src_type` into values of type @dest_type.
+ *
+ * Note that for the types to be transformable, they must be compatible or a
+ * transformation function must be registered using
+ * [func@GObject.Value.register_transform_func].
+ * @param srcType - source type
+ * @param destType - target type
+ */
 export const valueTypeTransformable = (srcType, destType) => {
     return call("libgobject-2.0.so.0", "g_value_type_transformable", [
         {