@gtkx/ffi 0.10.5 → 0.11.0

package/dist/generated/gobject/functions.d.ts

@@ -1,182 +1,104 @@
 import { Ref } from "@gtkx/native";
 import { ParamFlags, SignalMatchType, TypeDebugFlags, TypeFlags } from "./enums.js";
 import { Closure } from "./closure.js";
+import { EnumClass } from "./enum-class.js";
+import { EnumValue } from "./enum-value.js";
+import { FlagsClass } from "./flags-class.js";
+import { FlagsValue } from "./flags-value.js";
+import { InterfaceInfo } from "./interface-info.js";
+import { ParamSpecTypeInfo } from "./param-spec-type-info.js";
+import { SignalInvocationHint } from "./signal-invocation-hint.js";
+import { SignalQuery } from "./signal-query.js";
+import { TypeClass } from "./type-class.js";
+import { TypeFundamentalInfo } from "./type-fundamental-info.js";
+import { TypeInfo } from "./type-info.js";
+import { TypeInstance } from "./type-instance.js";
+import { TypeInterface } from "./type-interface.js";
+import { TypeQuery } from "./type-query.js";
 import { Value } from "./value.js";
+import { TypePlugin } from "./type-plugin.js";
 import { GObject } from "./object.js";
 import { ParamSpec } from "./param-spec.js";
-import { TypePlugin } from "./type-plugin.js";
 import * as GLib from "../glib/index.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.
- */
+/** Provide a copy of a boxed structure `src_boxed` which is of type `boxed_type`. */
 export declare const boxedCopy: (boxedType: number, srcBoxed: number) => number;
