@gtkx/ffi 0.1.45 → 0.1.46

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

@@ -6,160 +6,1591 @@ 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.
+ */
 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.
+ */
 export declare const boxedFree: (boxedType: number, boxed: number) => void;
+/**
+ * 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 declare const boxedTypeRegisterStatic: (name: string, boxedCopy: (...args: unknown[]) => unknown, boxedFree: (...args: unknown[]) => unknown) => number;
+/**
+ * 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | null, marshalData?: number | null) => void;
+/**
+ * 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 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 | 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 | 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 | 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 | 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 | 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 | null, marshalData?: number | null) => 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 | 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 | 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
+ * 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 declare const clearSignalHandler: (handlerIdPtr: number, instance: GObject) => void;
+/**
+ * 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 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;
+/**
+ * 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;
+/**
+ * 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;
+/**
+ * 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;
+/**
+ * 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;
+/**
+ * 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 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 | null, blurb?: string | null) => 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | 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 | null, blurb?: string | null, defaultValue?: string | null) => 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 | 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 | 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 | 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 | 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 | null, blurb?: string | null) => 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 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.
+ *
+ * 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;
+/**
+ * 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 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
+ */
 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
+ */
 export declare const paramValueSetDefault: (pspec: ParamSpec, value: Value) => void;
+/**
+ * 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 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;
+/**
+ * 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 declare const signalAccumulatorFirstWins: (ihint: number, 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
+ * 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 declare const signalAccumulatorTrueHandled: (ihint: number, returnAccu: Value, handlerReturn: Value, dummy?: number | null) => 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 declare const signalAddEmissionHook: (signalId: number, detail: number, hookFunc: (...args: unknown[]) => unknown, hookData?: number | null, dataDestroy?: () => void | null) => number;
+/**
+ * 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;
+/**
+ * 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 declare const signalConnectClosure: (instance: GObject, detailedSignal: string, closure: Closure, after: boolean) => number;
+/**
+ * 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 declare const signalConnectClosureById: (instance: GObject, signalId: number, detail: number, closure: Closure, after: boolean) => number;
+/**
+ * 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 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;
+/**
+ * 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 declare const signalHandlerBlock: (instance: GObject, handlerId: number) => void;
+/**
+ * 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 declare const signalHandlerDisconnect: (instance: GObject, handlerId: number) => void;
+/**
+ * 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 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.
+ * @param instance - The instance where a signal handler is sought.
+ * @param handlerId - the handler ID.
+ */
 export declare const signalHandlerIsConnected: (instance: GObject, handlerId: number) => 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 declare const signalHandlerUnblock: (instance: GObject, handlerId: number) => void;
+/**
+ * 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 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;
+/**
+ * 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 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.
+ *
+ * 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 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.
+ *
+ * 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 declare const signalHasHandlerPending: (instance: GObject, signalId: number, detail: number, mayBeBlocked: boolean) => 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 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[];
+/**
+ * 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 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;
+/**
+ * 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 declare const signalOverrideClassClosure: (signalId: number, instanceType: number, classClosure: Closure) => void;
+/**
+ * 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 declare const signalOverrideClassHandler: (signalName: string, instanceType: number, classHandler: (...args: unknown[]) => unknown) => 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;
+/**
+ * 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 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 signalRemoveEmissionHook: (signalId: number, hookId: number) => void;
+/**
+ * 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 declare const signalStopEmission: (instance: GObject, signalId: number, detail: number) => void;
+/**
+ * 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 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;
+/**
+ * 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 declare const sourceSetClosure: (source: GLib.Source, closure: Closure) => void;
+/**
+ * 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 declare const sourceSetDummyCallback: (source: GLib.Source) => void;
+/**
+ * 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 declare const strdupValueContents: (value: Value) => 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 declare const typeAddClassPrivate: (classType: number, privateSize: number) => void;
 export declare const typeAddInstancePrivate: (classType: number, privateSize: number) => number;
+/**
+ * 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;
+/**
+ * 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 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> | null) => number[];
 export declare const typeClassAdjustPrivateOffset: (privateSizeOrOffset: number, gClass?: number | null) => void;
+/**
+ * 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 declare const typeClassGet: (type: number) => number;
+/**
+ * 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 declare const typeClassPeek: (type: number) => number | 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;
+/**
+ * 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;
+/**
+ * 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 declare const typeDefaultInterfaceGet: (gType: number) => number;
+/**
+ * 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;
+/**
+ * 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 declare const typeDefaultInterfaceRef: (gType: number) => number;
+/**
+ * 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 declare const typeDefaultInterfaceUnref: (gIface: number) => 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;
+/**
+ * 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 declare const typeEnsure: (type: number) => void;
+/**
+ * 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 declare const typeFreeInstance: (instance: number) => 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;
+/**
+ * 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 declare const typeFundamentalNext: () => number;
+/**
+ * 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 declare const typeGetInstanceCount: (type: number) => number;
+/**
+ * Returns the #GTypePlugin structure for @type.
+ * @param type - #GType to retrieve the plugin for
+ */
 export declare const typeGetPlugin: (type: number) => 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 declare const typeGetQdata: (type: number, quark: number) => number | null;
+/**
+ * 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 declare const typeGetTypeRegistrationSerial: () => number;
+/**
+ * This function used to initialise the type system.  Since GLib 2.36,
+ * the type system is initialised automatically and this function does
+ * nothing.
+ */
 export declare const typeInit: () => void;
+/**
+ * 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 declare const typeInitWithDebugFlags: (debugFlags: TypeDebugFlags) => void;
+/**
+ * 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 declare const typeInterfaceAddPrerequisite: (interfaceType: number, prerequisiteType: number) => void;
+/**
+ * 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 declare const typeInterfaceGetPlugin: (instanceType: number, interfaceType: number) => 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 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> | 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> | 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`     could conform to
+ */
 export declare const typeIsA: (type: number, isAType: number) => 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 declare const typeName: (type: number) => string | null;
 export declare const typeNameFromClass: (gClass: number) => string;
 export declare const typeNameFromInstance: (instance: number) => 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
+ * 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 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
+ */
 export declare const typeQname: (type: number) => number;
+/**
+ * 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 declare const typeQuery: (type: number, query: Ref<number>) => 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;
+/**
+ * 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 declare const typeRegisterFundamental: (typeId: number, typeName: string, info: number, finfo: number, 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 | null) => void;
 export declare const typeTestFlags: (type: number, flags: number) => 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 declare const valueTypeCompatible: (srcType: number, destType: number) => 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 declare const valueTypeTransformable: (srcType: number, destType: number) => boolean;
 export declare const variantGetGtype: () => number;