@gtkx/ffi 0.1.45 → 0.1.46

package/dist/generated/glib/variant-builder.d.ts

@@ -1,14 +1,127 @@
 import { Variant } from "./variant.js";
 import { VariantType } from "./variant-type.js";
+/**
+ * A utility type for constructing container-type #GVariant instances.
+ *
+ * This is an opaque structure and may only be accessed using the
+ * following functions.
+ *
+ * #GVariantBuilder is not threadsafe in any way.  Do not attempt to
+ * access it from more than one thread.
+ */
 export declare class VariantBuilder {
     ptr: unknown;
+    /**
+     * Allocates and initialises a new #GVariantBuilder.
+     *
+     * You should call g_variant_builder_unref() on the return value when it
+     * is no longer needed.  The memory will not be automatically freed by
+     * any other call.
+     *
+     * In most cases it is easier to place a #GVariantBuilder directly on
+     * the stack of the calling function and initialise it with
+     * g_variant_builder_init_static().
+     * @param type - a container type
+     */
     constructor(type: VariantType);
     constructor(_args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * Adds `value` to @builder.
+     *
+     * It is an error to call this function in any way that would create an
+     * inconsistent value to be constructed.  Some examples of this are
+     * putting different types of items into an array, putting the wrong
+     * types or number of items in a tuple, putting more than one value into
+     * a variant, etc.
+     *
+     * If `value` is a floating reference (see g_variant_ref_sink()),
+     * the `builder` instance takes ownership of @value.
+     * @param value - a #GVariant
+     */
     addValue(value: Variant): void;
+    /**
+     * Closes the subcontainer inside the given `builder` that was opened by
+     * the most recent call to g_variant_builder_open().
+     *
+     * It is an error to call this function in any way that would create an
+     * inconsistent value to be constructed (ie: too few values added to the
+     * subcontainer).
+     */
     close(): void;
+    /**
+     * Ends the builder process and returns the constructed value.
+     *
+     * It is not permissible to use `builder` in any way after this call
+     * except for reference counting operations (in the case of a
+     * heap-allocated #GVariantBuilder) or by reinitialising it with
+     * g_variant_builder_init() (in the case of stack-allocated). This
+     * means that for the stack-allocated builders there is no need to
+     * call g_variant_builder_clear() after the call to
+     * g_variant_builder_end().
+     *
+     * It is an error to call this function in any way that would create an
+     * inconsistent value to be constructed (ie: insufficient number of
+     * items added to a container with a specific number of children
+     * required).  It is also an error to call this function if the builder
+     * was created with an indefinite array or maybe type and no children
+     * have been added; in this case it is impossible to infer the type of
+     * the empty array.
+     */
     end(): Variant;
+    /**
+     * Opens a subcontainer inside the given @builder.  When done adding
+     * items to the subcontainer, g_variant_builder_close() must be called. `type` is the type of the container: so to build a tuple of several values, `type` must include the tuple itself.
+     *
+     * It is an error to call this function in any way that would cause an
+     * inconsistent value to be constructed (ie: adding too many values or
+     * a value of an incorrect type).
+     *
+     * Example of building a nested variant:
+     * |[<!-- language="C" -->
+     * GVariantBuilder builder;
+     * guint32 some_number = get_number ();
+     * g_autoptr (GHashTable) some_dict = get_dict ();
+     * GHashTableIter iter;
+     * const gchar *key;
+     * const GVariant *value;
+     * g_autoptr (GVariant) output = NULL;
+     *
+     * g_variant_builder_init (&builder, G_VARIANT_TYPE ("(ua{sv})"));
+     * g_variant_builder_add (&builder, "u", some_number);
+     * g_variant_builder_open (&builder, G_VARIANT_TYPE ("a{sv}"));
+     *
+     * g_hash_table_iter_init (&iter, some_dict);
+     * while (g_hash_table_iter_next (&iter, (gpointer *) &key, (gpointer *) &value))
+     * {
+     * g_variant_builder_open (&builder, G_VARIANT_TYPE ("{sv}"));
+     * g_variant_builder_add (&builder, "s", key);
+     * g_variant_builder_add (&builder, "v", value);
+     * g_variant_builder_close (&builder);
+     * }
+     *
+     * g_variant_builder_close (&builder);
+     *
+     * output = g_variant_builder_end (&builder);
+     * ]|
+     * @param type - the #GVariantType of the container
+     */
     open(type: VariantType): void;
+    /**
+     * Increases the reference count on @builder.
+     *
+     * Don't call this on stack-allocated #GVariantBuilder instances or bad
+     * things will happen.
+     */
     ref(): VariantBuilder;
+    /**
+     * Decreases the reference count on @builder.
+     *
+     * In the event that there are no more references, releases all memory
+     * associated with the #GVariantBuilder.
+     *
+     * Don't call this on stack-allocated #GVariantBuilder instances or bad
+     * things will happen.
+     */
     unref(): void;
 }

package/dist/generated/glib/variant-builder.js

@@ -1,6 +1,15 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { Variant } from "./variant.js";
+/**
+ * A utility type for constructing container-type #GVariant instances.
+ *
+ * This is an opaque structure and may only be accessed using the
+ * following functions.
+ *
+ * #GVariantBuilder is not threadsafe in any way.  Do not attempt to
+ * access it from more than one thread.
+ */
 export class VariantBuilder {
     ptr;
     constructor(...args) {
@@ -21,6 +30,19 @@ export class VariantBuilder {
             },
         ], { type: "boxed", borrowed: true, innerType: "GVariantBuilder" });
     }