-/**
- * 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.
- */
+/** Free the boxed structure `boxed` which is of type `boxed_type`. */
 export declare const boxedFree: (boxedType: number, boxed: number) => void;
 /**
  * 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 declare const cclosureMarshal_BOOLEAN__BOXED_BOXED: (closure: Closure, returnValue: Value, nParamValues: number, paramValues: Value, invocationHint?: number, marshalData?: number) => void;
+export declare const cclosureMarshal_BOOLEAN__BOXED_BOXED: (closure: Closure, returnValue: Value, nParamValues: number, paramValues: Value, invocationHint?: number | null, marshalData?: number | null) => void;
 /**
  * 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 declare const cclosureMarshal_BOOLEAN__FLAGS: (closure: Closure, returnValue: Value, nParamValues: number, paramValues: Value, invocationHint?: number, marshalData?: number) => void;
+export declare const cclosureMarshal_BOOLEAN__FLAGS: (closure: Closure, returnValue: Value, nParamValues: number, paramValues: Value, invocationHint?: number | null, marshalData?: number | null) => void;
 /**
  * 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 declare const cclosureMarshal_STRING__OBJECT_POINTER: (closure: Closure, returnValue: Value, nParamValues: number, paramValues: Value, invocationHint?: number, marshalData?: number) => void;
+export declare const cclosureMarshal_STRING__OBJECT_POINTER: (closure: Closure, returnValue: Value, nParamValues: number, paramValues: Value, invocationHint?: number | null, marshalData?: number | null) => void;
 /**
  * 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 declare const cclosureMarshal_VOID__BOOLEAN: (closure: Closure, returnValue: Value, nParamValues: number, paramValues: Value, invocationHint?: number, marshalData?: number) => void;
+export declare const cclosureMarshal_VOID__BOOLEAN: (closure: Closure, returnValue: Value, nParamValues: number, paramValues: Value, invocationHint?: number | null, marshalData?: number | null) => void;
 /**
  * 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 declare const cclosureMarshal_VOID__BOXED: (closure: Closure, returnValue: Value, nParamValues: number, paramValues: Value, invocationHint?: number, marshalData?: number) => void;
+export declare const cclosureMarshal_VOID__BOXED: (closure: Closure, returnValue: Value, nParamValues: number, paramValues: Value, invocationHint?: number | null, marshalData?: number | null) => void;
 /**
  * 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 declare const cclosureMarshal_VOID__CHAR: (closure: Closure, returnValue: Value, nParamValues: number, paramValues: Value, invocationHint?: number, marshalData?: number) => void;
+export declare const cclosureMarshal_VOID__CHAR: (closure: Closure, returnValue: Value, nParamValues: number, paramValues: Value, invocationHint?: number | null, marshalData?: number | null) => void;
 /**
  * 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 declare const cclosureMarshal_VOID__DOUBLE: (closure: Closure, returnValue: Value, nParamValues: number, paramValues: Value, invocationHint?: number, marshalData?: number) => void;
+export declare const cclosureMarshal_VOID__DOUBLE: (closure: Closure, returnValue: Value, nParamValues: number, paramValues: Value, invocationHint?: number | null, marshalData?: number | null) => void;
 /**
  * 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 declare const cclosureMarshal_VOID__ENUM: (closure: Closure, returnValue: Value, nParamValues: number, paramValues: Value, invocationHint?: number, marshalData?: number) => void;
+export declare const cclosureMarshal_VOID__ENUM: (closure: Closure, returnValue: Value, nParamValues: number, paramValues: Value, invocationHint?: number | null, marshalData?: number | null) => void;
 /**
  * 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 declare const cclosureMarshal_VOID__FLAGS: (closure: Closure, returnValue: Value, nParamValues: number, paramValues: Value, invocationHint?: number, marshalData?: number) => void;
+export declare const cclosureMarshal_VOID__FLAGS: (closure: Closure, returnValue: Value, nParamValues: number, paramValues: Value, invocationHint?: number | null, marshalData?: number | null) => void;
 /**
  * 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 declare const cclosureMarshal_VOID__FLOAT: (closure: Closure, returnValue: Value, nParamValues: number, paramValues: Value, invocationHint?: number, marshalData?: number) => void;
+export declare const cclosureMarshal_VOID__FLOAT: (closure: Closure, returnValue: Value, nParamValues: number, paramValues: Value, invocationHint?: number | null, marshalData?: number | null) => void;
 /**
  * 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 declare const cclosureMarshal_VOID__INT: (closure: Closure, returnValue: Value, nParamValues: number, paramValues: Value, invocationHint?: number, marshalData?: number) => void;
+export declare const cclosureMarshal_VOID__INT: (closure: Closure, returnValue: Value, nParamValues: number, paramValues: Value, invocationHint?: number | null, marshalData?: number | null) => void;
 /**
  * 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 declare const cclosureMarshal_VOID__LONG: (closure: Closure, returnValue: Value, nParamValues: number, paramValues: Value, invocationHint?: number, marshalData?: number) => void;
+export declare const cclosureMarshal_VOID__LONG: (closure: Closure, returnValue: Value, nParamValues: number, paramValues: Value, invocationHint?: number | null, marshalData?: number | null) => void;
 /**
  * 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 declare const cclosureMarshal_VOID__OBJECT: (closure: Closure, returnValue: Value, nParamValues: number, paramValues: Value, invocationHint?: number, marshalData?: number) => void;
+export declare const cclosureMarshal_VOID__OBJECT: (closure: Closure, returnValue: Value, nParamValues: number, paramValues: Value, invocationHint?: number | null, marshalData?: number | null) => void;
 /**
  * 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 declare const cclosureMarshal_VOID__PARAM: (closure: Closure, returnValue: Value, nParamValues: number, paramValues: Value, invocationHint?: number, marshalData?: number) => void;
+export declare const cclosureMarshal_VOID__PARAM: (closure: Closure, returnValue: Value, nParamValues: number, paramValues: Value, invocationHint?: number | null, marshalData?: number | null) => void;
 /**
  * A #GClosureMarshal function for use with signals with a single raw
  * pointer argument type.
@@ -184,104 +106,48 @@ export declare const cclosureMarshal_VOID__PARAM: (closure: Closure, returnValue
  * 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 declare const cclosureMarshal_VOID__POINTER: (closure: Closure, returnValue: Value, nParamValues: number, paramValues: Value, invocationHint?: number, marshalData?: number) => void;
+export declare const cclosureMarshal_VOID__POINTER: (closure: Closure, returnValue: Value, nParamValues: number, paramValues: Value, invocationHint?: number | null, marshalData?: number | null) => void;
 /**
  * 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 declare const cclosureMarshal_VOID__STRING: (closure: Closure, returnValue: Value, nParamValues: number, paramValues: Value, invocationHint?: number, marshalData?: number) => void;
+export declare const cclosureMarshal_VOID__STRING: (closure: Closure, returnValue: Value, nParamValues: number, paramValues: Value, invocationHint?: number | null, marshalData?: number | null) => void;
 /**
  * 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 declare const cclosureMarshal_VOID__UCHAR: (closure: Closure, returnValue: Value, nParamValues: number, paramValues: Value, invocationHint?: number, marshalData?: number) => void;
+export declare const cclosureMarshal_VOID__UCHAR: (closure: Closure, returnValue: Value, nParamValues: number, paramValues: Value, invocationHint?: number | null, marshalData?: number | null) => void;
 /**
  * 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 declare const cclosureMarshal_VOID__UINT: (closure: Closure, returnValue: Value, nParamValues: number, paramValues: Value, invocationHint?: number, marshalData?: number) => void;
+export declare const cclosureMarshal_VOID__UINT: (closure: Closure, returnValue: Value, nParamValues: number, paramValues: Value, invocationHint?: number | null, marshalData?: number | null) => void;
 /**
  * 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 declare const cclosureMarshal_VOID__UINT_POINTER: (closure: Closure, returnValue: Value, nParamValues: number, paramValues: Value, invocationHint?: number, marshalData?: number) => void;
+export declare const cclosureMarshal_VOID__UINT_POINTER: (closure: Closure, returnValue: Value, nParamValues: number, paramValues: Value, invocationHint?: number | null, marshalData?: number | null) => void;
 /**
  * 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 declare const cclosureMarshal_VOID__ULONG: (closure: Closure, returnValue: Value, nParamValues: number, paramValues: Value, invocationHint?: number, marshalData?: number) => void;
+export declare const cclosureMarshal_VOID__ULONG: (closure: Closure, returnValue: Value, nParamValues: number, paramValues: Value, invocationHint?: number | null, marshalData?: number | null) => void;
 /**
  * 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 declare const cclosureMarshal_VOID__VARIANT: (closure: Closure, returnValue: Value, nParamValues: number, paramValues: Value, invocationHint?: number, marshalData?: number) => void;
-/**
- * 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 declare const cclosureMarshal_VOID__VOID: (closure: Closure, returnValue: Value, nParamValues: number, paramValues: Value, invocationHint?: number, marshalData?: number) => void;
+export declare const cclosureMarshal_VOID__VARIANT: (closure: Closure, returnValue: Value, nParamValues: number, paramValues: Value, invocationHint?: number | null, marshalData?: number | null) => void;
+/** A #GClosureMarshal function for use with signals with no arguments. */
+export declare const cclosureMarshal_VOID__VOID: (closure: Closure, returnValue: Value, nParamValues: number, paramValues: Value, invocationHint?: number | null, marshalData?: number | null) => void;
 /**
  * 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 declare const cclosureMarshalGeneric: (closure: Closure, returnGvalue: Value, nParamValues: number, paramValues: Value, invocationHint?: number, marshalData?: number) => void;
+export declare const cclosureMarshalGeneric: (closure: Closure, returnGvalue: Value, nParamValues: number, paramValues: Value, invocationHint?: number | null, marshalData?: number | null) => void;
 /**
  * Disconnects a handler from `instance` so it will not be called during
  * any future or currently ongoing emissions of the signal it has been
@@ -291,8 +157,6 @@ export declare const cclosureMarshalGeneric: (closure: Closure, returnGvalue: Va
  *
  * 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 declare const clearSignalHandler: (handlerIdPtr: number, instance: GObject) => void;
 /**
@@ -303,106 +167,68 @@ export declare const clearSignalHandler: (handlerIdPtr: number, instance: GObjec
  * |[<!-- language="C" -->
  * static void
  * my_enum_complete_type_info (GTypePlugin     *plugin,
- * GType            g_type,
- * GTypeInfo       *info,
- * GTypeValueTable *value_table)
+ *                             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 }
- * };
+ *   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);
+ *   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 declare const enumCompleteTypeInfo: (gEnumType: number, info: Ref<number>, constValues: number[]) => void;
-/**
- * Returns the #GEnumValue for a value.
- * @param enumClass - a #GEnumClass
- * @param value - the value to look up
- */
-export declare const enumGetValue: (enumClass: number, value: number) => number | null;
-/**
- * Looks up a #GEnumValue by name.
- * @param enumClass - a #GEnumClass
- * @param name - the name to look up
- */
-export declare const enumGetValueByName: (enumClass: number, name: string) => number | null;
-/**
- * Looks up a #GEnumValue by nickname.
- * @param enumClass - a #GEnumClass
- * @param nick - the nickname to look up
- */
-export declare const enumGetValueByNick: (enumClass: number, nick: string) => number | null;
+export declare const enumCompleteTypeInfo: (gEnumType: number, info: Ref<TypeInfo>, constValues: EnumValue[]) => void;
+/** Returns the #GEnumValue for a value. */
+export declare const enumGetValue: (enumClass: EnumClass, value: number) => EnumValue | null;
+/** Looks up a #GEnumValue by name. */
+export declare const enumGetValueByName: (enumClass: EnumClass, name: string) => EnumValue | null;
+/** Looks up a #GEnumValue by nickname. */
+export declare const enumGetValueByNick: (enumClass: EnumClass, nick: string) => EnumValue | null;
 /**
  * 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 declare const enumRegisterStatic: (name: string, constStaticValues: number[]) => number;
+export declare const enumRegisterStatic: (name: string, constStaticValues: EnumValue[]) => number;
 /**
  * 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 declare const enumToString: (gEnumType: number, value: number) => 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 declare const flagsCompleteTypeInfo: (gFlagsType: number, info: Ref<number>, constValues: number[]) => void;
-/**
- * Returns the first #GFlagsValue which is set in `value`.
- * @param flagsClass - a #GFlagsClass
- * @param value - the value
  */
