@gtkx/ffi 0.1.45 → 0.1.47

package/dist/generated/gio/menu-model.js

@@ -4,6 +4,124 @@ import { MenuAttributeIter } from "./menu-attribute-iter.js";
 import { MenuLinkIter } from "./menu-link-iter.js";
 import * as GLib from "../glib/index.js";
 import * as GObject from "../gobject/index.js";
+/**
+ * `GMenuModel` represents the contents of a menu — an ordered list of
+ * menu items. The items are associated with actions, which can be
+ * activated through them. Items can be grouped in sections, and may
+ * have submenus associated with them. Both items and sections usually
+ * have some representation data, such as labels or icons. The type of
+ * the associated action (ie whether it is stateful, and what kind of
+ * state it has) can influence the representation of the item.
+ *
+ * The conceptual model of menus in `GMenuModel` is hierarchical:
+ * sections and submenus are again represented by `GMenuModel`s.
+ * Menus themselves do not define their own roles. Rather, the role
+ * of a particular `GMenuModel` is defined by the item that references
+ * it (or, in the case of the ‘root’ menu, is defined by the context
+ * in which it is used).
+ *
+ * As an example, consider the visible portions of this menu:
+ *
+ * ## An example menu
+ *
+ *
+ *
+ * While this kind of deeply nested menu is no longer considered good UI
+ * practice, it serves as a good example of the concepts in `GMenuModel`.
+ * There are 8 ‘menus’ visible in the screenshot: one menubar, two
+ * submenus and 5 sections:
+ *
+ * - the toplevel menubar (containing 4 items)
+ * - the View submenu (containing 3 sections)
+ * - the first section of the View submenu (containing 2 items)
+ * - the second section of the View submenu (containing 1 item)
+ * - the final section of the View submenu (containing 1 item)
+ * - the Highlight Mode submenu (containing 2 sections)
+ * - the Sources section (containing 2 items)
+ * - the Markup section (containing 2 items)
+ *
+ * The [example](#a-menu-example) illustrates the conceptual connection between
+ * these 8 menus. Each large block in the figure represents a menu and the
+ * smaller blocks within the large block represent items in that menu. Some
+ * items contain references to other menus.
+ *
+ * ## A menu example
+ *
+ *
+ *
+ * Notice that the separators visible in the [example](#an-example-menu)
+ * appear nowhere in the [menu model](#a-menu-example). This is because
+ * separators are not explicitly represented in the menu model. Instead,
+ * a separator is inserted between any two non-empty sections of a menu.
+ * Section items can have labels just like any other item. In that case,
+ * a display system may show a section header instead of a separator.
+ *
+ * The motivation for this abstract model of application controls is
+ * that modern user interfaces tend to make these controls available
+ * outside the application. Examples include global menus, jumplists,
+ * dash boards, etc. To support such uses, it is necessary to ‘export’
+ * information about actions and their representation in menus, which
+ * is exactly what the action group exporter and the menu model exporter do for
+ * [iface@Gio.ActionGroup] and [class@Gio.MenuModel]. The client-side
+ * counterparts to make use of the exported information are
+ * [class@Gio.DBusActionGroup] and [class@Gio.DBusMenuModel].
+ *
+ * The API of `GMenuModel` is very generic, with iterators for the
+ * attributes and links of an item, see
+ * [method@Gio.MenuModel.iterate_item_attributes] and
+ * [method@Gio.MenuModel.iterate_item_links]. The ‘standard’ attributes and
+ * link types have predefined names: `G_MENU_ATTRIBUTE_LABEL`,
+ * `G_MENU_ATTRIBUTE_ACTION`, `G_MENU_ATTRIBUTE_TARGET`, `G_MENU_LINK_SECTION`
+ * and `G_MENU_LINK_SUBMENU`.
+ *
+ * Items in a `GMenuModel` represent active controls if they refer to
+ * an action that can get activated when the user interacts with the
+ * menu item. The reference to the action is encoded by the string ID
+ * in the `G_MENU_ATTRIBUTE_ACTION` attribute. An action ID uniquely
+ * identifies an action in an action group. Which action group(s) provide
+ * actions depends on the context in which the menu model is used.
+ * E.g. when the model is exported as the application menu of a
+ * `GtkApplication`,
+ * actions can be application-wide or window-specific (and thus come from
+ * two different action groups). By convention, the application-wide actions
+ * have names that start with `app.`, while the names of window-specific
+ * actions start with `win.`.
+ *
+ * While a wide variety of stateful actions is possible, the following
+ * is the minimum that is expected to be supported by all users of exported
+ * menu information:
+ * - an action with no parameter type and no state
+ * - an action with no parameter type and boolean state
+ * - an action with string parameter type and string state
+ *
+ * ## Stateless
+ *
+ * A stateless action typically corresponds to an ordinary menu item.
+ *
+ * Selecting such a menu item will activate the action (with no parameter).
+ *
+ * ## Boolean State
+ *
+ * An action with a boolean state will most typically be used with a ‘toggle’
+ * or ‘switch’ menu item. The state can be set directly, but activating the
+ * action (with no parameter) results in the state being toggled.
+ *
+ * Selecting a toggle menu item will activate the action. The menu item should
+ * be rendered as ‘checked’ when the state is true.
+ *
+ * ## String Parameter and State
+ *
+ * Actions with string parameters and state will most typically be used to
+ * represent an enumerated choice over the items available for a group of
+ * radio menu items. Activating the action with a string parameter is
+ * equivalent to setting that parameter as the state.
+ *
+ * Radio menu items, in addition to being associated with the action, will
+ * have a target value. Selecting that menu item will result in activation
+ * of the action with the target value as the parameter. The menu item should
+ * be rendered as ‘selected’ when the state of the action is equal to the
+ * target value of the menu item.
+ */
 const SIGNAL_META = {
     "items-changed": {
         params: [
@@ -29,6 +147,22 @@ export class MenuModel extends GObject.GObject {
             { type: { type: "gobject" }, value: null },
         ], { type: "gobject", borrowed: true });
     }
+    /**
+     * Queries the item at position `item_index` in `model` for the attribute
+     * specified by @attribute.
+     *
+     * If `expected_type` is non-%NULL then it specifies the expected type of
+     * the attribute.  If it is %NULL then any type will be accepted.
+     *
+     * If the attribute exists and matches `expected_type` (or if the
+     * expected type is unspecified) then the value is returned.
+     *
+     * If the attribute does not exist, or does not match the expected type
+     * then %NULL is returned.
+     * @param itemIndex - the index of the item
+     * @param attribute - the attribute to query
+     * @param expectedType - the expected type of the attribute, or
+     */
     getItemAttributeValue(itemIndex, attribute, expectedType) {
         const ptr = call("libgio-2.0.so.0", "g_menu_model_get_item_attribute_value", [
             {
@@ -63,6 +197,15 @@ export class MenuModel extends GObject.GObject {
             return null;
         return getObject(ptr, GLib.Variant);
     }
+    /**
+     * Queries the item at position `item_index` in `model` for the link
+     * specified by @link.
+     *
+     * If the link exists, the linked #GMenuModel is returned.  If the link
+     * does not exist, %NULL is returned.
+     * @param itemIndex - the index of the item
+     * @param link - the link to query
+     */
     getItemLink(itemIndex, link) {
         const ptr = call("libgio-2.0.so.0", "g_menu_model_get_item_link", [
             {
@@ -82,6 +225,9 @@ export class MenuModel extends GObject.GObject {
             return null;
         return getObject(ptr, MenuModel);
     }
+    /**
+     * Query the number of items in @model.
+     */
     getNItems() {
         return call("libgio-2.0.so.0", "g_menu_model_get_n_items", [
             {
@@ -90,6 +236,12 @@ export class MenuModel extends GObject.GObject {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    /**
+     * Queries if `model` is mutable.
+     *
+     * An immutable #GMenuModel will never emit the #GMenuModel::items-changed
+     * signal. Consumers of the model may make optimisations accordingly.
+     */
     isMutable() {
         return call("libgio-2.0.so.0", "g_menu_model_is_mutable", [
             {
@@ -98,6 +250,26 @@ export class MenuModel extends GObject.GObject {
             },
         ], { type: "boolean" });
     }
+    /**
+     * Requests emission of the #GMenuModel::items-changed signal on @model.
+     *
+     * This function should never be called except by #GMenuModel
+     * subclasses.  Any other calls to this function will very likely lead
+     * to a violation of the interface of the model.
+     *
+     * The implementation should update its internal representation of the
+     * menu before emitting the signal.  The implementation should further
+     * expect to receive queries about the new state of the menu (and
+     * particularly added menu items) while signal handlers are running.
+     *
+     * The implementation must dispatch this call directly from a mainloop
+     * entry and not in response to calls -- particularly those from the
+     * #GMenuModel API.  Said another way: the menu must not change while
+     * user code is running without returning to the mainloop.
+     * @param position - the position of the change
+     * @param removed - the number of items removed
+     * @param added - the number of items added
+     */
     itemsChanged(position, removed, added) {
         call("libgio-2.0.so.0", "g_menu_model_items_changed", [
             {
@@ -118,6 +290,13 @@ export class MenuModel extends GObject.GObject {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Creates a #GMenuAttributeIter to iterate over the attributes of
+     * the item at position `item_index` in @model.
+     *
+     * You must free the iterator with g_object_unref() when you are done.
+     * @param itemIndex - the index of the item
+     */
     iterateItemAttributes(itemIndex) {
         const ptr = call("libgio-2.0.so.0", "g_menu_model_iterate_item_attributes", [
             {
@@ -131,6 +310,13 @@ export class MenuModel extends GObject.GObject {
         ], { type: "gobject", borrowed: true });
         return getObject(ptr, MenuAttributeIter);
     }
+    /**
+     * Creates a #GMenuLinkIter to iterate over the links of the item at
+     * position `item_index` in @model.
+     *
+     * You must free the iterator with g_object_unref() when you are done.
+     * @param itemIndex - the index of the item
+     */
     iterateItemLinks(itemIndex) {
         const ptr = call("libgio-2.0.so.0", "g_menu_model_iterate_item_links", [
             {

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

@@ -1,23 +1,163 @@
 import { MenuItem } from "./menu-item.js";
 import * as GObject from "../gobject/index.js";
 import { MenuModel } from "./menu-model.js";
+/**
+ * `GMenu` is a simple implementation of [class@Gio.MenuModel].
+ * You populate a `GMenu` by adding [class@Gio.MenuItem] instances to it.
+ *
+ * There are some convenience functions to allow you to directly
+ * add items (avoiding [class@Gio.MenuItem]) for the common cases. To add
+ * a regular item, use [method@Gio.Menu.insert]. To add a section, use
+ * [method@Gio.Menu.insert_section]. To add a submenu, use
+ * [method@Gio.Menu.insert_submenu].
+ */
 export declare class Menu extends MenuModel {
+    /**
+     * Creates a new #GMenu.
+     *
+     * The new menu has no items.
+     */
     constructor(...args: unknown[]);
     protected createPtr(_args: unknown[]): unknown;
+    /**
+     * Convenience function for appending a normal menu item to the end of
+     * @menu.  Combine g_menu_item_new() and g_menu_insert_item() for a more
+     * flexible alternative.
+     * @param label - the section label, or %NULL
+     * @param detailedAction - the detailed action string, or %NULL
+     */
     append(label?: string | null, detailedAction?: string | null): void;
+    /**
+     * Appends `item` to the end of @menu.
+     *
+     * See g_menu_insert_item() for more information.
+     * @param item - a #GMenuItem to append
+     */
     appendItem(item: MenuItem): void;
+    /**
+     * Convenience function for appending a section menu item to the end of
+     * @menu.  Combine g_menu_item_new_section() and g_menu_insert_item() for a
+     * more flexible alternative.
+     * @param label - the section label, or %NULL
+     * @param section - a #GMenuModel with the items of the section
+     */
     appendSection(section: MenuModel, label?: string | null): void;
+    /**
+     * Convenience function for appending a submenu menu item to the end of
+     * @menu.  Combine g_menu_item_new_submenu() and g_menu_insert_item() for a
+     * more flexible alternative.
+     * @param label - the section label, or %NULL
+     * @param submenu - a #GMenuModel with the items of the submenu
+     */
     appendSubmenu(submenu: MenuModel, label?: string | null): void;
+    /**
+     * Marks `menu` as frozen.
+     *
+     * After the menu is frozen, it is an error to attempt to make any
+     * changes to it.  In effect this means that the #GMenu API must no
+     * longer be used.
+     *
+     * This function causes g_menu_model_is_mutable() to begin returning
+     * %FALSE, which has some positive performance implications.
+     */
     freeze(): void;
+    /**
+     * Convenience function for inserting a normal menu item into @menu.
+     * Combine g_menu_item_new() and g_menu_insert_item() for a more flexible
+     * alternative.
+     * @param position - the position at which to insert the item
+     * @param label - the section label, or %NULL
+     * @param detailedAction - the detailed action string, or %NULL
+     */
     insert(position: number, label?: string | null, detailedAction?: string | null): void;
+    /**
+     * Inserts `item` into @menu.
+     *
+     * The "insertion" is actually done by copying all of the attribute and
+     * link values of `item` and using them to form a new item within @menu.
+     * As such, `item` itself is not really inserted, but rather, a menu item
+     * that is exactly the same as the one presently described by @item.
+     *
+     * This means that `item` is essentially useless after the insertion
+     * occurs.  Any changes you make to it are ignored unless it is inserted
+     * again (at which point its updated values will be copied).
+     *
+     * You should probably just free `item` once you're done.
+     *
+     * There are many convenience functions to take care of common cases.
+     * See g_menu_insert(), g_menu_insert_section() and
+     * g_menu_insert_submenu() as well as "prepend" and "append" variants of
+     * each of these functions.
+     * @param position - the position at which to insert the item
+     * @param item - the #GMenuItem to insert
+     */
     insertItem(position: number, item: MenuItem): void;
+    /**
+     * Convenience function for inserting a section menu item into @menu.
+     * Combine g_menu_item_new_section() and g_menu_insert_item() for a more
+     * flexible alternative.
+     * @param position - the position at which to insert the item
+     * @param label - the section label, or %NULL
+     * @param section - a #GMenuModel with the items of the section
+     */
     insertSection(position: number, section: MenuModel, label?: string | null): void;
+    /**
+     * Convenience function for inserting a submenu menu item into @menu.
+     * Combine g_menu_item_new_submenu() and g_menu_insert_item() for a more
+     * flexible alternative.
+     * @param position - the position at which to insert the item
+     * @param label - the section label, or %NULL
+     * @param submenu - a #GMenuModel with the items of the submenu
+     */
     insertSubmenu(position: number, submenu: MenuModel, label?: string | null): void;
+    /**
+     * Convenience function for prepending a normal menu item to the start
+     * of @menu.  Combine g_menu_item_new() and g_menu_insert_item() for a more
+     * flexible alternative.
+     * @param label - the section label, or %NULL
+     * @param detailedAction - the detailed action string, or %NULL
+     */
     prepend(label?: string | null, detailedAction?: string | null): void;
+    /**
+     * Prepends `item` to the start of @menu.
+     *
+     * See g_menu_insert_item() for more information.
+     * @param item - a #GMenuItem to prepend
+     */
     prependItem(item: MenuItem): void;
+    /**
+     * Convenience function for prepending a section menu item to the start
+     * of @menu.  Combine g_menu_item_new_section() and g_menu_insert_item() for
+     * a more flexible alternative.
+     * @param label - the section label, or %NULL
+     * @param section - a #GMenuModel with the items of the section
+     */
     prependSection(section: MenuModel, label?: string | null): void;
+    /**
+     * Convenience function for prepending a submenu menu item to the start
+     * of @menu.  Combine g_menu_item_new_submenu() and g_menu_insert_item() for
+     * a more flexible alternative.
+     * @param label - the section label, or %NULL
+     * @param submenu - a #GMenuModel with the items of the submenu
+     */
     prependSubmenu(submenu: MenuModel, label?: string | null): void;
+    /**
+     * Removes an item from the menu.
+     *
+     * `position` gives the index of the item to remove.
+     *
+     * It is an error if position is not in range the range from 0 to one
+     * less than the number of items in the menu.
+     *
+     * It is not possible to remove items by identity since items are added
+     * to the menu simply by copying their links and attributes (ie:
+     * identity of the item itself is not preserved).
+     * @param position - the position of the item to remove
+     */
     remove(position: number): void;
+    /**
+     * Removes all items in the menu.
+     */
     removeAll(): void;
     connect(signal: "notify", handler: (self: Menu, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;

package/dist/generated/gio/menu.js

@@ -1,7 +1,22 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { MenuModel } from "./menu-model.js";
+/**
+ * `GMenu` is a simple implementation of [class@Gio.MenuModel].
+ * You populate a `GMenu` by adding [class@Gio.MenuItem] instances to it.
+ *
+ * There are some convenience functions to allow you to directly
+ * add items (avoiding [class@Gio.MenuItem]) for the common cases. To add
+ * a regular item, use [method@Gio.Menu.insert]. To add a section, use
+ * [method@Gio.Menu.insert_section]. To add a submenu, use
+ * [method@Gio.Menu.insert_submenu].
+ */
 export class Menu extends MenuModel {
+    /**
+     * Creates a new #GMenu.
+     *
+     * The new menu has no items.
+     */
     constructor(...args) {
         super(...args);
     }
@@ -11,6 +26,13 @@ export class Menu extends MenuModel {
             borrowed: false,
         });
     }
+    /**
+     * Convenience function for appending a normal menu item to the end of
+     * @menu.  Combine g_menu_item_new() and g_menu_insert_item() for a more
+     * flexible alternative.
+     * @param label - the section label, or %NULL
+     * @param detailedAction - the detailed action string, or %NULL
+     */
     append(label, detailedAction) {
         call("libgio-2.0.so.0", "g_menu_append", [
             {
@@ -29,6 +51,12 @@ export class Menu extends MenuModel {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Appends `item` to the end of @menu.
+     *
+     * See g_menu_insert_item() for more information.
+     * @param item - a #GMenuItem to append
+     */
     appendItem(item) {
         call("libgio-2.0.so.0", "g_menu_append_item", [
             {
@@ -41,6 +69,13 @@ export class Menu extends MenuModel {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Convenience function for appending a section menu item to the end of
+     * @menu.  Combine g_menu_item_new_section() and g_menu_insert_item() for a
+     * more flexible alternative.
+     * @param label - the section label, or %NULL
+     * @param section - a #GMenuModel with the items of the section
+     */
     appendSection(section, label) {
         call("libgio-2.0.so.0", "g_menu_append_section", [
             {
@@ -58,6 +93,13 @@ export class Menu extends MenuModel {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Convenience function for appending a submenu menu item to the end of
+     * @menu.  Combine g_menu_item_new_submenu() and g_menu_insert_item() for a
+     * more flexible alternative.
+     * @param label - the section label, or %NULL
+     * @param submenu - a #GMenuModel with the items of the submenu
+     */
     appendSubmenu(submenu, label) {
         call("libgio-2.0.so.0", "g_menu_append_submenu", [
             {
@@ -75,6 +117,16 @@ export class Menu extends MenuModel {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Marks `menu` as frozen.
+     *
+     * After the menu is frozen, it is an error to attempt to make any
+     * changes to it.  In effect this means that the #GMenu API must no
+     * longer be used.
+     *
+     * This function causes g_menu_model_is_mutable() to begin returning
+     * %FALSE, which has some positive performance implications.
+     */
     freeze() {
         call("libgio-2.0.so.0", "g_menu_freeze", [
             {
@@ -83,6 +135,14 @@ export class Menu extends MenuModel {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Convenience function for inserting a normal menu item into @menu.
+     * Combine g_menu_item_new() and g_menu_insert_item() for a more flexible
+     * alternative.
+     * @param position - the position at which to insert the item
+     * @param label - the section label, or %NULL
+     * @param detailedAction - the detailed action string, or %NULL
+     */
     insert(position, label, detailedAction) {
         call("libgio-2.0.so.0", "g_menu_insert", [
             {
@@ -105,6 +165,27 @@ export class Menu extends MenuModel {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Inserts `item` into @menu.
+     *
+     * The "insertion" is actually done by copying all of the attribute and
+     * link values of `item` and using them to form a new item within @menu.
+     * As such, `item` itself is not really inserted, but rather, a menu item
+     * that is exactly the same as the one presently described by @item.
+     *
+     * This means that `item` is essentially useless after the insertion
+     * occurs.  Any changes you make to it are ignored unless it is inserted
+     * again (at which point its updated values will be copied).
+     *
+     * You should probably just free `item` once you're done.
+     *
+     * There are many convenience functions to take care of common cases.
+     * See g_menu_insert(), g_menu_insert_section() and
+     * g_menu_insert_submenu() as well as "prepend" and "append" variants of
+     * each of these functions.
+     * @param position - the position at which to insert the item
+     * @param item - the #GMenuItem to insert
+     */
     insertItem(position, item) {
         call("libgio-2.0.so.0", "g_menu_insert_item", [
             {
@@ -121,6 +202,14 @@ export class Menu extends MenuModel {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Convenience function for inserting a section menu item into @menu.
+     * Combine g_menu_item_new_section() and g_menu_insert_item() for a more
+     * flexible alternative.
+     * @param position - the position at which to insert the item
+     * @param label - the section label, or %NULL
+     * @param section - a #GMenuModel with the items of the section
+     */
     insertSection(position, section, label) {
         call("libgio-2.0.so.0", "g_menu_insert_section", [
             {
@@ -142,6 +231,14 @@ export class Menu extends MenuModel {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Convenience function for inserting a submenu menu item into @menu.
+     * Combine g_menu_item_new_submenu() and g_menu_insert_item() for a more
+     * flexible alternative.
+     * @param position - the position at which to insert the item
+     * @param label - the section label, or %NULL
+     * @param submenu - a #GMenuModel with the items of the submenu
+     */
     insertSubmenu(position, submenu, label) {
         call("libgio-2.0.so.0", "g_menu_insert_submenu", [
             {
@@ -163,6 +260,13 @@ export class Menu extends MenuModel {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Convenience function for prepending a normal menu item to the start
+     * of @menu.  Combine g_menu_item_new() and g_menu_insert_item() for a more
+     * flexible alternative.
+     * @param label - the section label, or %NULL
+     * @param detailedAction - the detailed action string, or %NULL
+     */
     prepend(label, detailedAction) {
         call("libgio-2.0.so.0", "g_menu_prepend", [
             {
@@ -181,6 +285,12 @@ export class Menu extends MenuModel {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Prepends `item` to the start of @menu.
+     *
+     * See g_menu_insert_item() for more information.
+     * @param item - a #GMenuItem to prepend
+     */
     prependItem(item) {
         call("libgio-2.0.so.0", "g_menu_prepend_item", [
             {
@@ -193,6 +303,13 @@ export class Menu extends MenuModel {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Convenience function for prepending a section menu item to the start
+     * of @menu.  Combine g_menu_item_new_section() and g_menu_insert_item() for
+     * a more flexible alternative.
+     * @param label - the section label, or %NULL
+     * @param section - a #GMenuModel with the items of the section
+     */
     prependSection(section, label) {
         call("libgio-2.0.so.0", "g_menu_prepend_section", [
             {
@@ -210,6 +327,13 @@ export class Menu extends MenuModel {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Convenience function for prepending a submenu menu item to the start
+     * of @menu.  Combine g_menu_item_new_submenu() and g_menu_insert_item() for
+     * a more flexible alternative.
+     * @param label - the section label, or %NULL
+     * @param submenu - a #GMenuModel with the items of the submenu
+     */
     prependSubmenu(submenu, label) {
         call("libgio-2.0.so.0", "g_menu_prepend_submenu", [
             {
@@ -227,6 +351,19 @@ export class Menu extends MenuModel {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Removes an item from the menu.
+     *
+     * `position` gives the index of the item to remove.
+     *
+     * It is an error if position is not in range the range from 0 to one
+     * less than the number of items in the menu.
+     *
+     * It is not possible to remove items by identity since items are added
+     * to the menu simply by copying their links and attributes (ie:
+     * identity of the item itself is not preserved).
+     * @param position - the position of the item to remove
+     */
     remove(position) {
         call("libgio-2.0.so.0", "g_menu_remove", [
             {
@@ -239,6 +376,9 @@ export class Menu extends MenuModel {
             },
         ], { type: "undefined" });
     }
+    /**
+     * Removes all items in the menu.
+     */
     removeAll() {
         call("libgio-2.0.so.0", "g_menu_remove_all", [
             {