+    /**
+     * Adds `value` to @builder.
+     *
+     * It is an error to call this function in any way that would create an
+     * inconsistent value to be constructed.  Some examples of this are
+     * putting different types of items into an array, putting the wrong
+     * types or number of items in a tuple, putting more than one value into
+     * a variant, etc.
+     *
+     * If `value` is a floating reference (see g_variant_ref_sink()),
+     * the `builder` instance takes ownership of @value.
+     * @param value - a #GVariant
+     */
     addValue(value) {
         call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_builder_add_value", [
             {
@@ -38,6 +60,14 @@ export class VariantBuilder {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Closes the subcontainer inside the given `builder` that was opened by
+     * the most recent call to g_variant_builder_open().
+     *
+     * It is an error to call this function in any way that would create an
+     * inconsistent value to be constructed (ie: too few values added to the
+     * subcontainer).
+     */
     close() {
         call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_builder_close", [
             {
@@ -46,6 +76,25 @@ export class VariantBuilder {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Ends the builder process and returns the constructed value.
+     *
+     * It is not permissible to use `builder` in any way after this call
+     * except for reference counting operations (in the case of a
+     * heap-allocated #GVariantBuilder) or by reinitialising it with
+     * g_variant_builder_init() (in the case of stack-allocated). This
+     * means that for the stack-allocated builders there is no need to
+     * call g_variant_builder_clear() after the call to
+     * g_variant_builder_end().
+     *
+     * It is an error to call this function in any way that would create an
+     * inconsistent value to be constructed (ie: insufficient number of
+     * items added to a container with a specific number of children
+     * required).  It is also an error to call this function if the builder
+     * was created with an indefinite array or maybe type and no children
+     * have been added; in this case it is impossible to infer the type of
+     * the empty array.
+     */
     end() {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_builder_end", [
             {
@@ -60,6 +109,43 @@ export class VariantBuilder {
         });
         return getObject(ptr, Variant);
     }
+    /**
+     * Opens a subcontainer inside the given @builder.  When done adding
+     * items to the subcontainer, g_variant_builder_close() must be called. `type` is the type of the container: so to build a tuple of several values, `type` must include the tuple itself.
+     *
+     * It is an error to call this function in any way that would cause an
+     * inconsistent value to be constructed (ie: adding too many values or
+     * a value of an incorrect type).
+     *
+     * Example of building a nested variant:
+     * |[<!-- language="C" -->
+     * GVariantBuilder builder;
+     * guint32 some_number = get_number ();
+     * g_autoptr (GHashTable) some_dict = get_dict ();
+     * GHashTableIter iter;
+     * const gchar *key;
+     * const GVariant *value;
+     * g_autoptr (GVariant) output = NULL;
+     *
+     * g_variant_builder_init (&builder, G_VARIANT_TYPE ("(ua{sv})"));
+     * g_variant_builder_add (&builder, "u", some_number);
+     * g_variant_builder_open (&builder, G_VARIANT_TYPE ("a{sv}"));
+     *
+     * g_hash_table_iter_init (&iter, some_dict);
+     * while (g_hash_table_iter_next (&iter, (gpointer *) &key, (gpointer *) &value))
+     * {
+     * g_variant_builder_open (&builder, G_VARIANT_TYPE ("{sv}"));
+     * g_variant_builder_add (&builder, "s", key);
+     * g_variant_builder_add (&builder, "v", value);
+     * g_variant_builder_close (&builder);
+     * }
+     *
+     * g_variant_builder_close (&builder);
+     *
+     * output = g_variant_builder_end (&builder);
+     * ]|
+     * @param type - the #GVariantType of the container
+     */
     open(type) {
         call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_builder_open", [
             {
@@ -77,6 +163,12 @@ export class VariantBuilder {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Increases the reference count on @builder.
+     *
+     * Don't call this on stack-allocated #GVariantBuilder instances or bad
+     * things will happen.
+     */
     ref() {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_builder_ref", [
             {
@@ -91,6 +183,15 @@ export class VariantBuilder {
         });
         return getObject(ptr, VariantBuilder);
     }
+    /**
+     * Decreases the reference count on @builder.
+     *
+     * In the event that there are no more references, releases all memory
+     * associated with the #GVariantBuilder.
+     *
+     * Don't call this on stack-allocated #GVariantBuilder instances or bad
+     * things will happen.
+     */
     unref() {
         call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_builder_unref", [
             {

package/dist/generated/glib/variant-dict.d.ts

@@ -1,16 +1,190 @@
 import { Variant } from "./variant.js";
 import { VariantType } from "./variant-type.js";
+/**
+ * #GVariantDict is a mutable interface to #GVariant dictionaries.
+ *
+ * It can be used for doing a sequence of dictionary lookups in an
+ * efficient way on an existing #GVariant dictionary or it can be used
+ * to construct new dictionaries with a hashtable-like interface.  It
+ * can also be used for taking existing dictionaries and modifying them
+ * in order to create new ones.
+ *
+ * #GVariantDict can only be used with %G_VARIANT_TYPE_VARDICT
+ * dictionaries.
+ *
+ * It is possible to use #GVariantDict allocated on the stack or on the
+ * heap.  When using a stack-allocated #GVariantDict, you begin with a
+ * call to g_variant_dict_init() and free the resources with a call to
+ * g_variant_dict_clear().
+ *
+ * Heap-allocated #GVariantDict follows normal refcounting rules: you
+ * allocate it with g_variant_dict_new() and use g_variant_dict_ref()
+ * and g_variant_dict_unref().
+ *
+ * g_variant_dict_end() is used to convert the #GVariantDict back into a
+ * dictionary-type #GVariant.  When used with stack-allocated instances,
+ * this also implicitly frees all associated memory, but for
+ * heap-allocated instances, you must still call g_variant_dict_unref()
+ * afterwards.
+ *
+ * You will typically want to use a heap-allocated #GVariantDict when
+ * you expose it as part of an API.  For most other uses, the
+ * stack-allocated form will be more convenient.
+ *
+ * Consider the following two examples that do the same thing in each
+ * style: take an existing dictionary and look up the "count" uint32
+ * key, adding 1 to it if it is found, or returning an error if the
+ * key is not found.  Each returns the new dictionary as a floating
+ * #GVariant.
+ *
+ * ## Using a stack-allocated GVariantDict
+ *
+ * |[<!-- language="C" -->
+ * GVariant *
+ * add_to_count (GVariant  *orig,
+ * GError   **error)
+ * {
+ * GVariantDict dict;
+ * guint32 count;
+ *
+ * g_variant_dict_init (&dict, orig);
+ * if (!g_variant_dict_lookup (&dict, "count", "u", &count))
+ * {
+ * g_set_error (...);
+ * g_variant_dict_clear (&dict);
+ * return NULL;
+ * }
+ *
+ * g_variant_dict_insert (&dict, "count", "u", count + 1);
+ *
+ * return g_variant_dict_end (&dict);
+ * }
+ * ]|
+ *
+ * ## Using heap-allocated GVariantDict
+ *
+ * |[<!-- language="C" -->
+ * GVariant *
+ * add_to_count (GVariant  *orig,
+ * GError   **error)
+ * {
+ * GVariantDict *dict;
+ * GVariant *result;
+ * guint32 count;
+ *
+ * dict = g_variant_dict_new (orig);
+ *
+ * if (g_variant_dict_lookup (dict, "count", "u", &count))
+ * {
+ * g_variant_dict_insert (dict, "count", "u", count + 1);
+ * result = g_variant_dict_end (dict);
+ * }
+ * else
+ * {
+ * g_set_error (...);
+ * result = NULL;
+ * }
+ *
+ * g_variant_dict_unref (dict);
+ *
+ * return result;
+ * }
+ * ]|
+ */
 export declare class VariantDict {
     ptr: unknown;
+    /**
+     * Allocates and initialises a new #GVariantDict.
+     *
+     * You should call g_variant_dict_unref() on the return value when it
+     * is no longer needed.  The memory will not be automatically freed by
+     * any other call.
+     *
+     * In some cases it may be easier to place a #GVariantDict directly on
+     * the stack of the calling function and initialise it with
+     * g_variant_dict_init().  This is particularly useful when you are
+     * using #GVariantDict to construct a #GVariant.
+     * @param fromAsv - the #GVariant with which to initialise the
+     */
     constructor(fromAsv?: Variant | null);
     constructor(_args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * Releases all memory associated with a #GVariantDict without freeing
+     * the #GVariantDict structure itself.
+     *
+     * It typically only makes sense to do this on a stack-allocated
+     * #GVariantDict if you want to abort building the value part-way
+     * through.  This function need not be called if you call
+     * g_variant_dict_end() and it also doesn't need to be called on dicts
+     * allocated with g_variant_dict_new (see g_variant_dict_unref() for
+     * that).
+     *
+     * It is valid to call this function on either an initialised
+     * #GVariantDict or one that was previously cleared by an earlier call
+     * to g_variant_dict_clear() but it is not valid to call this function
+     * on uninitialised memory.
+     */
     clear(): void;
+    /**
+     * Checks if `key` exists in @dict.
+     * @param key - the key to look up in the dictionary
+     */
     contains(key: string): boolean;
+    /**
+     * Returns the current value of `dict` as a #GVariant of type
+     * %G_VARIANT_TYPE_VARDICT, clearing it in the process.
+     *
+     * It is not permissible to use `dict` in any way after this call except
+     * for reference counting operations (in the case of a heap-allocated
+     * #GVariantDict) or by reinitialising it with g_variant_dict_init() (in
+     * the case of stack-allocated).
+     */
     end(): Variant;
+    /**
+     * Inserts (or replaces) a key in a #GVariantDict.
+     *
+     * `value` is consumed if it is floating.
+     * @param key - the key to insert a value for
+     * @param value - the value to insert
+     */
     insertValue(key: string, value: Variant): void;
+    /**
+     * Looks up a value in a #GVariantDict.
+     *
+     * If `key` is not found in @dictionary, %NULL is returned.
+     *
+     * The `expected_type` string specifies what type of value is expected.
+     * If the value associated with `key` has a different type then %NULL is
+     * returned.
+     *
+     * If the key is found and the value has the correct type, it is
+     * returned.  If `expected_type` was specified then any non-%NULL return
+     * value will have this type.
+     * @param key - the key to look up in the dictionary
+     * @param expectedType - a #GVariantType, or %NULL
+     */
     lookupValue(key: string, expectedType?: VariantType | null): Variant | null;
+    /**
+     * Increases the reference count on @dict.
+     *
+     * Don't call this on stack-allocated #GVariantDict instances or bad
+     * things will happen.
+     */
     ref(): VariantDict;
+    /**
+     * Removes a key and its associated value from a #GVariantDict.
+     * @param key - the key to remove
+     */
     remove(key: string): boolean;
+    /**
+     * Decreases the reference count on @dict.
+     *
+     * In the event that there are no more references, releases all memory
+     * associated with the #GVariantDict.
+     *
+     * Don't call this on stack-allocated #GVariantDict instances or bad
+     * things will happen.
+     */
     unref(): void;
 }

package/dist/generated/glib/variant-dict.js

@@ -1,6 +1,97 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { Variant } from "./variant.js";
+/**
+ * #GVariantDict is a mutable interface to #GVariant dictionaries.
+ *
+ * It can be used for doing a sequence of dictionary lookups in an
+ * efficient way on an existing #GVariant dictionary or it can be used
+ * to construct new dictionaries with a hashtable-like interface.  It
+ * can also be used for taking existing dictionaries and modifying them
+ * in order to create new ones.
+ *
+ * #GVariantDict can only be used with %G_VARIANT_TYPE_VARDICT
+ * dictionaries.
+ *
+ * It is possible to use #GVariantDict allocated on the stack or on the
+ * heap.  When using a stack-allocated #GVariantDict, you begin with a
+ * call to g_variant_dict_init() and free the resources with a call to
+ * g_variant_dict_clear().
+ *
+ * Heap-allocated #GVariantDict follows normal refcounting rules: you
+ * allocate it with g_variant_dict_new() and use g_variant_dict_ref()
+ * and g_variant_dict_unref().
+ *
+ * g_variant_dict_end() is used to convert the #GVariantDict back into a
+ * dictionary-type #GVariant.  When used with stack-allocated instances,
+ * this also implicitly frees all associated memory, but for
+ * heap-allocated instances, you must still call g_variant_dict_unref()
+ * afterwards.
+ *
+ * You will typically want to use a heap-allocated #GVariantDict when
+ * you expose it as part of an API.  For most other uses, the
+ * stack-allocated form will be more convenient.
+ *
+ * Consider the following two examples that do the same thing in each
+ * style: take an existing dictionary and look up the "count" uint32
+ * key, adding 1 to it if it is found, or returning an error if the
+ * key is not found.  Each returns the new dictionary as a floating
+ * #GVariant.
+ *
+ * ## Using a stack-allocated GVariantDict
+ *
+ * |[<!-- language="C" -->
+ * GVariant *
+ * add_to_count (GVariant  *orig,
+ * GError   **error)
+ * {
+ * GVariantDict dict;
+ * guint32 count;
+ *
+ * g_variant_dict_init (&dict, orig);
+ * if (!g_variant_dict_lookup (&dict, "count", "u", &count))
+ * {
+ * g_set_error (...);
+ * g_variant_dict_clear (&dict);
+ * return NULL;
+ * }
+ *
+ * g_variant_dict_insert (&dict, "count", "u", count + 1);
+ *
+ * return g_variant_dict_end (&dict);
+ * }
+ * ]|
+ *
+ * ## Using heap-allocated GVariantDict
+ *
+ * |[<!-- language="C" -->
+ * GVariant *
+ * add_to_count (GVariant  *orig,
+ * GError   **error)
+ * {
+ * GVariantDict *dict;
+ * GVariant *result;
+ * guint32 count;
+ *
+ * dict = g_variant_dict_new (orig);
+ *
+ * if (g_variant_dict_lookup (dict, "count", "u", &count))
+ * {
+ * g_variant_dict_insert (dict, "count", "u", count + 1);
+ * result = g_variant_dict_end (dict);
+ * }
+ * else
+ * {
+ * g_set_error (...);
+ * result = NULL;
+ * }
+ *
+ * g_variant_dict_unref (dict);
+ *
+ * return result;
+ * }
+ * ]|
+ */
 export class VariantDict {
     ptr;
     constructor(...args) {
@@ -22,6 +113,22 @@ export class VariantDict {
             },
         ], { type: "boxed", borrowed: true, innerType: "GVariantDict" });
     }
+    /**
+     * Releases all memory associated with a #GVariantDict without freeing
+     * the #GVariantDict structure itself.
+     *
+     * It typically only makes sense to do this on a stack-allocated
+     * #GVariantDict if you want to abort building the value part-way
+     * through.  This function need not be called if you call
+     * g_variant_dict_end() and it also doesn't need to be called on dicts
+     * allocated with g_variant_dict_new (see g_variant_dict_unref() for
+     * that).
+     *
+     * It is valid to call this function on either an initialised
+     * #GVariantDict or one that was previously cleared by an earlier call
+     * to g_variant_dict_clear() but it is not valid to call this function
+     * on uninitialised memory.
+     */
     clear() {
         call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_dict_clear", [
             {
@@ -30,6 +137,10 @@ export class VariantDict {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Checks if `key` exists in @dict.
+     * @param key - the key to look up in the dictionary
+     */
     contains(key) {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_dict_contains", [
             {
@@ -42,6 +153,15 @@ export class VariantDict {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Returns the current value of `dict` as a #GVariant of type
+     * %G_VARIANT_TYPE_VARDICT, clearing it in the process.
+     *
+     * It is not permissible to use `dict` in any way after this call except
+     * for reference counting operations (in the case of a heap-allocated
+     * #GVariantDict) or by reinitialising it with g_variant_dict_init() (in
+     * the case of stack-allocated).
+     */
     end() {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_dict_end", [
             {
@@ -56,6 +176,13 @@ export class VariantDict {
         });
         return getObject(ptr, Variant);
     }
+    /**
+     * Inserts (or replaces) a key in a #GVariantDict.
+     *
+     * `value` is consumed if it is floating.
+     * @param key - the key to insert a value for
+     * @param value - the value to insert
+     */
     insertValue(key, value) {
         call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_dict_insert_value", [
             {
@@ -77,6 +204,21 @@ export class VariantDict {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Looks up a value in a #GVariantDict.
+     *
+     * If `key` is not found in @dictionary, %NULL is returned.
+     *
+     * The `expected_type` string specifies what type of value is expected.
+     * If the value associated with `key` has a different type then %NULL is
+     * returned.
+     *
+     * If the key is found and the value has the correct type, it is
+     * returned.  If `expected_type` was specified then any non-%NULL return
+     * value will have this type.
+     * @param key - the key to look up in the dictionary
+     * @param expectedType - a #GVariantType, or %NULL
+     */
     lookupValue(key, expectedType) {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_dict_lookup_value", [
             {
@@ -107,6 +249,12 @@ export class VariantDict {
             return null;
         return getObject(ptr, Variant);
     }
+    /**
+     * Increases the reference count on @dict.
+     *
+     * Don't call this on stack-allocated #GVariantDict instances or bad
+     * things will happen.
+     */
     ref() {
         const ptr = call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_dict_ref", [
             {
@@ -121,6 +269,10 @@ export class VariantDict {
         });
         return getObject(ptr, VariantDict);
     }
+    /**
+     * Removes a key and its associated value from a #GVariantDict.
+     * @param key - the key to remove
+     */
     remove(key) {
         return call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_dict_remove", [
             {
@@ -133,6 +285,15 @@ export class VariantDict {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Decreases the reference count on @dict.
+     *
+     * In the event that there are no more references, releases all memory
+     * associated with the #GVariantDict.
+     *
+     * Don't call this on stack-allocated #GVariantDict instances or bad
+     * things will happen.
+     */
     unref() {
         call("libgobject-2.0.so.0,libglib-2.0.so.0", "g_variant_dict_unref", [
             {