-export declare const flagsGetFirstValue: (flagsClass: number, value: number) => number | null;
-/**
- * Looks up a #GFlagsValue by name.
- * @param flagsClass - a #GFlagsClass
- * @param name - the name to look up
- */
-export declare const flagsGetValueByName: (flagsClass: number, name: string) => number | null;
-/**
- * Looks up a #GFlagsValue by nickname.
- * @param flagsClass - a #GFlagsClass
- * @param nick - the nickname to look up
- */
-export declare const flagsGetValueByNick: (flagsClass: number, nick: string) => number | null;
+export declare const flagsCompleteTypeInfo: (gFlagsType: number, info: Ref<TypeInfo>, constValues: FlagsValue[]) => void;
+/** Returns the first #GFlagsValue which is set in `value`. */
+export declare const flagsGetFirstValue: (flagsClass: FlagsClass, value: number) => FlagsValue | null;
+/** Looks up a #GFlagsValue by name. */
+export declare const flagsGetValueByName: (flagsClass: FlagsClass, name: string) => FlagsValue | null;
+/** Looks up a #GFlagsValue by nickname. */
+export declare const flagsGetValueByNick: (flagsClass: FlagsClass, nick: string) => FlagsValue | null;
 /**
  * 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 declare const flagsRegisterStatic: (name: string, constStaticValues: number[]) => number;
+export declare const flagsRegisterStatic: (name: string, constStaticValues: FlagsValue[]) => number;
 /**
  * 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 declare const flagsToString: (flagsType: number, value: number) => string;
 export declare const gtypeGetType: () => number;
@@ -414,252 +240,127 @@ export declare const gtypeGetType: () => number;
  * 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 declare const paramSpecBoolean: (name: string, defaultValue: boolean, flags: ParamFlags, nick?: string, blurb?: string) => ParamSpec;
+export declare const paramSpecBoolean: (name: string, defaultValue: boolean, flags: ParamFlags, nick?: string | null, blurb?: string | null) => 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 declare const paramSpecBoxed: (name: string, boxedType: number, flags: ParamFlags, nick?: string, blurb?: string) => 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 declare const paramSpecChar: (name: string, minimum: number, maximum: number, defaultValue: number, flags: ParamFlags, nick?: string, blurb?: string) => ParamSpec;
+export declare const paramSpecBoxed: (name: string, boxedType: number, flags: ParamFlags, nick?: string | null, blurb?: string | null) => ParamSpec;
+/** Creates a new #GParamSpecChar instance specifying a %G_TYPE_CHAR property. */
+export declare const paramSpecChar: (name: string, minimum: number, maximum: number, defaultValue: number, flags: ParamFlags, nick?: string | null, blurb?: string | null) => 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 declare const paramSpecDouble: (name: string, minimum: number, maximum: number, defaultValue: number, flags: ParamFlags, nick?: string, blurb?: string) => ParamSpec;
+export declare const paramSpecDouble: (name: string, minimum: number, maximum: number, defaultValue: number, flags: ParamFlags, nick?: string | null, blurb?: string | null) => 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 declare const paramSpecEnum: (name: string, enumType: number, defaultValue: number, flags: ParamFlags, nick?: string, blurb?: string) => ParamSpec;
+export declare const paramSpecEnum: (name: string, enumType: number, defaultValue: number, flags: ParamFlags, nick?: string | null, blurb?: string | null) => 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 declare const paramSpecFlags: (name: string, flagsType: number, defaultValue: number, flags: ParamFlags, nick?: string, blurb?: string) => ParamSpec;
+export declare const paramSpecFlags: (name: string, flagsType: number, defaultValue: number, flags: ParamFlags, nick?: string | null, blurb?: string | null) => 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 declare const paramSpecFloat: (name: string, minimum: number, maximum: number, defaultValue: number, flags: ParamFlags, nick?: string, blurb?: string) => ParamSpec;
+export declare const paramSpecFloat: (name: string, minimum: number, maximum: number, defaultValue: number, flags: ParamFlags, nick?: string | null, blurb?: string | null) => 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 declare const paramSpecGtype: (name: string, isAType: number, flags: ParamFlags, nick?: string, blurb?: string) => ParamSpec;
+export declare const paramSpecGtype: (name: string, isAType: number, flags: ParamFlags, nick?: string | null, blurb?: string | null) => 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 declare const paramSpecInt: (name: string, minimum: number, maximum: number, defaultValue: number, flags: ParamFlags, nick?: string, blurb?: string) => ParamSpec;
+export declare const paramSpecInt: (name: string, minimum: number, maximum: number, defaultValue: number, flags: ParamFlags, nick?: string | null, blurb?: string | null) => 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 declare const paramSpecInt64: (name: string, minimum: number, maximum: number, defaultValue: number, flags: ParamFlags, nick?: string, blurb?: string) => ParamSpec;
+export declare const paramSpecInt64: (name: string, minimum: number, maximum: number, defaultValue: number, flags: ParamFlags, nick?: string | null, blurb?: string | null) => 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 declare const paramSpecLong: (name: string, minimum: number, maximum: number, defaultValue: number, flags: ParamFlags, nick?: string, blurb?: string) => ParamSpec;
+export declare const paramSpecLong: (name: string, minimum: number, maximum: number, defaultValue: number, flags: ParamFlags, nick?: string | null, blurb?: string | null) => 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 declare const paramSpecObject: (name: string, objectType: number, flags: ParamFlags, nick?: string, blurb?: string) => ParamSpec;
+export declare const paramSpecObject: (name: string, objectType: number, flags: ParamFlags, nick?: string | null, blurb?: string | null) => 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 declare const paramSpecParam: (name: string, paramType: number, flags: ParamFlags, nick?: string, blurb?: string) => ParamSpec;
+export declare const paramSpecParam: (name: string, paramType: number, flags: ParamFlags, nick?: string | null, blurb?: string | null) => 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 declare const paramSpecPointer: (name: string, flags: ParamFlags, nick?: string, blurb?: string) => ParamSpec;
+export declare const paramSpecPointer: (name: string, flags: ParamFlags, nick?: string | null, blurb?: string | null) => 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 declare const paramSpecString: (name: string, flags: ParamFlags, nick?: string, blurb?: string, defaultValue?: string) => 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 declare const paramSpecUchar: (name: string, minimum: number, maximum: number, defaultValue: number, flags: ParamFlags, nick?: string, blurb?: string) => ParamSpec;
+export declare const paramSpecString: (name: string, flags: ParamFlags, nick?: string | null, blurb?: string | null, defaultValue?: string | null) => ParamSpec;
+/** Creates a new #GParamSpecUChar instance specifying a %G_TYPE_UCHAR property. */
+export declare const paramSpecUchar: (name: string, minimum: number, maximum: number, defaultValue: number, flags: ParamFlags, nick?: string | null, blurb?: string | null) => 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 declare const paramSpecUint: (name: string, minimum: number, maximum: number, defaultValue: number, flags: ParamFlags, nick?: string, blurb?: string) => ParamSpec;
+export declare const paramSpecUint: (name: string, minimum: number, maximum: number, defaultValue: number, flags: ParamFlags, nick?: string | null, blurb?: string | null) => 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 declare const paramSpecUint64: (name: string, minimum: number, maximum: number, defaultValue: number, flags: ParamFlags, nick?: string, blurb?: string) => ParamSpec;
+export declare const paramSpecUint64: (name: string, minimum: number, maximum: number, defaultValue: number, flags: ParamFlags, nick?: string | null, blurb?: string | null) => 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 declare const paramSpecUlong: (name: string, minimum: number, maximum: number, defaultValue: number, flags: ParamFlags, nick?: string, blurb?: string) => ParamSpec;
+export declare const paramSpecUlong: (name: string, minimum: number, maximum: number, defaultValue: number, flags: ParamFlags, nick?: string | null, blurb?: string | null) => 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 declare const paramSpecUnichar: (name: string, defaultValue: number, flags: ParamFlags, nick?: string, blurb?: string) => ParamSpec;
+export declare const paramSpecUnichar: (name: string, defaultValue: number, flags: ParamFlags, nick?: string | null, blurb?: string | null) => ParamSpec;
 /**
  * Creates a new #GParamSpecVariant instance specifying a #GVariant
  * property.
@@ -667,14 +368,8 @@ export declare const paramSpecUnichar: (name: string, defaultValue: number, flag
  * 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 declare const paramSpecVariant: (name: string, type: GLib.VariantType, flags: ParamFlags, nick?: string, blurb?: string, defaultValue?: GLib.Variant) => ParamSpec;
+export declare const paramSpecVariant: (name: string, type: GLib.VariantType, flags: ParamFlags, nick?: string | null, blurb?: string | null, defaultValue?: GLib.Variant | null) => ParamSpec;
 /**
  * Registers `name` as the name of a new static type derived
  * from %G_TYPE_PARAM.
@@ -682,10 +377,8 @@ export declare const paramSpecVariant: (name: string, type: GLib.VariantType, fl
  * 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 declare const paramTypeRegisterStatic: (name: string, pspecInfo: number) => number;
+export declare const paramTypeRegisterStatic: (name: string, pspecInfo: ParamSpecTypeInfo) => number;
 /**
  * Transforms `src_value` into `dest_value` if possible, and then
  * validates `dest_value`, in order for it to conform to `pspec`.  If
@@ -694,30 +387,16 @@ export declare const paramTypeRegisterStatic: (name: string, pspecInfo: number)
  *
  * 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`
  */
 export declare const paramValueConvert: (pspec: ParamSpec, srcValue: Value, destValue: Value, strictValidation: boolean) => 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`
- */
+/** Checks whether `value` contains the default value as specified in `pspec`. */
 export declare const paramValueDefaults: (pspec: ParamSpec, value: Value) => 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 declare const paramValueIsValid: (pspec: ParamSpec, value: Value) => 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
- */
+/** Sets `value` to its default value as specified in `pspec`. */
 export declare const paramValueSetDefault: (pspec: ParamSpec, value: Value) => void;
 /**
  * Ensures that the contents of `value` comply with the specifications
@@ -726,23 +405,17 @@ export declare const paramValueSetDefault: (pspec: ParamSpec, value: Value) => v
  * 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 declare const paramValueValidate: (pspec: ParamSpec, value: Value) => 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 declare const paramValuesCmp: (pspec: ParamSpec, value1: Value, value2: Value) => number;
 /**
  * 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 declare const pointerTypeRegisterStatic: (name: string) => number;
 /**
@@ -756,12 +429,8 @@ export declare const pointerTypeRegisterStatic: (name: string) => number;
  * 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 declare const signalAccumulatorFirstWins: (ihint: number, returnAccu: Value, handlerReturn: Value, dummy?: number) => boolean;
+export declare const signalAccumulatorFirstWins: (ihint: SignalInvocationHint, returnAccu: Value, handlerReturn: Value, dummy?: number | null) => boolean;
 /**
  * A predefined #GSignalAccumulator for signals that return a
  * boolean values. The behavior that this accumulator gives is
@@ -770,19 +439,13 @@ export declare const signalAccumulatorFirstWins: (ihint: number, returnAccu: Val
  * 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 declare const signalAccumulatorTrueHandled: (ihint: number, returnAccu: Value, handlerReturn: Value, dummy?: number) => boolean;
+export declare const signalAccumulatorTrueHandled: (ihint: SignalInvocationHint, returnAccu: Value, handlerReturn: Value, dummy?: number | null) => boolean;
 /**
  * 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 declare const signalChainFromOverridden: (instanceAndParams: Value[], returnValue: Value) => void;
 /**
@@ -798,10 +461,6 @@ export declare const signalChainFromOverridden: (instanceAndParams: Value[], ret
  *
  * 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 declare const signalConnectClosure: (instance: GObject, detailedSignal: string, closure: Closure, after: boolean) => number;
 /**
@@ -817,11 +476,6 @@ export declare const signalConnectClosure: (instance: GObject, detailedSignal: s
  *
  * 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 declare const signalConnectClosureById: (instance: GObject, signalId: number, detail: number, closure: Closure, after: boolean) => number;
 /**
@@ -830,17 +484,10 @@ export declare const signalConnectClosureById: (instance: GObject, signalId: num
  *
  * 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 declare const signalEmitv: (instanceAndParams: Value[], signalId: number, detail: number, returnValue: Ref<Value>) => void;
-/**
- * Returns the invocation hint of the innermost signal emission of instance.
- * @param instance - the instance to query
- */
-export declare const signalGetInvocationHint: (instance: GObject) => number | null;
+/** Returns the invocation hint of the innermost signal emission of instance. */
+export declare const signalGetInvocationHint: (instance: GObject) => SignalInvocationHint | null;
 /**
  * Blocks a handler of an instance so it will not be called during any
  * signal emissions unless it is unblocked again. Thus "blocking" a
@@ -850,8 +497,6 @@ export declare const signalGetInvocationHint: (instance: GObject) => number | nu
  *
  * 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 declare const signalHandlerBlock: (instance: GObject, handlerId: number) => void;
 /**
@@ -861,8 +506,6 @@ export declare const signalHandlerBlock: (instance: GObject, handlerId: number)
  *
  * 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 declare const signalHandlerDisconnect: (instance: GObject, handlerId: number) => void;
 /**
@@ -871,20 +514,9 @@ export declare const signalHandlerDisconnect: (instance: GObject, handlerId: num
  * 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`
