@gtkx/ffi 0.1.45 → 0.1.46

package/dist/generated/gio/memory-output-stream.js

@@ -2,7 +2,18 @@ import { call } from "@gtkx/native";
 import { NativeError, getObject } from "@gtkx/ffi";
 import * as GLib from "../glib/index.js";
 import { OutputStream } from "./output-stream.js";
+/**
+ * `GMemoryOutputStream` is a class for using arbitrary
+ * memory chunks as output for GIO streaming output operations.
+ *
+ * As of GLib 2.34, `GMemoryOutputStream` trivially implements
+ * [iface@Gio.PollableOutputStream]: it always polls as ready.
+ */
 export class MemoryOutputStream extends OutputStream {
+    /**
+     * Creates a new #GMemoryOutputStream, using g_realloc() and g_free()
+     * for memory allocation.
+     */
     constructor(...args) {
         super(...args);
     }
@@ -12,6 +23,12 @@ export class MemoryOutputStream extends OutputStream {
             borrowed: false,
         });
     }
+    /**
+     * Gets any loaded data from the @ostream.
+     *
+     * Note that the returned pointer may become invalid on the next
+     * write or truncate operation on the stream.
+     */
     getData() {
         return call("libgio-2.0.so.0", "g_memory_output_stream_get_data", [
             {
@@ -20,6 +37,10 @@ export class MemoryOutputStream extends OutputStream {
             },
         ], { type: "int", size: 64, unsigned: true });
     }
+    /**
+     * Returns the number of bytes from the start up to including the last
+     * byte written in the stream that has not been truncated away.
+     */
     getDataSize() {
         return call("libgio-2.0.so.0", "g_memory_output_stream_get_data_size", [
             {
@@ -28,6 +49,23 @@ export class MemoryOutputStream extends OutputStream {
             },
         ], { type: "int", size: 64, unsigned: true });
     }
+    /**
+     * Gets the size of the currently allocated data area (available from
+     * g_memory_output_stream_get_data()).
+     *
+     * You probably don't want to use this function on resizable streams.
+     * See g_memory_output_stream_get_data_size() instead.  For resizable
+     * streams the size returned by this function is an implementation
+     * detail and may be change at any time in response to operations on the
+     * stream.
+     *
+     * If the stream is fixed-sized (ie: no realloc was passed to
+     * g_memory_output_stream_new()) then this is the maximum size of the
+     * stream and further writes will return %G_IO_ERROR_NO_SPACE.
+     *
+     * In any case, if you want the number of bytes currently written to the
+     * stream, use g_memory_output_stream_get_data_size().
+     */
     getSize() {
         return call("libgio-2.0.so.0", "g_memory_output_stream_get_size", [
             {
@@ -36,6 +74,10 @@ export class MemoryOutputStream extends OutputStream {
             },
         ], { type: "int", size: 64, unsigned: true });
     }
+    /**
+     * Returns data from the `ostream` as a #GBytes. `ostream` must be
+     * closed before calling this function.
+     */
     stealAsBytes() {
         const ptr = call("libgio-2.0.so.0", "g_memory_output_stream_steal_as_bytes", [
             {
@@ -50,6 +92,14 @@ export class MemoryOutputStream extends OutputStream {
         });
         return getObject(ptr, GLib.Bytes);
     }
+    /**
+     * Gets any loaded data from the @ostream. Ownership of the data
+     * is transferred to the caller; when no longer needed it must be
+     * freed using the free function set in @ostream's
+     * #GMemoryOutputStream:destroy-function property.
+     *
+     * `ostream` must be closed before calling this function.
+     */
     stealData() {
         return call("libgio-2.0.so.0", "g_memory_output_stream_steal_data", [
             {
@@ -58,6 +108,15 @@ export class MemoryOutputStream extends OutputStream {
             },
         ], { type: "int", size: 64, unsigned: true });
     }
+    /**
+     * Checks if `stream` is actually pollable. Some classes may implement
+     * #GPollableOutputStream but have only certain instances of that
+     * class be pollable. If this method returns %FALSE, then the behavior
+     * of other #GPollableOutputStream methods is undefined.
+     *
+     * For any given stream, the value returned by this method is constant;
+     * a stream cannot switch from pollable to non-pollable or vice versa.
+     */
     canPoll() {
         return call("libgio-2.0.so.0", "g_pollable_output_stream_can_poll", [
             {
@@ -66,6 +125,20 @@ export class MemoryOutputStream extends OutputStream {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Creates a #GSource that triggers when `stream` can be written, or
+     * `cancellable` is triggered or an error occurs. The callback on the
+     * source is of the #GPollableSourceFunc type.
+     *
+     * As with g_pollable_output_stream_is_writable(), it is possible that
+     * the stream may not actually be writable even after the source
+     * triggers, so you should use g_pollable_output_stream_write_nonblocking()
+     * rather than g_output_stream_write() from the callback.
+     *
+     * The behaviour of this method is undefined if
+     * g_pollable_output_stream_can_poll() returns %FALSE for @stream.
+     * @param cancellable - a #GCancellable, or %NULL
+     */
     createSource(cancellable) {
         const ptr = call("libgio-2.0.so.0", "g_pollable_output_stream_create_source", [
             {
@@ -85,6 +158,19 @@ export class MemoryOutputStream extends OutputStream {
         });
         return getObject(ptr, GLib.Source);
     }
+    /**
+     * Checks if `stream` can be written.
+     *
+     * Note that some stream types may not be able to implement this 100%
+     * reliably, and it is possible that a call to g_output_stream_write()
+     * after this returns %TRUE would still block. To guarantee
+     * non-blocking behavior, you should always use
+     * g_pollable_output_stream_write_nonblocking(), which will return a
+     * %G_IO_ERROR_WOULD_BLOCK error rather than blocking.
+     *
+     * The behaviour of this method is undefined if
+     * g_pollable_output_stream_can_poll() returns %FALSE for @stream.
+     */
     isWritable() {
         return call("libgio-2.0.so.0", "g_pollable_output_stream_is_writable", [
             {
@@ -93,6 +179,29 @@ export class MemoryOutputStream extends OutputStream {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Attempts to write up to `count` bytes from `buffer` to @stream, as
+     * with g_output_stream_write(). If `stream` is not currently writable,
+     * this will immediately return %G_IO_ERROR_WOULD_BLOCK, and you can
+     * use g_pollable_output_stream_create_source() to create a #GSource
+     * that will be triggered when `stream` is writable.
+     *
+     * Note that since this method never blocks, you cannot actually
+     * use `cancellable` to cancel it. However, it will return an error
+     * if `cancellable` has already been cancelled when you call, which
+     * may happen if you call this method after a source triggers due
+     * to having been cancelled.
+     *
+     * Also note that if %G_IO_ERROR_WOULD_BLOCK is returned some underlying
+     * transports like D/TLS require that you re-send the same `buffer` and
+     * `count` in the next write call.
+     *
+     * The behaviour of this method is undefined if
+     * g_pollable_output_stream_can_poll() returns %FALSE for @stream.
+     * @param buffer - a buffer to write
+     * @param count - the number of bytes you want to write
+     * @param cancellable - a #GCancellable, or %NULL
+     */
     writeNonblocking(buffer, count, cancellable) {
         const error = { value: null };
         const result = call("libgio-2.0.so.0", "g_pollable_output_stream_write_nonblocking", [
@@ -133,6 +242,31 @@ export class MemoryOutputStream extends OutputStream {
         }
         return result;
     }
+    /**
+     * Attempts to write the bytes contained in the `n_vectors` `vectors` to @stream,
+     * as with g_output_stream_writev(). If `stream` is not currently writable,
+     * this will immediately return %@G_POLLABLE_RETURN_WOULD_BLOCK, and you can
+     * use g_pollable_output_stream_create_source() to create a #GSource
+     * that will be triggered when `stream` is writable. `error` will *not* be
+     * set in that case.
+     *
+     * Note that since this method never blocks, you cannot actually
+     * use `cancellable` to cancel it. However, it will return an error
+     * if `cancellable` has already been cancelled when you call, which
+     * may happen if you call this method after a source triggers due
+     * to having been cancelled.
+     *
+     * Also note that if %G_POLLABLE_RETURN_WOULD_BLOCK is returned some underlying
+     * transports like D/TLS require that you re-send the same `vectors` and
+     * `n_vectors` in the next write call.
+     *
+     * The behaviour of this method is undefined if
+     * g_pollable_output_stream_can_poll() returns %FALSE for @stream.
+     * @param vectors - the buffer containing the #GOutputVectors to write.
+     * @param nVectors - the number of vectors to write
+     * @param bytesWritten - location to store the number of bytes that were
+     * @param cancellable - a #GCancellable, or %NULL
+     */
     writevNonblocking(vectors, nVectors, bytesWritten, cancellable) {
         const error = { value: null };
         const result = call("libgio-2.0.so.0", "g_pollable_output_stream_writev_nonblocking", [
@@ -181,6 +315,9 @@ export class MemoryOutputStream extends OutputStream {
         }
         return result;
     }
+    /**
+     * Tests if the stream supports the #GSeekableIface.
+     */
     canSeek() {
         return call("libgio-2.0.so.0", "g_seekable_can_seek", [
             {
@@ -189,6 +326,10 @@ export class MemoryOutputStream extends OutputStream {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Tests if the length of the stream can be adjusted with
+     * g_seekable_truncate().
+     */
     canTruncate() {
         return call("libgio-2.0.so.0", "g_seekable_can_truncate", [
             {
@@ -197,6 +338,25 @@ export class MemoryOutputStream extends OutputStream {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Seeks in the stream by the given @offset, modified by @type.
+     *
+     * Attempting to seek past the end of the stream will have different
+     * results depending on if the stream is fixed-sized or resizable.  If
+     * the stream is resizable then seeking past the end and then writing
+     * will result in zeros filling the empty space.  Seeking past the end
+     * of a resizable stream and reading will result in EOF.  Seeking past
+     * the end of a fixed-sized stream will fail.
+     *
+     * Any operation that would result in a negative offset will fail.
+     *
+     * If `cancellable` is not %NULL, then the operation can be cancelled by
+     * triggering the cancellable object from another thread. If the operation
+     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+     * @param offset - a #goffset.
+     * @param type - a #GSeekType.
+     * @param cancellable - optional #GCancellable object, %NULL to ignore.
+     */
     seek(offset, type, cancellable) {
         const error = { value: null };
         const result = call("libgio-2.0.so.0", "g_seekable_seek", [
@@ -234,6 +394,9 @@ export class MemoryOutputStream extends OutputStream {
         }
         return result;
     }
+    /**
+     * Tells the current position within the stream.
+     */
     tell() {
         return call("libgio-2.0.so.0", "g_seekable_tell", [
             {
@@ -242,6 +405,19 @@ export class MemoryOutputStream extends OutputStream {
             },
         ], { type: "int", size: 64, unsigned: false });
     }
+    /**
+     * Sets the length of the stream to @offset. If the stream was previously
+     * larger than @offset, the extra data is discarded. If the stream was
+     * previously shorter than @offset, it is extended with NUL ('\0') bytes.
+     *
+     * If `cancellable` is not %NULL, then the operation can be cancelled by
+     * triggering the cancellable object from another thread. If the operation
+     * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
+     * operation was partially finished when the operation was cancelled the
+     * partial result will be returned, without an error.
+     * @param offset - new length for @seekable, in bytes.
+     * @param cancellable - optional #GCancellable object, %NULL to ignore.
+     */
     truncate(offset, cancellable) {
         const error = { value: null };
         const result = call("libgio-2.0.so.0", "g_seekable_truncate", [

package/dist/generated/gio/menu-attribute-iter.d.ts

@@ -1,12 +1,57 @@
 import { Ref } from "@gtkx/native";
 import * as GLib from "../glib/index.js";
 import * as GObject from "../gobject/index.js";
+/**
+ * #GMenuAttributeIter is an opaque structure type.  You must access it
+ * using the functions below.
+ */
 export declare class MenuAttributeIter extends GObject.GObject {
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * Gets the name of the attribute at the current iterator position, as
+     * a string.
+     *
+     * The iterator is not advanced.
+     */
     getName(): string;
+    /**
+     * This function combines g_menu_attribute_iter_next() with
+     * g_menu_attribute_iter_get_name() and g_menu_attribute_iter_get_value().
+     *
+     * First the iterator is advanced to the next (possibly first) attribute.
+     * If that fails, then %FALSE is returned and there are no other
+     * effects.
+     *
+     * If successful, `name` and `value` are set to the name and value of the
+     * attribute that has just been advanced to.  At this point,
+     * g_menu_attribute_iter_get_name() and g_menu_attribute_iter_get_value() will
+     * return the same values again.
+     *
+     * The value returned in `name` remains valid for as long as the iterator
+     * remains at the current position.  The value returned in `value` must
+     * be unreffed using g_variant_unref() when it is no longer in use.
+     * @param outName - the type of the attribute
+     * @param value - the attribute value
+     */
     getNext(outName?: Ref<string> | null, value?: Ref<GLib.Variant> | null): boolean;
+    /**
+     * Gets the value of the attribute at the current iterator position.
+     *
+     * The iterator is not advanced.
+     */
     getValue(): GLib.Variant;
+    /**
+     * Attempts to advance the iterator to the next (possibly first)
+     * attribute.
+     *
+     * %TRUE is returned on success, or %FALSE if there are no more
+     * attributes.
+     *
+     * You must call this function when you first acquire the iterator
+     * to advance it to the first attribute (and determine if the first
+     * attribute exists at all).
+     */
     next(): boolean;
     connect(signal: "notify", handler: (self: MenuAttributeIter, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;

package/dist/generated/gio/menu-attribute-iter.js

@@ -2,6 +2,10 @@ import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import * as GLib from "../glib/index.js";
 import * as GObject from "../gobject/index.js";
+/**
+ * #GMenuAttributeIter is an opaque structure type.  You must access it
+ * using the functions below.
+ */
 export class MenuAttributeIter extends GObject.GObject {
     constructor(...args) {
         super(...args);
@@ -17,6 +21,12 @@ export class MenuAttributeIter extends GObject.GObject {
             { type: { type: "gobject" }, value: null },
         ], { type: "gobject", borrowed: true });
     }
+    /**
+     * Gets the name of the attribute at the current iterator position, as
+     * a string.
+     *
+     * The iterator is not advanced.
+     */
     getName() {
         return call("libgio-2.0.so.0", "g_menu_attribute_iter_get_name", [
             {
@@ -25,6 +35,25 @@ export class MenuAttributeIter extends GObject.GObject {
             },
         ], { type: "string", borrowed: true });
     }
+    /**
+     * This function combines g_menu_attribute_iter_next() with
+     * g_menu_attribute_iter_get_name() and g_menu_attribute_iter_get_value().
+     *
+     * First the iterator is advanced to the next (possibly first) attribute.
+     * If that fails, then %FALSE is returned and there are no other
+     * effects.
+     *
+     * If successful, `name` and `value` are set to the name and value of the
+     * attribute that has just been advanced to.  At this point,
+     * g_menu_attribute_iter_get_name() and g_menu_attribute_iter_get_value() will
+     * return the same values again.
+     *
+     * The value returned in `name` remains valid for as long as the iterator
+     * remains at the current position.  The value returned in `value` must
+     * be unreffed using g_variant_unref() when it is no longer in use.
+     * @param outName - the type of the attribute
+     * @param value - the attribute value
+     */
     getNext(outName, value) {
         return call("libgio-2.0.so.0", "g_menu_attribute_iter_get_next", [
             {
@@ -50,6 +79,11 @@ export class MenuAttributeIter extends GObject.GObject {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Gets the value of the attribute at the current iterator position.
+     *
+     * The iterator is not advanced.
+     */
     getValue() {
         const ptr = call("libgio-2.0.so.0", "g_menu_attribute_iter_get_value", [
             {
@@ -64,6 +98,17 @@ export class MenuAttributeIter extends GObject.GObject {
         });
         return getObject(ptr, GLib.Variant);
     }
+    /**
+     * Attempts to advance the iterator to the next (possibly first)
+     * attribute.
+     *
+     * %TRUE is returned on success, or %FALSE if there are no more
+     * attributes.
+     *
+     * You must call this function when you first acquire the iterator
+     * to advance it to the first attribute (and determine if the first
+     * attribute exists at all).
+     */
     next() {
         return call("libgio-2.0.so.0", "g_menu_attribute_iter_next", [
             {

package/dist/generated/gio/menu-item.d.ts

@@ -2,22 +2,265 @@ import { Icon } from "./icon.js";
 import { MenuModel } from "./menu-model.js";
 import * as GLib from "../glib/index.js";
 import * as GObject from "../gobject/index.js";
+/**
+ * #GMenuItem is an opaque structure type.  You must access it using the
+ * functions below.
+ */
 export declare class MenuItem extends GObject.GObject {
+    /**
+     * Creates a new #GMenuItem.
+     *
+     * If `label` is non-%NULL it is used to set the "label" attribute of the
+     * new item.
+     *
+     * If `detailed_action` is non-%NULL it is used to set the "action" and
+     * possibly the "target" attribute of the new item.  See
+     * g_menu_item_set_detailed_action() for more information.
+     * @param label - the section label, or %NULL
+     * @param detailedAction - the detailed action string, or %NULL
+     */
     constructor(label?: string | null, detailedAction?: string | null);
     constructor(...args: unknown[]);
+    /**
+     * Creates a #GMenuItem as an exact copy of an existing menu item in a
+     * #GMenuModel.
+     *
+     * `item_index` must be valid (ie: be sure to call
+     * g_menu_model_get_n_items() first).
+     * @param model - a #GMenuModel
+     * @param itemIndex - the index of an item in @model
+     */
     static itemNewFromModel(model: MenuModel, itemIndex: number): MenuItem;
+    /**
+     * Creates a new #GMenuItem representing a section.
+     *
+     * This is a convenience API around g_menu_item_new() and
+     * g_menu_item_set_section().
+     *
+     * The effect of having one menu appear as a section of another is
+     * exactly as it sounds: the items from `section` become a direct part of
+     * the menu that `menu_item` is added to.
+     *
+     * Visual separation is typically displayed between two non-empty
+     * sections.  If `label` is non-%NULL then it will be incorporated into
+     * this visual indication.  This allows for labeled subsections of a
+     * menu.
+     *
+     * As a simple example, consider a typical "Edit" menu from a simple
+     * program.  It probably contains an "Undo" and "Redo" item, followed by
+     * a separator, followed by "Cut", "Copy" and "Paste".
+     *
+     * This would be accomplished by creating three #GMenu instances.  The
+     * first would be populated with the "Undo" and "Redo" items, and the
+     * second with the "Cut", "Copy" and "Paste" items.  The first and
+     * second menus would then be added as submenus of the third.  In XML
+     * format, this would look something like the following:
+     * |[
+     * <menu id='edit-menu'>
+     * <section>
+     * <item label='Undo'/>
+     * <item label='Redo'/>
+     * </section>
+     * <section>
+     * <item label='Cut'/>
+     * <item label='Copy'/>
+     * <item label='Paste'/>
+     * </section>
+     * </menu>
+     * ]|
+     *
+     * The following example is exactly equivalent.  It is more illustrative
+     * of the exact relationship between the menus and items (keeping in
+     * mind that the 'link' element defines a new menu that is linked to the
+     * containing one).  The style of the second example is more verbose and
+     * difficult to read (and therefore not recommended except for the
+     * purpose of understanding what is really going on).
+     * |[
+     * <menu id='edit-menu'>
+     * <item>
+     * <link name='section'>
+     * <item label='Undo'/>
+     * <item label='Redo'/>
+     * </link>
+     * </item>
+     * <item>
+     * <link name='section'>
+     * <item label='Cut'/>
+     * <item label='Copy'/>
+     * <item label='Paste'/>
+     * </link>
+     * </item>
+     * </menu>
+     * ]|
+     * @param label - the section label, or %NULL
+     * @param section - a #GMenuModel with the items of the section
+     */
     static itemNewSection(section: MenuModel, label?: string | null): MenuItem;
+    /**
+     * Creates a new #GMenuItem representing a submenu.
+     *
+     * This is a convenience API around g_menu_item_new() and
+     * g_menu_item_set_submenu().
+     * @param label - the section label, or %NULL
+     * @param submenu - a #GMenuModel with the items of the submenu
+     */
     static itemNewSubmenu(submenu: MenuModel, label?: string | null): MenuItem;
     protected createPtr(args: unknown[]): unknown;
+    /**
+     * Queries the named `attribute` on @menu_item.
+     *
+     * If `expected_type` is specified and the attribute does not have this
+     * type, %NULL is returned.  %NULL is also returned if the attribute
+     * simply does not exist.
+     * @param attribute - the attribute name to query
+     * @param expectedType - the expected type of the attribute
+     */
     getAttributeValue(attribute: string, expectedType?: GLib.VariantType | null): GLib.Variant | null;
+    /**
+     * Queries the named `link` on @menu_item.
+     * @param link - the link name to query
+     */
     getLink(link: string): MenuModel | null;
+    /**
+     * Sets or unsets the "action" and "target" attributes of @menu_item.
+     *
+     * If `action` is %NULL then both the "action" and "target" attributes
+     * are unset (and `target_value` is ignored).
+     *
+     * If `action` is non-%NULL then the "action" attribute is set.  The
+     * "target" attribute is then set to the value of `target_value` if it is
+     * non-%NULL or unset otherwise.
+     *
+     * Normal menu items (ie: not submenu, section or other custom item
+     * types) are expected to have the "action" attribute set to identify
+     * the action that they are associated with.  The state type of the
+     * action help to determine the disposition of the menu item.  See
+     * #GAction and #GActionGroup for an overview of actions.
+     *
+     * In general, clicking on the menu item will result in activation of
+     * the named action with the "target" attribute given as the parameter
+     * to the action invocation.  If the "target" attribute is not set then
+     * the action is invoked with no parameter.
+     *
+     * If the action has no state then the menu item is usually drawn as a
+     * plain menu item (ie: with no additional decoration).
+     *
+     * If the action has a boolean state then the menu item is usually drawn
+     * as a toggle menu item (ie: with a checkmark or equivalent
+     * indication).  The item should be marked as 'toggled' or 'checked'
+     * when the boolean state is %TRUE.
+     *
+     * If the action has a string state then the menu item is usually drawn
+     * as a radio menu item (ie: with a radio bullet or equivalent
+     * indication).  The item should be marked as 'selected' when the string
+     * state is equal to the value of the `target` property.
+     *
+     * See g_menu_item_set_action_and_target() or
+     * g_menu_item_set_detailed_action() for two equivalent calls that are
+     * probably more convenient for most uses.
+     * @param action - the name of the action for this item
+     * @param targetValue - a #GVariant to use as the action target
+     */
     setActionAndTargetValue(action?: string | null, targetValue?: GLib.Variant | null): void;
+    /**
+     * Sets or unsets an attribute on @menu_item.
+     *
+     * The attribute to set or unset is specified by @attribute. This
+     * can be one of the standard attribute names %G_MENU_ATTRIBUTE_LABEL,
+     * %G_MENU_ATTRIBUTE_ACTION, %G_MENU_ATTRIBUTE_TARGET, or a custom
+     * attribute name.
+     * Attribute names are restricted to lowercase characters, numbers
+     * and '-'. Furthermore, the names must begin with a lowercase character,
+     * must not end with a '-', and must not contain consecutive dashes.
+     *
+     * must consist only of lowercase
+     * ASCII characters, digits and '-'.
+     *
+     * If `value` is non-%NULL then it is used as the new value for the
+     * attribute.  If `value` is %NULL then the attribute is unset. If
+     * the `value` #GVariant is floating, it is consumed.
+     *
+     * See also g_menu_item_set_attribute() for a more convenient way to do
+     * the same.
+     * @param attribute - the attribute to set
+     * @param value - a #GVariant to use as the value, or %NULL
+     */
     setAttributeValue(attribute: string, value?: GLib.Variant | null): void;
+    /**
+     * Sets the "action" and possibly the "target" attribute of @menu_item.
+     *
+     * The format of `detailed_action` is the same format parsed by
+     * g_action_parse_detailed_name().
+     *
+     * See g_menu_item_set_action_and_target() or
+     * g_menu_item_set_action_and_target_value() for more flexible (but
+     * slightly less convenient) alternatives.
+     *
+     * See also g_menu_item_set_action_and_target_value() for a description of
+     * the semantics of the action and target attributes.
+     * @param detailedAction - the "detailed" action string
+     */
     setDetailedAction(detailedAction: string): void;
+    /**
+     * Sets (or unsets) the icon on @menu_item.
+     *
+     * This call is the same as calling g_icon_serialize() and using the
+     * result as the value to g_menu_item_set_attribute_value() for
+     * %G_MENU_ATTRIBUTE_ICON.
+     *
+     * This API is only intended for use with "noun" menu items; things like
+     * bookmarks or applications in an "Open With" menu.  Don't use it on
+     * menu items corresponding to verbs (eg: stock icons for 'Save' or
+     * 'Quit').
+     *
+     * If `icon` is %NULL then the icon is unset.
+     * @param icon - a #GIcon, or %NULL
+     */
     setIcon(icon: Icon): void;
+    /**
+     * Sets or unsets the "label" attribute of @menu_item.
+     *
+     * If `label` is non-%NULL it is used as the label for the menu item.  If
+     * it is %NULL then the label attribute is unset.
+     * @param label - the label to set, or %NULL to unset
+     */
     setLabel(label?: string | null): void;
+    /**
+     * Creates a link from `menu_item` to `model` if non-%NULL, or unsets it.
+     *
+     * Links are used to establish a relationship between a particular menu
+     * item and another menu.  For example, %G_MENU_LINK_SUBMENU is used to
+     * associate a submenu with a particular menu item, and %G_MENU_LINK_SECTION
+     * is used to create a section. Other types of link can be used, but there
+     * is no guarantee that clients will be able to make sense of them.
+     * Link types are restricted to lowercase characters, numbers
+     * and '-'. Furthermore, the names must begin with a lowercase character,
+     * must not end with a '-', and must not contain consecutive dashes.
+     * @param link - type of link to establish or unset
+     * @param model - the #GMenuModel to link to (or %NULL to unset)
+     */
     setLink(link: string, model?: MenuModel | null): void;
+    /**
+     * Sets or unsets the "section" link of `menu_item` to @section.
+     *
+     * The effect of having one menu appear as a section of another is
+     * exactly as it sounds: the items from `section` become a direct part of
+     * the menu that `menu_item` is added to.  See g_menu_item_new_section()
+     * for more information about what it means for a menu item to be a
+     * section.
+     * @param section - a #GMenuModel, or %NULL
+     */
     setSection(section?: MenuModel | null): void;
+    /**
+     * Sets or unsets the "submenu" link of `menu_item` to @submenu.
+     *
+     * If `submenu` is non-%NULL, it is linked to.  If it is %NULL then the
+     * link is unset.
+     *
+     * The effect of having one menu appear as a submenu of another is
+     * exactly as it sounds.
+     * @param submenu - a #GMenuModel, or %NULL
+     */
     setSubmenu(submenu?: MenuModel | null): void;
     connect(signal: "notify", handler: (self: MenuItem, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;