- * @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 declare const signalHandlerFind: (instance: GObject, mask: SignalMatchType, signalId: number, detail: number, closure?: Closure, func?: number, data?: number) => number;
-/**
- * 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 declare const signalHandlerFind: (instance: GObject, mask: SignalMatchType, signalId: number, detail: number, closure?: Closure | null, func?: number | null, data?: number | null) => number;
+/** Returns whether `handler_id` is the ID of a handler connected to `instance`. */
 export declare const signalHandlerIsConnected: (instance: GObject, handlerId: number) => boolean;
 /**
  * Undoes the effect of a previous g_signal_handler_block() call.  A
@@ -900,8 +532,6 @@ export declare const signalHandlerIsConnected: (instance: GObject, handlerId: nu
  *
  * 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 declare const signalHandlerUnblock: (instance: GObject, handlerId: number) => void;
 /**
@@ -918,20 +548,12 @@ export declare const signalHandlerUnblock: (instance: GObject, handlerId: number
  * 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`
- * @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 declare const signalHandlersBlockMatched: (instance: GObject, mask: SignalMatchType, signalId: number, detail: number, closure?: Closure, func?: number, data?: number) => number;
+export declare const signalHandlersBlockMatched: (instance: GObject, mask: SignalMatchType, signalId: number, detail: number, closure?: Closure | null, func?: number | null, data?: number | null) => number;
 /**
  * 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 declare const signalHandlersDestroy: (instance: GObject) => void;
 /**
@@ -949,15 +571,8 @@ export declare const signalHandlersDestroy: (instance: GObject) => void;
  * 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`
- * @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 declare const signalHandlersDisconnectMatched: (instance: GObject, mask: SignalMatchType, signalId: number, detail: number, closure?: Closure, func?: number, data?: number) => number;
+export declare const signalHandlersDisconnectMatched: (instance: GObject, mask: SignalMatchType, signalId: number, detail: number, closure?: Closure | null, func?: number | null, data?: number | null) => number;
 /**
  * Unblocks all handlers on an instance that match a certain selection
  * criteria.
@@ -974,15 +589,8 @@ export declare const signalHandlersDisconnectMatched: (instance: GObject, mask:
  * 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`
- * @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 declare const signalHandlersUnblockMatched: (instance: GObject, mask: SignalMatchType, signalId: number, detail: number, closure?: Closure, func?: number, data?: number) => number;
+export declare const signalHandlersUnblockMatched: (instance: GObject, mask: SignalMatchType, signalId: number, detail: number, closure?: Closure | null, func?: number | null, data?: number | null) => number;
 /**
  * Returns whether there are any handlers connected to `instance` for the
  * given signal id and detail.
@@ -1000,10 +608,6 @@ export declare const signalHandlersUnblockMatched: (instance: GObject, mask: Sig
  * 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 declare const signalHasHandlerPending: (instance: GObject, signalId: number, detail: number, mayBeBlocked: boolean) => boolean;
 /**
@@ -1012,15 +616,12 @@ export declare const signalHasHandlerPending: (instance: GObject, signalId: numb
  *
  * See {@link 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 declare const signalIsValidName: (name: string) => 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 declare const signalListIds: (itype: number, nIds: Ref<number>) => number[];
 /**
@@ -1035,15 +636,12 @@ export declare const signalListIds: (itype: number, nIds: Ref<number>) => number
  * 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 declare const signalLookup: (name: string, itype: number) => number;
 /**
  * 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 declare const signalName: (signalId: number) => string | null;
 /**
@@ -1054,19 +652,11 @@ export declare const signalName: (signalId: number) => string | null;
  * 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 declare const signalOverrideClassClosure: (signalId: number, instanceType: number, classClosure: Closure) => void;
 /**
  * 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 declare const signalParseName: (detailedSignal: string, itype: number, signalIdP: Ref<number>, detailP: Ref<number>, forceDetailQuark: boolean) => boolean;
 /**
@@ -1076,15 +666,9 @@ export declare const signalParseName: (detailedSignal: string, itype: number, si
  * 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 declare const signalQuery: (signalId: number, query: Ref<number>) => void;
-/**
- * Deletes an emission hook.
- * @param signalId - the id of the signal
- * @param hookId - the id of the emission hook, as returned by
  */
+export declare const signalQuery: (signalId: number, query: SignalQuery) => void;
+/** Deletes an emission hook. */
 export declare const signalRemoveEmissionHook: (signalId: number, hookId: number) => void;
 /**
  * Stops a signal's current emission.
@@ -1094,9 +678,6 @@ export declare const signalRemoveEmissionHook: (signalId: number, hookId: number
  * 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 declare const signalStopEmission: (instance: GObject, signalId: number, detail: number) => void;
 /**
@@ -1104,16 +685,12 @@ export declare const signalStopEmission: (instance: GObject, signalId: number, d
  *
  * 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 declare const signalStopEmissionByName: (instance: GObject, detailedSignal: string) => void;
 /**
  * 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 declare const signalTypeCclosureNew: (itype: number, structOffset: number) => Closure;
 /**
@@ -1122,8 +699,6 @@ export declare const signalTypeCclosureNew: (itype: number, structOffset: number
  * 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 declare const sourceSetClosure: (source: GLib.Source, closure: Closure) => void;
 /**
@@ -1137,7 +712,6 @@ export declare const sourceSetClosure: (source: GLib.Source, closure: Closure) =
  * `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 declare const sourceSetDummyCallback: (source: GLib.Source) => void;
 /**
@@ -1145,7 +719,6 @@ export declare const sourceSetDummyCallback: (source: GLib.Source) => void;
  * #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 declare const strdupValueContents: (value: Value) => string;
 /**
@@ -1159,8 +732,6 @@ export declare const strdupValueContents: (value: Value) => string;
  * 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 declare const typeAddClassPrivate: (classType: number, privateSize: number) => void;
 export declare const typeAddInstancePrivate: (classType: number, privateSize: number) => number;
@@ -1168,40 +739,31 @@ export declare const typeAddInstancePrivate: (classType: number, privateSize: nu
  * 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 declare const typeAddInterfaceDynamic: (instanceType: number, interfaceType: number, plugin: TypePlugin) => void;
 /**
  * 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 declare const typeAddInterfaceStatic: (instanceType: number, interfaceType: number, info: number) => void;
-export declare const typeCheckClassIsA: (gClass: number, isAType: number) => boolean;
+export declare const typeAddInterfaceStatic: (instanceType: number, interfaceType: number, info: InterfaceInfo) => void;
+export declare const typeCheckClassIsA: (gClass: TypeClass, isAType: number) => boolean;
 /**
  * Private helper function to aid implementation of the
  * G_TYPE_CHECK_INSTANCE() macro.
- * @param instance - a valid #GTypeInstance structure
  */
-export declare const typeCheckInstance: (instance: number) => boolean;
-export declare const typeCheckInstanceIsA: (instance: number, ifaceType: number) => boolean;
-export declare const typeCheckInstanceIsFundamentallyA: (instance: number, fundamentalType: number) => boolean;
+export declare const typeCheckInstance: (instance: TypeInstance) => boolean;
+export declare const typeCheckInstanceIsA: (instance: TypeInstance, ifaceType: number) => boolean;
+export declare const typeCheckInstanceIsFundamentallyA: (instance: TypeInstance, fundamentalType: number) => boolean;
 export declare const typeCheckIsValueType: (type: number) => boolean;
 export declare const typeCheckValue: (value: Value) => boolean;
 export declare const typeCheckValueHolds: (value: Value, type: number) => 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 declare const typeChildren: (type: number, nChildren?: Ref<number>) => number[];
-export declare const typeClassAdjustPrivateOffset: (privateSizeOrOffset: number, gClass?: number) => void;
+export declare const typeChildren: (type: number, nChildren?: Ref<number> | null) => number[];
+export declare const typeClassAdjustPrivateOffset: (privateSizeOrOffset: number, gClass?: number | null) => void;
 /**
  * Retrieves the type class of the given `type`.
  *
@@ -1209,9 +771,8 @@ export declare const typeClassAdjustPrivateOffset: (privateSizeOrOffset: number,
  * 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 declare const typeClassGet: (type: number) => number;
+export declare const typeClassGet: (type: number) => TypeClass;
 /**
  * Retrieves the class for a give type.
  *
@@ -1221,23 +782,20 @@ export declare const typeClassGet: (type: number) => number;
  * 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 declare const typeClassPeek: (type: number) => number | null;
+export declare const typeClassPeek: (type: number) => TypeClass | null;
 /**
  * A more efficient version of g_type_class_peek() which works only for
  * static types.
- * @param type - type ID of a classed type
  */
-export declare const typeClassPeekStatic: (type: number) => number | null;
+export declare const typeClassPeekStatic: (type: number) => TypeClass | null;
 /**
  * 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 declare const typeClassRef: (type: number) => number;
+export declare const typeClassRef: (type: number) => TypeClass;
 /**
  * Returns the default interface vtable for the given `g_type`.
  *
@@ -1252,15 +810,13 @@ export declare const typeClassRef: (type: number) => number;
  * 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 declare const typeDefaultInterfaceGet: (gType: number) => number;
+export declare const typeDefaultInterfaceGet: (gType: number) => TypeInterface;
 /**
  * If the interface type `g_type` is currently in use, returns its
  * default interface vtable.
- * @param gType - an interface type
  */
-export declare const typeDefaultInterfacePeek: (gType: number) => number;
+export declare const typeDefaultInterfacePeek: (gType: number) => TypeInterface;
 /**
  * Increments the reference count for the interface type `g_type`,
  * and returns the default interface vtable for the type.
@@ -1272,9 +828,8 @@ export declare const typeDefaultInterfacePeek: (gType: number) => number;
  * 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 declare const typeDefaultInterfaceRef: (gType: number) => number;
+export declare const typeDefaultInterfaceRef: (gType: number) => TypeInterface;
 /**
  * Decrements the reference count for the type corresponding to the
  * interface default vtable `g_iface`.
@@ -1282,13 +837,11 @@ export declare const typeDefaultInterfaceRef: (gType: number) => number;
  * 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 declare const typeDefaultInterfaceUnref: (gIface: number) => void;
+export declare const typeDefaultInterfaceUnref: (gIface: TypeInterface) => void;
 /**
  * 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 declare const typeDepth: (type: number) => number;
 /**
@@ -1304,7 +857,6 @@ export declare const typeDepth: (type: number) => number;
  * 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 declare const typeEnsure: (type: number) => void;
 /**
@@ -1313,21 +865,18 @@ export declare const typeEnsure: (type: number) => void;
  *
  * Like g_type_create_instance(), this function is reserved for
  * implementors of fundamental types.
- * @param instance - an instance of a type
  */
-export declare const typeFreeInstance: (instance: number) => void;
+export declare const typeFreeInstance: (instance: TypeInstance) => void;
 /**
  * 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 declare const typeFromName: (name: string) => number;
 /**
  * Internal function, used to extract the fundamental type ID portion.
  * Use G_TYPE_FUNDAMENTAL() instead.
- * @param typeId - valid type ID
  */
 export declare const typeFundamental: (typeId: number) => number;
 /**
@@ -1342,13 +891,9 @@ export declare const typeFundamentalNext: () => number;
  * 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 declare const typeGetInstanceCount: (type: number) => number;
-/**
- * Returns the #GTypePlugin structure for `type`.
- * @param type - #GType to retrieve the plugin for
- */
+/** Returns the #GTypePlugin structure for `type`. */
 export declare const typeGetPlugin: (type: number) => TypePlugin;
 /**
  * Obtains data which has previously been attached to `type`
@@ -1357,8 +902,6 @@ export declare const typeGetPlugin: (type: number) => TypePlugin;
  * 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 declare const typeGetQdata: (type: number, quark: number) => number | null;
 /**
@@ -1382,7 +925,6 @@ export declare const typeInit: () => void;
  *
  * If you need to enable debugging features, use the `GOBJECT_DEBUG`
  * environment variable.
- * @param debugFlags - bitwise combination of #GTypeDebugFlags values for
  */
 export declare const typeInitWithDebugFlags: (debugFlags: TypeDebugFlags) => void;
 /**
@@ -1391,8 +933,6 @@ export declare const typeInitWithDebugFlags: (debugFlags: TypeDebugFlags) => voi
  * `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 declare const typeInterfaceAddPrerequisite: (interfaceType: number, prerequisiteType: number) => void;
 /**
@@ -1400,8 +940,6 @@ export declare const typeInterfaceAddPrerequisite: (interfaceType: number, prere
  * `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 declare const typeInterfaceGetPlugin: (instanceType: number, interfaceType: number) => TypePlugin;
 /**
@@ -1411,35 +949,24 @@ export declare const typeInterfaceGetPlugin: (instanceType: number, interfaceTyp
  *
  * See g_type_interface_add_prerequisite() for more information
  * about prerequisites.
- * @param interfaceType - an interface type
  */
 export declare const typeInterfaceInstantiatablePrerequisite: (interfaceType: number) => number;
 /**
  * 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 declare const typeInterfacePeek: (instanceClass: number, ifaceType: number) => number | null;
-/**
- * Returns the prerequisites of an interfaces type.
- * @param interfaceType - an interface type
- * @param nPrerequisites - location to return the number
  */
-export declare const typeInterfacePrerequisites: (interfaceType: number, nPrerequisites?: Ref<number>) => number[];
+export declare const typeInterfacePeek: (instanceClass: TypeClass, ifaceType: number) => TypeInterface | null;
+/** Returns the prerequisites of an interfaces type. */
+export declare const typeInterfacePrerequisites: (interfaceType: number, nPrerequisites?: Ref<number> | null) => number[];
 /**
  * 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 declare const typeInterfaces: (type: number, nInterfaces?: Ref<number>) => number[];
+export declare const typeInterfaces: (type: number, nInterfaces?: Ref<number> | null) => number[];
 /**
  * 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`
  */
 export declare const typeIsA: (type: number, isAType: number) => boolean;
 /**
@@ -1449,11 +976,10 @@ export declare const typeIsA: (type: number, isAType: number) => boolean;
  * 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 declare const typeName: (type: number) => string | null;
-export declare const typeNameFromClass: (gClass: number) => string;
-export declare const typeNameFromInstance: (instance: number) => string;
+export declare const typeNameFromClass: (gClass: TypeClass) => string;
+export declare const typeNameFromInstance: (instance: TypeInstance) => string;
 /**
  * Given a `leaf_type` and a `root_type` which is contained in its
  * ancestry, return the type that `root_type` is the immediate parent
@@ -1462,20 +988,14 @@ export declare const typeNameFromInstance: (instance: number) => string;
  * `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 declare const typeNextBase: (leafType: number, rootType: number) => number;
 /**
  * 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 declare const typeParent: (type: number) => number;
-/**
- * Get the corresponding quark of the type IDs name.
- * @param type - type to return quark of type name for
- */
+/** Get the corresponding quark of the type IDs name. */
 export declare const typeQname: (type: number) => number;
 /**
  * Queries the type system for information about a specific type.
@@ -1488,20 +1008,14 @@ export declare const typeQname: (type: number) => number;
  *
  * 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 declare const typeQuery: (type: number, query: Ref<number>) => void;
+export declare const typeQuery: (type: number, query: TypeQuery) => void;
 /**
  * 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 declare const typeRegisterDynamic: (parentType: number, typeName: string, plugin: TypePlugin, flags: TypeFlags) => number;
 /**
@@ -1512,38 +1026,22 @@ export declare const typeRegisterDynamic: (parentType: number, typeName: string,
  * 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 declare const typeRegisterFundamental: (typeId: number, typeName: string, info: number, finfo: number, flags: TypeFlags) => number;
+export declare const typeRegisterFundamental: (typeId: number, typeName: string, info: TypeInfo, finfo: TypeFundamentalInfo, flags: TypeFlags) => number;
 /**
  * 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 declare const typeRegisterStatic: (parentType: number, typeName: string, info: number, flags: TypeFlags) => number;
-/**
- * Attaches arbitrary data to a type.
- * @param type - a #GType
- * @param quark - a #GQuark id to identify the data
- * @param data - the data
  */
-export declare const typeSetQdata: (type: number, quark: number, data?: number) => void;
+export declare const typeRegisterStatic: (parentType: number, typeName: string, info: TypeInfo, flags: TypeFlags) => number;
+/** Attaches arbitrary data to a type. */
+export declare const typeSetQdata: (type: number, quark: number, data?: number | null) => void;
 export declare const typeTestFlags: (type: number, flags: number) => boolean;
 /**
  * Checks whether a {@link 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 declare const valueTypeCompatible: (srcType: number, destType: number) => boolean;
 /**
@@ -1553,8 +1051,6 @@ export declare const valueTypeCompatible: (srcType: number, destType: number) =>
  * Note that for the types to be transformable, they must be compatible or a
  * transformation function must be registered using
  * {@link GObject.Value.register_transform_func}.
- * @param srcType - source type
- * @param destType - target type
  */
 export declare const valueTypeTransformable: (srcType: number, destType: number) => boolean;
 export declare const variantGetGtype: () => number;