@girs/dbusmenu-0.4 0.4.0-3.0.0-beta.12

package/dbusmenu-0.4.d.cts

@@ -0,0 +1,1545 @@
+
+/*
+ * Type Definitions for Gjs (https://gjs.guide/)
+ *
+ * These type definitions are automatically generated, do not edit them by hand.
+ * If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gjs
+ */
+/**
+ * Dbusmenu-0.4
+ */
+
+import type GObject from '@girs/gobject-2.0';
+import type GLib from '@girs/glib-2.0';
+
+/**
+ * Tracks how the menus should be presented to the user.
+ */
+export enum Status {
+    /**
+     * Everything is normal
+     */
+    NORMAL,
+    /**
+     * The menus should be shown at a higher priority
+     */
+    NOTICE,
+}
+/**
+ * The direction of text that the strings that this server
+ * 	will be sending strings as.
+ */
+export enum TextDirection {
+    /**
+     * Unspecified text direction
+     */
+    NONE,
+    /**
+     * Left-to-right text direction
+     */
+    LTR,
+    /**
+     * Right-to-left text direction
+     */
+    RTL,
+}
+/**
+ * String to access property #DbusmenuClient:dbus-name
+ */
+export const CLIENT_PROP_DBUS_NAME: string | null
+/**
+ * String to access property #DbusmenuClient:dbus-object
+ */
+export const CLIENT_PROP_DBUS_OBJECT: string | null
+/**
+ * String to access property #DbusmenuClient:group-events
+ */
+export const CLIENT_PROP_GROUP_EVENTS: string | null
+/**
+ * String to access property #DbusmenuClient:status
+ */
+export const CLIENT_PROP_STATUS: string | null
+/**
+ * String to access property #DbusmenuClient:text-direction
+ */
+export const CLIENT_PROP_TEXT_DIRECTION: string | null
+/**
+ * String to attach to signal #DbusmenuClient::event-result
+ */
+export const CLIENT_SIGNAL_EVENT_RESULT: string | null
+/**
+ * String to attach to signal #DbusmenuClient::icon-theme-dirs-changed
+ */
+export const CLIENT_SIGNAL_ICON_THEME_DIRS_CHANGED: string | null
+/**
+ * String to attach to signal #DbusmenuClient::item-activate
+ */
+export const CLIENT_SIGNAL_ITEM_ACTIVATE: string | null
+/**
+ * String to attach to signal #DbusmenuClient::layout-updated
+ */
+export const CLIENT_SIGNAL_LAYOUT_UPDATED: string | null
+/**
+ * String to attach to signal #DbusmenuClient::new-menuitem
+ */
+export const CLIENT_SIGNAL_NEW_MENUITEM: string | null
+/**
+ * String to attach to signal #DbusmenuClient::root-changed
+ */
+export const CLIENT_SIGNAL_ROOT_CHANGED: string | null
+/**
+ * Used to set the 'type' property on a menu item to create
+ * a standard menu item.
+ */
+export const CLIENT_TYPES_DEFAULT: string | null
+/**
+ * Used to set the 'type' property on a menu item to create
+ * an image menu item.  Deprecated as standard menu items now
+ * support images as well.
+ */
+export const CLIENT_TYPES_IMAGE: string | null
+/**
+ * Used to set the 'type' property on a menu item to create
+ * a separator menu item.
+ */
+export const CLIENT_TYPES_SEPARATOR: string | null
+/**
+ * Used in #DBUSMENU_MENUITEM_PROP_CHILD_DISPLAY to have the
+ * subitems displayed as a submenu.
+ */
+export const MENUITEM_CHILD_DISPLAY_SUBMENU: string | null
+/**
+ * Used in #DBUSMENU_MENUITEM_PROP_DISPOSITION to have a menu
+ * item displayed in a way that conveys it's giving an alert
+ * to the user.
+ */
+export const MENUITEM_DISPOSITION_ALERT: string | null
+/**
+ * Used in #DBUSMENU_MENUITEM_PROP_DISPOSITION to have a menu
+ * item displayed in a way that conveys it's giving additional
+ * information to the user.
+ */
+export const MENUITEM_DISPOSITION_INFORMATIVE: string | null
+/**
+ * Used in #DBUSMENU_MENUITEM_PROP_DISPOSITION to have a menu
+ * item displayed in the normal manner.  Default value.
+ */
+export const MENUITEM_DISPOSITION_NORMAL: string | null
+/**
+ * Used in #DBUSMENU_MENUITEM_PROP_DISPOSITION to have a menu
+ * item displayed in a way that conveys it's giving a warning
+ * to the user.
+ */
+export const MENUITEM_DISPOSITION_WARNING: string | null
+/**
+ * String for the event identifier when a menu item is clicked
+ * on by the user.
+ */
+export const MENUITEM_EVENT_ACTIVATED: string | null
+/**
+ * String for the event identifier when a menu is closed and
+ * displayed to the user.  Only valid for items that contain
+ * submenus.
+ */
+export const MENUITEM_EVENT_CLOSED: string | null
+/**
+ * String for the event identifier when a menu is opened and
+ * displayed to the user.  Only valid for items that contain
+ * submenus.
+ */
+export const MENUITEM_EVENT_OPENED: string | null
+/**
+ * Used to set #DBUSMENU_MENUITEM_PROP_TOGGLE_STATE so that the menu's
+ * toggle item is undecided.
+ */
+export const MENUITEM_ICON_NAME_BLANK: string | null
+/**
+ * #DbusmenuMenuitem property used to provide a textual description of any
+ * information that the icon may convey. The contents of this property are
+ * passed through to assistive technologies such as the Orca screen reader.
+ * The contents of this property will not be visible in the menu item. If
+ * this property is set, Orca will use this property instead of the label
+ * property.
+ */
+export const MENUITEM_PROP_ACCESSIBLE_DESC: string | null
+/**
+ * #DbusmenuMenuitem property that tells how the children of this menuitem
+ * should be displayed.  Most likely this will be unset or of the value
+ * #DBUSMENU_MENUITEM_CHILD_DISPLAY_SUBMENU.  Type: #G_VARIANT_TYPE_STRING
+ */
+export const MENUITEM_PROP_CHILD_DISPLAY: string | null
+/**
+ * #DbusmenuMenuitem property to tell what type of information that the
+ * menu item is displaying to the user.  Type: #G_VARIANT_TYPE_STRING
+ */
+export const MENUITEM_PROP_DISPOSITION: string | null
+/**
+ * #DbusmenuMenuitem property used to represent whether the menuitem
+ * is clickable or not.  Type: #G_VARIANT_TYPE_BOOLEAN.
+ */
+export const MENUITEM_PROP_ENABLED: string | null
+/**
+ * #DbusmenuMenuitem property that is the raw data of a custom icon
+ * used in the application.  Type: #G_VARIANT_TYPE_VARIANT
+ * 
+ * It is recommended that this is not set directly but instead the
+ * libdbusmenu-gtk library is used with the function dbusmenu_menuitem_property_set_image()
+ */
+export const MENUITEM_PROP_ICON_DATA: string | null
+/**
+ * #DbusmenuMenuitem property that is the name of the icon under the
+ * Freedesktop.org icon naming spec.  Type: #G_VARIANT_TYPE_STRING
+ */
+export const MENUITEM_PROP_ICON_NAME: string | null
+/**
+ * #DbusmenuMenuitem property used for the text on the menu item.
+ */
+export const MENUITEM_PROP_LABEL: string | null
+/**
+ * #DbusmenuMenuitem property that is the entries that represent a shortcut
+ * to activate the menuitem.  It is an array of arrays of strings.
+ * 
+ * It is recommended that this is not set directly but instead the
+ * libdbusmenu-gtk library is used with the function dbusmenu_menuitem_property_set_shortcut()
+ */
+export const MENUITEM_PROP_SHORTCUT: string | null
+/**
+ * #DbusmenuMenuitem property that says what state a toggle entry should
+ * be shown as the menu.  Should be either #DBUSMENU_MENUITEM_TOGGLE_STATE_UNCHECKED
+ * #DBUSMENU_MENUITEM_TOGGLE_STATE_CHECKED or #DBUSMENU_MENUITEM_TOGGLE_STATUE_UNKNOWN.
+ */
+export const MENUITEM_PROP_TOGGLE_STATE: string | null
+/**
+ * #DbusmenuMenuitem property that says what type of toggle entry should
+ * be shown in the menu.  Should be either #DBUSMENU_MENUITEM_TOGGLE_CHECK
+ * or #DBUSMENU_MENUITEM_TOGGLE_RADIO.  Type: #G_VARIANT_TYPE_STRING
+ */
+export const MENUITEM_PROP_TOGGLE_TYPE: string | null
+/**
+ * #DbusmenuMenuitem property used to represent what type of menuitem
+ * this object represents.  Type: #G_VARIANT_TYPE_STRING.
+ */
+export const MENUITEM_PROP_TYPE: string | null
+/**
+ * #DbusmenuMenuitem property used to represent whether the menuitem
+ * should be shown or not.  Type: #G_VARIANT_TYPE_BOOLEAN.
+ */
+export const MENUITEM_PROP_VISIBLE: string | null
+/**
+ * Used in #DBUSMENU_MENUITEM_PROP_SHORTCUT to represent the
+ * alternate key.
+ */
+export const MENUITEM_SHORTCUT_ALT: string | null
+/**
+ * Used in #DBUSMENU_MENUITEM_PROP_SHORTCUT to represent the
+ * control key.
+ */
+export const MENUITEM_SHORTCUT_CONTROL: string | null
+/**
+ * Used in #DBUSMENU_MENUITEM_PROP_SHORTCUT to represent the
+ * shift key.
+ */
+export const MENUITEM_SHORTCUT_SHIFT: string | null
+/**
+ * Used in #DBUSMENU_MENUITEM_PROP_SHORTCUT to represent the
+ * super key.
+ */
+export const MENUITEM_SHORTCUT_SUPER: string | null
+/**
+ * String to attach to signal #DbusmenuServer::about-to-show
+ */
+export const MENUITEM_SIGNAL_ABOUT_TO_SHOW: string | null
+/**
+ * String to attach to signal #DbusmenuServer::child-added
+ */
+export const MENUITEM_SIGNAL_CHILD_ADDED: string | null
+/**
+ * String to attach to signal #DbusmenuServer::child-moved
+ */
+export const MENUITEM_SIGNAL_CHILD_MOVED: string | null
+/**
+ * String to attach to signal #DbusmenuServer::child-removed
+ */
+export const MENUITEM_SIGNAL_CHILD_REMOVED: string | null
+/**
+ * String to attach to signal #DbusmenuServer::event
+ */
+export const MENUITEM_SIGNAL_EVENT: string | null
+/**
+ * String to attach to signal #DbusmenuServer::item-activated
+ */
+export const MENUITEM_SIGNAL_ITEM_ACTIVATED: string | null
+/**
+ * String to attach to signal #DbusmenuServer::property-changed
+ */
+export const MENUITEM_SIGNAL_PROPERTY_CHANGED: string | null
+/**
+ * String to attach to signal #DbusmenuServer::realized
+ */
+export const MENUITEM_SIGNAL_REALIZED: string | null
+/**
+ * String to attach to signal #DbusmenuServer::show-to-user
+ */
+export const MENUITEM_SIGNAL_SHOW_TO_USER: string | null
+/**
+ * Used to set #DBUSMENU_MENUITEM_PROP_TOGGLE_TYPE to be a standard
+ * check mark item.
+ */
+export const MENUITEM_TOGGLE_CHECK: string | null
+/**
+ * Used to set #DBUSMENU_MENUITEM_PROP_TOGGLE_TYPE to be a standard
+ * radio item.
+ */
+export const MENUITEM_TOGGLE_RADIO: string | null
+/**
+ * Used to set #DBUSMENU_MENUITEM_PROP_TOGGLE_STATE so that the menu's
+ * toggle item is filled.
+ */
+export const MENUITEM_TOGGLE_STATE_CHECKED: number
+/**
+ * Used to set #DBUSMENU_MENUITEM_PROP_TOGGLE_STATE so that the menu's
+ * toggle item is empty.
+ */
+export const MENUITEM_TOGGLE_STATE_UNCHECKED: number
+/**
+ * Used to set #DBUSMENU_MENUITEM_PROP_TOGGLE_STATE so that the menu's
+ * toggle item is undecided.
+ */
+export const MENUITEM_TOGGLE_STATE_UNKNOWN: number
+/**
+ * String to access property #DbusmenuServer:dbus-object
+ */
+export const SERVER_PROP_DBUS_OBJECT: string | null
+/**
+ * String to access property #DbusmenuServer:root-node
+ */
+export const SERVER_PROP_ROOT_NODE: string | null
+/**
+ * String to access property #DbusmenuServer:status
+ */
+export const SERVER_PROP_STATUS: string | null
+/**
+ * String to access property #DbusmenuServer:text-direction
+ */
+export const SERVER_PROP_TEXT_DIRECTION: string | null
+/**
+ * String to access property #DbusmenuServer:version
+ */
+export const SERVER_PROP_VERSION: string | null
+/**
+ * String to attach to signal #DbusmenuServer::item-property-updated
+ */
+export const SERVER_SIGNAL_ID_PROP_UPDATE: string | null
+/**
+ * String to attach to signal #DbusmenuServer::item-updated
+ */
+export const SERVER_SIGNAL_ID_UPDATE: string | null
+/**
+ * String to attach to signal #DbusmenuServer::item-activation-requested
+ */
+export const SERVER_SIGNAL_ITEM_ACTIVATION: string | null
+/**
+ * String to attach to signal #DbusmenuServer::layout-updated
+ */
+export const SERVER_SIGNAL_LAYOUT_UPDATED: string | null
+/**
+ * The type handler is called when a dbusmenu item is created
+ * 	with a matching type as setup in #dbusmenu_client_add_type_handler
+ * 
+ * 	Return value: #TRUE if the type has been handled.  #FALSE if this
+ * 		function was somehow unable to handle it.
+ * @callback 
+ * @param newitem The #DbusmenuMenuitem that was created
+ * @param parent The parent of `newitem` or #NULL if none
+ * @param client A pointer to the #DbusmenuClient
+ */
+export interface ClientTypeHandler {
+    (newitem: Menuitem, parent: Menuitem, client: Client): boolean
+}
+/**
+ * Callback prototype for a callback that is called when the
+ * menu should be shown.
+ * @callback 
+ * @param mi Menu item that should be shown
+ */
+export interface menuitem_about_to_show_cb {
+    (mi: Menuitem): void
+}
+/**
+ * This is the function that is called to represent this menu item
+ * as a variant.  Should call its own children.
+ * @callback 
+ * @param mi Menu item that should be built from
+ * @param properties A list of properties that should be the only ones in the resulting variant structure
+ * @returns A variant representing this item and its children
+ */
+export interface menuitem_buildvariant_slot_t {
+    (mi: Menuitem, properties: string | null): GLib.Variant
+}
+export module Client {
+
+    // Signal callback interfaces
+
+    /**
+     * Signal callback interface for `event-result`
+     */
+    export interface EventResultSignalCallback {
+        ($obj: Client, object: GObject.Object, p0: string | null, p1: GLib.Variant, p2: number, p3: any | null): void
+    }
+
+    /**
+     * Signal callback interface for `icon-theme-dirs-changed`
+     */
+    export interface IconThemeDirsChangedSignalCallback {
+        ($obj: Client, arg1: any | null): void
+    }
+
+    /**
+     * Signal callback interface for `item-activate`
+     */
+    export interface ItemActivateSignalCallback {
+        ($obj: Client, arg1: GObject.Object, arg2: number): void
+    }
+
+    /**
+     * Signal callback interface for `layout-updated`
+     */
+    export interface LayoutUpdatedSignalCallback {
+        ($obj: Client): void
+    }
+
+    /**
+     * Signal callback interface for `new-menuitem`
+     */
+    export interface NewMenuitemSignalCallback {
+        ($obj: Client, arg1: GObject.Object): void
+    }
+
+    /**
+     * Signal callback interface for `root-changed`
+     */
+    export interface RootChangedSignalCallback {
+        ($obj: Client, arg1: GObject.Object): void
+    }
+
+
+    // Constructor properties interface
+
+    export interface ConstructorProperties extends GObject.Object.ConstructorProperties {
+
+        // Own constructor properties of Dbusmenu-0.4.Dbusmenu.Client
+
+        dbus_name?: string | null
+        dbus_object?: string | null
+        group_events?: boolean | null
+    }
+
+}
+
+export interface Client {
+
+    // Own properties of Dbusmenu-0.4.Dbusmenu.Client
+
+    readonly dbus_name: string | null
+    readonly dbus_object: string | null
+    group_events: boolean
+
+    // Owm methods of Dbusmenu-0.4.Dbusmenu.Client
+
+    /**
+     * This function connects into the type handling of the #DbusmenuClient.
+     * Every new menuitem that comes in immediately gets asked for its
+     * properties.  When we get those properties we check the 'type'
+     * property and look to see if it matches a handler that is known
+     * by the client.  If so, the `newfunc` function is executed on that
+     * #DbusmenuMenuitem.  If not, then the DbusmenuClient::new-menuitem
+     * signal is sent.
+     * 
+     * In the future the known types will be sent to the server so that it
+     * can make choices about the menu item types availble.
+     * @param type A text string that will be matched with the 'type'     property on incoming menu items
+     * @param newfunc The function that will be executed with those new     items when they come in.
+     * @returns If registering the new type was successful.
+     */
+    add_type_handler(type: string | null, newfunc: ClientTypeHandler): boolean
+    /**
+     * This function connects into the type handling of the #DbusmenuClient.
+     * Every new menuitem that comes in immediately gets asked for its
+     * properties.  When we get those properties we check the 'type'
+     * property and look to see if it matches a handler that is known
+     * by the client.  If so, the `newfunc` function is executed on that
+     * #DbusmenuMenuitem.  If not, then the DbusmenuClient::new-menuitem
+     * signal is sent.
+     * 
+     * In the future the known types will be sent to the server so that it
+     * can make choices about the menu item types availble.
+     * @param type A text string that will be matched with the 'type'     property on incoming menu items
+     * @param newfunc The function that will be executed with those new     items when they come in.
+     * @returns If registering the new type was successful.
+     */
+    add_type_handler_full(type: string | null, newfunc: ClientTypeHandler): boolean
+    /**
+     * Gets the stored and exported icon paths from the client.
+     * @returns A NULL-terminated list of icon paths with   memory managed by the client.  Duplicate if you want   to keep them.
+     */
+    get_icon_paths(): string[]
+    /**
+     * Grabs the root node for the specified client `client`.  This
+     * function may block.  It will block if there is currently a
+     * call to update the layout, it will block on that layout
+     * updated and then return the newly updated layout.  Chances
+     * are that this update is in the queue for the mainloop as
+     * it would have been requested some time ago, but in theory
+     * it could block longer.
+     * @returns A #DbusmenuMenuitem representing the root of 	menu on the server.  If there is no server or there is 	an error receiving its layout it'll return #NULL.
+     */
+    get_root(): Menuitem
+    /**
+     * Gets the recommended current status that the server
+     * 	is exporting for the menus.  In situtations where the
+     * 	value is #DBUSMENU_STATUS_NOTICE it is recommended that
+     * 	the client show the menus to the user an a more noticible
+     * 	way.
+     * 
+     * 	Return value: Status being exported.
+     */
+    get_status(): Status
+    /**
+     * Gets the text direction that the server is exporting.  If
+     * 	the server is not exporting a direction then the value
+     * 	#DBUSMENU_TEXT_DIRECTION_NONE will be returned.
+     * 
+     * 	Return value: Text direction being exported.
+     */
+    get_text_direction(): TextDirection
+
+    // Own signals of Dbusmenu-0.4.Dbusmenu.Client
+
+    connect(sigName: "event-result", callback: Client.EventResultSignalCallback): number
+    connect_after(sigName: "event-result", callback: Client.EventResultSignalCallback): number
+    emit(sigName: "event-result", object: GObject.Object, p0: string | null, p1: GLib.Variant, p2: number, p3: any | null, ...args: any[]): void
+    connect(sigName: "icon-theme-dirs-changed", callback: Client.IconThemeDirsChangedSignalCallback): number
+    connect_after(sigName: "icon-theme-dirs-changed", callback: Client.IconThemeDirsChangedSignalCallback): number
+    emit(sigName: "icon-theme-dirs-changed", arg1: any | null, ...args: any[]): void
+    connect(sigName: "item-activate", callback: Client.ItemActivateSignalCallback): number
+    connect_after(sigName: "item-activate", callback: Client.ItemActivateSignalCallback): number
+    emit(sigName: "item-activate", arg1: GObject.Object, arg2: number, ...args: any[]): void
+    connect(sigName: "layout-updated", callback: Client.LayoutUpdatedSignalCallback): number
+    connect_after(sigName: "layout-updated", callback: Client.LayoutUpdatedSignalCallback): number
+    emit(sigName: "layout-updated", ...args: any[]): void
+    connect(sigName: "new-menuitem", callback: Client.NewMenuitemSignalCallback): number
+    connect_after(sigName: "new-menuitem", callback: Client.NewMenuitemSignalCallback): number
+    emit(sigName: "new-menuitem", arg1: GObject.Object, ...args: any[]): void
+    connect(sigName: "root-changed", callback: Client.RootChangedSignalCallback): number
+    connect_after(sigName: "root-changed", callback: Client.RootChangedSignalCallback): number
+    emit(sigName: "root-changed", arg1: GObject.Object, ...args: any[]): void
+
+    // Class property signals of Dbusmenu-0.4.Dbusmenu.Client
+
+    connect(sigName: "notify::dbus-name", callback: (($obj: Client, pspec: GObject.ParamSpec) => void)): number
+    connect_after(sigName: "notify::dbus-name", callback: (($obj: Client, pspec: GObject.ParamSpec) => void)): number
+    emit(sigName: "notify::dbus-name", ...args: any[]): void
+    connect(sigName: "notify::dbus-object", callback: (($obj: Client, pspec: GObject.ParamSpec) => void)): number
+    connect_after(sigName: "notify::dbus-object", callback: (($obj: Client, pspec: GObject.ParamSpec) => void)): number
+    emit(sigName: "notify::dbus-object", ...args: any[]): void
+    connect(sigName: "notify::group-events", callback: (($obj: Client, pspec: GObject.ParamSpec) => void)): number
+    connect_after(sigName: "notify::group-events", callback: (($obj: Client, pspec: GObject.ParamSpec) => void)): number
+    emit(sigName: "notify::group-events", ...args: any[]): void
+    connect(sigName: string, callback: (...args: any[]) => void): number
+    connect_after(sigName: string, callback: (...args: any[]) => void): number
+    emit(sigName: string, ...args: any[]): void
+    disconnect(id: number): void
+}
+
+/**
+ * The client for a #DbusmenuServer creating a shared
+ * 	object set of #DbusmenuMenuitem objects.
+ * @class 
+ */
+export class Client extends GObject.Object {
+
+    // Own properties of Dbusmenu-0.4.Dbusmenu.Client
+
+    static name: string
+    static $gtype: GObject.GType<Client>
+
+    // Constructors of Dbusmenu-0.4.Dbusmenu.Client
+
+    constructor(config?: Client.ConstructorProperties) 
+    /**
+     * This function creates a new client that connects to a specific
+     * server on DBus.  That server is at a specific location sharing
+     * a known object.  The interface is assumed by the code to be
+     * the DBus menu interface.  The newly created client will start
+     * sending out events as it syncs up with the server.
+     * @constructor 
+     * @param name The DBus name for the server to connect to
+     * @param object The object on the server to monitor
+     * @returns A brand new #DbusmenuClient
+     */
+    constructor(name: string | null, object: string | null) 
+    /**
+     * This function creates a new client that connects to a specific
+     * server on DBus.  That server is at a specific location sharing
+     * a known object.  The interface is assumed by the code to be
+     * the DBus menu interface.  The newly created client will start
+     * sending out events as it syncs up with the server.
+     * @constructor 
+     * @param name The DBus name for the server to connect to
+     * @param object The object on the server to monitor
+     * @returns A brand new #DbusmenuClient
+     */
+    static new(name: string | null, object: string | null): Client
+    _init(config?: Client.ConstructorProperties): void
+}
+
+export module Menuitem {
+
+    // Signal callback interfaces
+
+    /**
+     * Signal callback interface for `about-to-show`
+     */
+    export interface AboutToShowSignalCallback {
+        ($obj: Menuitem): boolean
+    }
+
+    /**
+     * Signal callback interface for `child-added`
+     */
+    export interface ChildAddedSignalCallback {
+        ($obj: Menuitem, arg1: GObject.Object, arg2: number): void
+    }
+
+    /**
+     * Signal callback interface for `child-moved`
+     */
+    export interface ChildMovedSignalCallback {
+        ($obj: Menuitem, arg1: GObject.Object, arg2: number, arg3: number): void
+    }
+
+    /**
+     * Signal callback interface for `child-removed`
+     */
+    export interface ChildRemovedSignalCallback {
+        ($obj: Menuitem, arg1: GObject.Object): void
+    }
+
+    /**
+     * Signal callback interface for `event`
+     */
+    export interface EventSignalCallback {
+        ($obj: Menuitem, arg1: string | null, arg2: GLib.Variant, arg3: number): boolean
+    }
+
+    /**
+     * Signal callback interface for `item-activated`
+     */
+    export interface ItemActivatedSignalCallback {
+        ($obj: Menuitem, arg1: number): void
+    }
+
+    /**
+     * Signal callback interface for `property-changed`
+     */
+    export interface PropertyChangedSignalCallback {
+        ($obj: Menuitem, arg1: string | null, arg2: GLib.Variant): void
+    }
+
+    /**
+     * Signal callback interface for `realized`
+     */
+    export interface RealizedSignalCallback {
+        ($obj: Menuitem): void
+    }
+
+    /**
+     * Signal callback interface for `show-to-user`
+     */
+    export interface ShowToUserSignalCallback {
+        ($obj: Menuitem, arg1: number): void
+    }
+
+
+    // Constructor properties interface
+
+    export interface ConstructorProperties extends GObject.Object.ConstructorProperties {
+
+        // Own constructor properties of Dbusmenu-0.4.Dbusmenu.Menuitem
+
+        id?: number | null
+    }
+
+}
+
+export interface Menuitem {
+
+    // Own properties of Dbusmenu-0.4.Dbusmenu.Menuitem
+
+    readonly id: number
+
+    // Own fields of Dbusmenu-0.4.Dbusmenu.Menuitem
+
+    /**
+     * Parent object
+     * @field 
+     */
+    parent: GObject.Object
+    /**
+     * Private data
+     * @field 
+     */
+    priv: MenuitemPrivate
+
+    // Owm methods of Dbusmenu-0.4.Dbusmenu.Menuitem
+
+    /**
+     * Puts `child` in the list of children for `mi` at the location
+     * specified in `position`.  If there is not enough entires available
+     * then `child` will be placed at the end of the list.
+     * @param child The #DbusmenuMenuitem to make a child of `mi`.
+     * @param position Where in `mi` object's list of chidren `child` should be placed.
+     * @returns Whether @child was added successfully.
+     */
+    child_add_position(child: Menuitem, position: number): boolean
+    /**
+     * This function adds `child` to the list of children on `mi` at
+     * the end of that list.
+     * @param child The #DbusmenMenuitem that will be a child
+     * @returns Whether the child has been added successfully.
+     */
+    child_append(child: Menuitem): boolean
+    /**
+     * This function removes `child` from the children list of `mi`.  It does
+     * not call #g_object_unref on `child`.
+     * @param child The child #DbusmenuMenuitem that you want to no longer     be a child of `mi`.
+     * @returns If we were able to delete @child.
+     */
+    child_delete(child: Menuitem): boolean
+    /**
+     * Search the children of `mi` to find one with the ID of `id`.
+     * If it doesn't exist then we return #NULL.
+     * @param id The ID of the child that we're looking for.
+     * @returns The menu item with the ID @id or #NULL if it    can't be found.
+     */
+    child_find(id: number): Menuitem
+    /**
+     * This function adds `child` to the list of children on `mi` at
+     * the beginning of that list.
+     * @param child The #DbusmenMenuitem that will be a child
+     * @returns Whether the child has been added successfully.
+     */
+    child_prepend(child: Menuitem): boolean
+    /**
+     * This function moves a child on the list of children.  It is
+     * for a child that is already in the list, but simply needs a
+     * new location.
+     * @param child The #DbusmenuMenuitem that is a child needing to be moved
+     * @param position The position in the list to place it in
+     * @returns Whether the move was successful.
+     */
+    child_reorder(child: Menuitem, position: number): boolean
+    /**
+     * This function searchs the whole tree of children that
+     * are attached to `mi`.  This could be quite a few nodes, all
+     * the way down the tree.  It is a depth first search.
+     * @param id ID of the #DbusmenuMenuitem to search for
+     * @returns The #DbusmenuMenuitem with the ID of @id 	or #NULL if there isn't such a menu item in the tree 	represented by @mi.
+     */
+    find_id(id: number): Menuitem
+    /**
+     * This calls the function `func` on this menu item and all
+     * of the children of this item.  And their children.  And
+     * their children.  And... you get the point.  It will get
+     * called on the whole tree.
+     * @param func Function to call on every node in the tree
+     * @param data User data to pass to the function
+     */
+    foreach(func: any | null, data: any | null): void
+    /**
+     * Returns simply the list of children that this menu item
+     * has.  The list is valid until another child related function
+     * is called, where it might be changed.
+     * @returns A #GList of pointers to #DbusmenuMenuitem objects.
+     */
+    get_children(): Menuitem[]
+    /**
+     * Gets the unique ID for `mi`.
+     * @returns The ID of the @mi.
+     */
+    get_id(): number
+    /**
+     * This function looks up the parent of `mi`
+     * @returns The parent of this menu item
+     */
+    get_parent(): Menuitem
+    /**
+     * This function returns the position of the menu item `mi`
+     * in the children of `parent`.  It will return zero if the
+     * menu item can't be found.
+     * @param parent The #DbusmenuMenuitem who's children contain `mi`
+     * @returns The position of @mi in the children of @parent.
+     */
+    get_position(parent: Menuitem): number
+    /**
+     * This function is very similar to #dbusmenu_menuitem_get_position
+     * except that it only counts in the children that have been realized.
+     * @param parent The #DbusmenuMenuitem who's children contain `mi`
+     * @returns The position of @mi in the realized children of @parent.
+     */
+    get_position_realized(parent: Menuitem): number
+    /**
+     * This function returns the internal value of whether this is a
+     * root node or not.
+     * @returns #TRUE if this is a root node
+     */
+    get_root(): boolean
+    /**
+     * This function is called to create an event.  It is likely
+     * to be overrided by subclasses.  The default menu item
+     * will respond to the activate signal and do:
+     * 
+     * Emits the #DbusmenuMenuitem::item-activate signal on this
+     * menu item.  Called by server objects when they get the
+     * appropriate DBus signals from the client.
+     * 
+     * If you subclass this function you should really think
+     * about calling the parent function unless you have a good
+     * reason not to.
+     * @param name The name of the signal
+     * @param variant A value that could be set for the event
+     * @param timestamp The timestamp of when the event happened
+     */
+    handle_event(name: string | null, variant: GLib.Variant, timestamp: number): void
+    /**
+     * This function takes the properties of a #DbusmenuMenuitem
+     * and puts them into a #GHashTable that is referenced by the
+     * key of a string and has the value of a string.  The hash
+     * table may not have any entries if there aren't any or there
+     * is an error in processing.  It is the caller's responsibility
+     * to destroy the created #GHashTable.
+     * @returns A brand new #GHashTable that contains all of    theroperties that are on this #DbusmenuMenuitem @mi.
+     */
+    properties_copy(): GLib.HashTable
+    /**
+     * This functiong gets a list of the names of all the properties
+     * that are set on this menu item.  This data on the list is owned
+     * by the menuitem but the list is not and should be freed using
+     * g_list_free() when the calling function is done with it.
+     * @returns A list of strings or NULL if there are none.
+     */
+    properties_list(): string[]
+    /**
+     * Checkes to see if a particular property exists on `mi` and
+     * returns #TRUE if so.
+     * @param property The property to look for.
+     * @returns A boolean checking to see if the property is available
+     */
+    property_exist(property: string | null): boolean
+    /**
+     * Look up a property on `mi` and return the value of it if
+     * it exits.  #NULL will be returned if the property doesn't
+     * exist.
+     * @param property The property to grab.
+     * @returns A string with the value of the property 	that shouldn't be free'd.  Or #NULL if the property 	is not set or is not a string.
+     */
+    property_get(property: string | null): string | null
+    /**
+     * Look up a property on `mi` and return the value of it if
+     * it exits.  Returns #FALSE if the property doesn't exist.
+     * @param property The property to grab.
+     * @returns The value of the property or #FALSE.
+     */
+    property_get_bool(property: string | null): boolean
+    /**
+     * Look up a property on `mi` and return the value of it if
+     * it exits.  #NULL will be returned if the property doesn't
+     * exist.
+     * @param property The property to grab.
+     * @returns A byte array with the 	value of the property that shouldn't be free'd.  Or #NULL if the property 	is not set or is not a byte array.
+     */
+    property_get_byte_array(property: string | null): Uint8Array
+    /**
+     * Look up a property on `mi` and return the value of it if
+     * it exits.  Returns zero if the property doesn't exist.
+     * @param property The property to grab.
+     * @returns The value of the property or zero.
+     */
+    property_get_int(property: string | null): number
+    /**
+     * Look up a property on `mi` and return the value of it if
+     * it exits.  #NULL will be returned if the property doesn't
+     * exist.
+     * @param property The property to grab.
+     * @returns A GVariant for the property.
+     */
+    property_get_variant(property: string | null): GLib.Variant
+    /**
+     * Removes a property from the menuitem.
+     * @param property The property to look for.
+     */
+    property_remove(property: string | null): void
+    /**
+     * Takes the pair of `property` and `value` and places them as a
+     * property on `mi`.  If a property already exists by that name,
+     * then the value is set to the new value.  If not, the property
+     * is added.  If the value is changed or the property was previously
+     * unset then the signal #DbusmenuMenuitem::prop-changed will be
+     * emitted by this function.
+     * @param property Name of the property to set.
+     * @param value The value of the property.
+     * @returns A boolean representing if the property value was set.
+     */
+    property_set(property: string | null, value: string | null): boolean
+    /**
+     * Takes a boolean `value` and sets it on `property` as a
+     * property on `mi`.  If a property already exists by that name,
+     * then the value is set to the new value.  If not, the property
+     * is added.  If the value is changed or the property was previously
+     * unset then the signal #DbusmenuMenuitem::prop-changed will be
+     * emitted by this function.
+     * @param property Name of the property to set.
+     * @param value The value of the property.
+     * @returns A boolean representing if the property value was set.
+     */
+    property_set_bool(property: string | null, value: boolean): boolean
+    /**
+     * Takes a byte array `value` and sets it on `property` as a
+     * property on `mi`.  If a property already exists by that name,
+     * then the value is set to the new value.  If not, the property
+     * is added.  If the value is changed or the property was previously
+     * unset then the signal #DbusmenuMenuitem::prop-changed will be
+     * emitted by this function.
+     * @param property Name of the property to set.
+     * @param value The byte array.
+     * @param nelements The number of elements in the byte array.
+     * @returns A boolean representing if the property value was set.
+     */
+    property_set_byte_array(property: string | null, value: number, nelements: number): boolean
+    /**
+     * Takes a boolean `value` and sets it on `property` as a
+     * property on `mi`.  If a property already exists by that name,
+     * then the value is set to the new value.  If not, the property
+     * is added.  If the value is changed or the property was previously
+     * unset then the signal #DbusmenuMenuitem::prop-changed will be
+     * emitted by this function.
+     * @param property Name of the property to set.
+     * @param value The value of the property.
+     * @returns A boolean representing if the property value was set.
+     */
+    property_set_int(property: string | null, value: number): boolean
+    /**
+     * Takes the pair of `property` and `value` and places them as a
+     * property on `mi`.  If a property already exists by that name,
+     * then the value is set to the new value.  If not, the property
+     * is added.  If the value is changed or the property was previously
+     * unset then the signal #DbusmenuMenuitem::prop-changed will be
+     * emitted by this function.
+     * @param property Name of the property to set.
+     * @param value The value of the property.
+     * @returns A boolean representing if the property value was set.
+     */
+    property_set_variant(property: string | null, value: GLib.Variant): boolean
+    /**
+     * This function is used to send the even that the submenu
+     * of this item is about to be shown.  Callers to this event
+     * should delay showing the menu until their callback is
+     * called if possible.
+     * @param cb Callback to call when the call has returned.
+     * @param cb_data Data to pass to the callback.
+     */
+    send_about_to_show(cb: any | null, cb_data: any | null): void
+    /**
+     * Sets the parent of `mi` to `parent`. If `mi` already
+     * has a parent, then this call will fail. The parent will
+     * be set automatically when using the usual methods to add a
+     * child menuitem, so this function should not normally be
+     * called directly
+     * @param parent The new parent #DbusmenuMenuitem
+     * @returns Whether the parent was set successfully
+     */
+    set_parent(parent: Menuitem): boolean
+    /**
+     * This function sets the internal value of whether this is a
+     * root node or not.
+     * @param root Whether `mi` is a root node or not
+     */
+    set_root(root: boolean): void
+    /**
+     * Signals that this menu item should be shown to the user.  If this is
+     * server side the server will then take it and send it over the
+     * bus.
+     * @param timestamp The time that the user requested it to be shown
+     */
+    show_to_user(timestamp: number): void
+    /**
+     * While the name sounds devious that's exactly what this function
+     * does.  It takes the list of children from the `mi` and clears the
+     * internal list.  The calling function is now in charge of the ref's
+     * on the children it has taken.  A lot of responsibility involved
+     * in taking children.
+     * @returns     A #GList of pointers to #DbusmenuMenuitem objects.
+     */
+    take_children(): Menuitem[]
+    /**
+     * Unparents the menu item `mi`. If `mi` doesn't have a
+     * parent, then this call will fail. The menuitem will
+     * be unparented automatically when using the usual methods
+     * to delete a child menuitem, so this function should not
+     * normally be called directly
+     * @returns Whether the menu item was unparented successfully
+     */
+    unparent(): boolean
+
+    // Own virtual methods of Dbusmenu-0.4.Dbusmenu.Menuitem
+
+    vfunc_child_added(position: number): void
+    vfunc_child_moved(newpos: number, oldpos: number): void
+    vfunc_child_removed(): void
+    /**
+     * This function is called to create an event.  It is likely
+     * to be overrided by subclasses.  The default menu item
+     * will respond to the activate signal and do:
+     * 
+     * Emits the #DbusmenuMenuitem::item-activate signal on this
+     * menu item.  Called by server objects when they get the
+     * appropriate DBus signals from the client.
+     * 
+     * If you subclass this function you should really think
+     * about calling the parent function unless you have a good
+     * reason not to.
+     * @virtual 
+     * @param name The name of the signal
+     * @param variant A value that could be set for the event
+     * @param timestamp The timestamp of when the event happened
+     */
+    vfunc_handle_event(name: string | null, variant: GLib.Variant, timestamp: number): void
+    vfunc_show_to_user(timestamp: number, cb_data: any | null): void
+
+    // Own signals of Dbusmenu-0.4.Dbusmenu.Menuitem
+
+    connect(sigName: "about-to-show", callback: Menuitem.AboutToShowSignalCallback): number
+    connect_after(sigName: "about-to-show", callback: Menuitem.AboutToShowSignalCallback): number
+    emit(sigName: "about-to-show", ...args: any[]): void
+    connect(sigName: "child-added", callback: Menuitem.ChildAddedSignalCallback): number
+    connect_after(sigName: "child-added", callback: Menuitem.ChildAddedSignalCallback): number
+    emit(sigName: "child-added", arg1: GObject.Object, arg2: number, ...args: any[]): void
+    connect(sigName: "child-moved", callback: Menuitem.ChildMovedSignalCallback): number
+    connect_after(sigName: "child-moved", callback: Menuitem.ChildMovedSignalCallback): number
+    emit(sigName: "child-moved", arg1: GObject.Object, arg2: number, arg3: number, ...args: any[]): void
+    connect(sigName: "child-removed", callback: Menuitem.ChildRemovedSignalCallback): number
+    connect_after(sigName: "child-removed", callback: Menuitem.ChildRemovedSignalCallback): number
+    emit(sigName: "child-removed", arg1: GObject.Object, ...args: any[]): void
+    connect(sigName: "event", callback: Menuitem.EventSignalCallback): number
+    connect_after(sigName: "event", callback: Menuitem.EventSignalCallback): number
+    emit(sigName: "event", arg1: string | null, arg2: GLib.Variant, arg3: number, ...args: any[]): void
+    connect(sigName: "item-activated", callback: Menuitem.ItemActivatedSignalCallback): number
+    connect_after(sigName: "item-activated", callback: Menuitem.ItemActivatedSignalCallback): number
+    emit(sigName: "item-activated", arg1: number, ...args: any[]): void
+    connect(sigName: "property-changed", callback: Menuitem.PropertyChangedSignalCallback): number
+    connect_after(sigName: "property-changed", callback: Menuitem.PropertyChangedSignalCallback): number
+    emit(sigName: "property-changed", arg1: string | null, arg2: GLib.Variant, ...args: any[]): void
+    connect(sigName: "realized", callback: Menuitem.RealizedSignalCallback): number
+    connect_after(sigName: "realized", callback: Menuitem.RealizedSignalCallback): number
+    emit(sigName: "realized", ...args: any[]): void
+    connect(sigName: "show-to-user", callback: Menuitem.ShowToUserSignalCallback): number
+    connect_after(sigName: "show-to-user", callback: Menuitem.ShowToUserSignalCallback): number
+    emit(sigName: "show-to-user", arg1: number, ...args: any[]): void
+
+    // Class property signals of Dbusmenu-0.4.Dbusmenu.Menuitem
+
+    connect(sigName: "notify::id", callback: (($obj: Menuitem, pspec: GObject.ParamSpec) => void)): number
+    connect_after(sigName: "notify::id", callback: (($obj: Menuitem, pspec: GObject.ParamSpec) => void)): number
+    emit(sigName: "notify::id", ...args: any[]): void
+    connect(sigName: string, callback: (...args: any[]) => void): number
+    connect_after(sigName: string, callback: (...args: any[]) => void): number
+    emit(sigName: string, ...args: any[]): void
+    disconnect(id: number): void
+}
+
+/**
+ * This is the #GObject based object that represents a menu
+ * item.  It gets created the same on both the client and
+ * the server side and libdbusmenu-glib does the work of making
+ * this object model appear on both sides of DBus.  Simple
+ * really, though through updates and people coming on and off
+ * the bus it can lead to lots of fun complex scenarios.
+ * @class 
+ */
+export class Menuitem extends GObject.Object {
+
+    // Own properties of Dbusmenu-0.4.Dbusmenu.Menuitem
+
+    static name: string
+    static $gtype: GObject.GType<Menuitem>
+
+    // Constructors of Dbusmenu-0.4.Dbusmenu.Menuitem
+
+    constructor(config?: Menuitem.ConstructorProperties) 
+    /**
+     * Create a new #DbusmenuMenuitem with all default values.
+     * @constructor 
+     * @returns A newly allocated #DbusmenuMenuitem.
+     */
+    constructor() 
+    /**
+     * Create a new #DbusmenuMenuitem with all default values.
+     * @constructor 
+     * @returns A newly allocated #DbusmenuMenuitem.
+     */
+    static new(): Menuitem
+    /**
+     * This creates a blank #DbusmenuMenuitem with a specific ID.
+     * @constructor 
+     * @param id ID to use for this menuitem
+     * @returns A newly allocated #DbusmenuMenuitem.
+     */
+    static new_with_id(id: number): Menuitem
+    _init(config?: Menuitem.ConstructorProperties): void
+}
+
+export module MenuitemProxy {
+
+    // Constructor properties interface
+
+    export interface ConstructorProperties extends Menuitem.ConstructorProperties {
+
+        // Own constructor properties of Dbusmenu-0.4.Dbusmenu.MenuitemProxy
+
+        menu_item?: Menuitem | null
+    }
+
+}
+
+export interface MenuitemProxy {
+
+    // Own properties of Dbusmenu-0.4.Dbusmenu.MenuitemProxy
+
+    readonly menu_item: Menuitem
+
+    // Owm methods of Dbusmenu-0.4.Dbusmenu.MenuitemProxy
+
+    /**
+     * Accesses the private variable of which #DbusmenuMenuitem
+     * we are doing the proxying for.
+     * @returns A #DbusmenuMenuitem object or a #NULL if we 	don't have one or there is an error.
+     */
+    get_wrapped(): Menuitem
+
+    // Class property signals of Dbusmenu-0.4.Dbusmenu.MenuitemProxy
+
+    connect(sigName: "notify::menu-item", callback: (($obj: MenuitemProxy, pspec: GObject.ParamSpec) => void)): number
+    connect_after(sigName: "notify::menu-item", callback: (($obj: MenuitemProxy, pspec: GObject.ParamSpec) => void)): number
+    emit(sigName: "notify::menu-item", ...args: any[]): void
+    connect(sigName: "notify::id", callback: (($obj: MenuitemProxy, pspec: GObject.ParamSpec) => void)): number
+    connect_after(sigName: "notify::id", callback: (($obj: MenuitemProxy, pspec: GObject.ParamSpec) => void)): number
+    emit(sigName: "notify::id", ...args: any[]): void
+    connect(sigName: string, callback: (...args: any[]) => void): number
+    connect_after(sigName: string, callback: (...args: any[]) => void): number
+    emit(sigName: string, ...args: any[]): void
+    disconnect(id: number): void
+}
+
+/**
+ * Public instance data for a #DbusmenuMenuitemProxy.
+ * @class 
+ */
+export class MenuitemProxy extends Menuitem {
+
+    // Own properties of Dbusmenu-0.4.Dbusmenu.MenuitemProxy
+
+    static name: string
+    static $gtype: GObject.GType<MenuitemProxy>
+
+    // Constructors of Dbusmenu-0.4.Dbusmenu.MenuitemProxy
+
+    constructor(config?: MenuitemProxy.ConstructorProperties) 
+    /**
+     * Builds a new #DbusmenuMenuitemProxy object that proxies
+     * all of the values for `mi`.
+     * @constructor 
+     * @param mi The #DbusmenuMenuitem to proxy
+     * @returns A new #DbusmenuMenuitemProxy object.
+     */
+    constructor(mi: Menuitem) 
+    /**
+     * Builds a new #DbusmenuMenuitemProxy object that proxies
+     * all of the values for `mi`.
+     * @constructor 
+     * @param mi The #DbusmenuMenuitem to proxy
+     * @returns A new #DbusmenuMenuitemProxy object.
+     */
+    static new(mi: Menuitem): MenuitemProxy
+
+    // Overloads of new
+
+    /**
+     * Create a new #DbusmenuMenuitem with all default values.
+     * @constructor 
+     * @returns A newly allocated #DbusmenuMenuitem.
+     */
+    static new(): Menuitem
+    _init(config?: MenuitemProxy.ConstructorProperties): void
+}
+
+export module Server {
+
+    // Signal callback interfaces
+
+    /**
+     * Signal callback interface for `item-activation-requested`
+     */
+    export interface ItemActivationRequestedSignalCallback {
+        ($obj: Server, arg1: number, arg2: number): void
+    }
+
+    /**
+     * Signal callback interface for `item-property-updated`
+     */
+    export interface ItemPropertyUpdatedSignalCallback {
+        ($obj: Server, object: number, p0: string | null, p1: GLib.Variant): void
+    }
+
+    /**
+     * Signal callback interface for `item-updated`
+     */
+    export interface ItemUpdatedSignalCallback {
+        ($obj: Server, object: number): void
+    }
+
+    /**
+     * Signal callback interface for `layout-updated`
+     */
+    export interface LayoutUpdatedSignalCallback {
+        ($obj: Server, arg1: number, arg2: number): void
+    }
+
+
+    // Constructor properties interface
+
+    export interface ConstructorProperties extends GObject.Object.ConstructorProperties {
+
+        // Own constructor properties of Dbusmenu-0.4.Dbusmenu.Server
+
+        dbus_object?: string | null
+        root_node?: Menuitem | null
+    }
+
+}
+
+export interface Server {
+
+    // Own properties of Dbusmenu-0.4.Dbusmenu.Server
+
+    readonly dbus_object: string | null
+    root_node: Menuitem
+    readonly version: number
+
+    // Owm methods of Dbusmenu-0.4.Dbusmenu.Server
+
+    /**
+     * Gets the stored and exported icon paths from the server.
+     * @returns A NULL-terminated list of icon paths with   memory managed by the server.  Duplicate if you want   to keep them.
+     */
+    get_icon_paths(): string[]
+    /**
+     * Gets the current statust hat the server is sending out over
+     * 	DBus.
+     * 
+     * 	Return value: The current status the server is sending
+     */
+    get_status(): Status
+    /**
+     * Returns the value of the text direction that is being exported
+     * 	over DBus for this server.  It should relate to the direction
+     * 	of the labels and other text fields that are being exported by
+     * 	this server.
+     * 
+     * 	Return value: Text direction exported for this server.
+     */
+    get_text_direction(): TextDirection
+    /**
+     * Sets the icon paths for the server.  This will replace previously
+     * 	set icon theme paths.
+     * @param icon_paths 
+     */
+    set_icon_paths(icon_paths: string[]): void
+    /**
+     * This function contains all of the #GValue wrapping
+     * 	required to set the property #DbusmenuServer:root-node
+     * 	on the server `self`.
+     * @param root The new root #DbusmenuMenuitem tree
+     */
+    set_root(root: Menuitem): void
+    /**
+     * Changes the status of the server.
+     * @param status Status value to set on the server
+     */
+    set_status(status: Status): void
+    /**
+     * Sets the text direction that should be exported over DBus for
+     * 	this server.  If the value is set to #DBUSMENU_TEXT_DIRECTION_NONE
+     * 	the default detection will be used for setting the value and
+     * 	exported over DBus.
+     * @param dir Direction of the text
+     */
+    set_text_direction(dir: TextDirection): void
+
+    // Own signals of Dbusmenu-0.4.Dbusmenu.Server
+
+    connect(sigName: "item-activation-requested", callback: Server.ItemActivationRequestedSignalCallback): number
+    connect_after(sigName: "item-activation-requested", callback: Server.ItemActivationRequestedSignalCallback): number
+    emit(sigName: "item-activation-requested", arg1: number, arg2: number, ...args: any[]): void
+    connect(sigName: "item-property-updated", callback: Server.ItemPropertyUpdatedSignalCallback): number
+    connect_after(sigName: "item-property-updated", callback: Server.ItemPropertyUpdatedSignalCallback): number
+    emit(sigName: "item-property-updated", object: number, p0: string | null, p1: GLib.Variant, ...args: any[]): void
+    connect(sigName: "item-updated", callback: Server.ItemUpdatedSignalCallback): number
+    connect_after(sigName: "item-updated", callback: Server.ItemUpdatedSignalCallback): number
+    emit(sigName: "item-updated", object: number, ...args: any[]): void
+    connect(sigName: "layout-updated", callback: Server.LayoutUpdatedSignalCallback): number
+    connect_after(sigName: "layout-updated", callback: Server.LayoutUpdatedSignalCallback): number
+    emit(sigName: "layout-updated", arg1: number, arg2: number, ...args: any[]): void
+
+    // Class property signals of Dbusmenu-0.4.Dbusmenu.Server
+
+    connect(sigName: "notify::dbus-object", callback: (($obj: Server, pspec: GObject.ParamSpec) => void)): number
+    connect_after(sigName: "notify::dbus-object", callback: (($obj: Server, pspec: GObject.ParamSpec) => void)): number
+    emit(sigName: "notify::dbus-object", ...args: any[]): void
+    connect(sigName: "notify::root-node", callback: (($obj: Server, pspec: GObject.ParamSpec) => void)): number
+    connect_after(sigName: "notify::root-node", callback: (($obj: Server, pspec: GObject.ParamSpec) => void)): number
+    emit(sigName: "notify::root-node", ...args: any[]): void
+    connect(sigName: "notify::version", callback: (($obj: Server, pspec: GObject.ParamSpec) => void)): number
+    connect_after(sigName: "notify::version", callback: (($obj: Server, pspec: GObject.ParamSpec) => void)): number
+    emit(sigName: "notify::version", ...args: any[]): void
+    connect(sigName: string, callback: (...args: any[]) => void): number
+    connect_after(sigName: string, callback: (...args: any[]) => void): number
+    emit(sigName: string, ...args: any[]): void
+    disconnect(id: number): void
+}
+
+/**
+ * A server which represents a sharing of a set of
+ * 	#DbusmenuMenuitems across DBus to a #DbusmenuClient.
+ * @class 
+ */
+export class Server extends GObject.Object {
+
+    // Own properties of Dbusmenu-0.4.Dbusmenu.Server
+
+    static name: string
+    static $gtype: GObject.GType<Server>
+
+    // Constructors of Dbusmenu-0.4.Dbusmenu.Server
+
+    constructor(config?: Server.ConstructorProperties) 
+    /**
+     * Creates a new #DbusmenuServer object with a specific object
+     * 	path on DBus.  If `object` is set to NULL the default object
+     * 	name of "/com/canonical/dbusmenu" will be used.
+     * 
+     * 	Return value: A brand new #DbusmenuServer
+     * @constructor 
+     * @param object The object name to show for this menu structure 		on DBus.  May be NULL.
+     */
+    constructor(object: string | null) 
+    /**
+     * Creates a new #DbusmenuServer object with a specific object
+     * 	path on DBus.  If `object` is set to NULL the default object
+     * 	name of "/com/canonical/dbusmenu" will be used.
+     * 
+     * 	Return value: A brand new #DbusmenuServer
+     * @constructor 
+     * @param object The object name to show for this menu structure 		on DBus.  May be NULL.
+     */
+    static new(object: string | null): Server
+    _init(config?: Server.ConstructorProperties): void
+}
+
+export interface ClientClass {
+
+    // Own fields of Dbusmenu-0.4.Dbusmenu.ClientClass
+
+    /**
+     * #GObjectClass
+     * @field 
+     */
+    parent_class: GObject.ObjectClass
+    layout_updated: () => void
+    root_changed: (newroot: Menuitem) => void
+    new_menuitem: (newitem: Menuitem) => void
+    item_activate: (item: Menuitem, timestamp: number) => void
+    event_result: (item: Menuitem, event: string | null, data: GLib.Variant, timestamp: number, error: GLib.Error) => void
+    icon_theme_dirs: (item: Menuitem, theme_dirs: any, error: GLib.Error) => void
+    reserved1: () => void
+    reserved2: () => void
+    reserved3: () => void
+    reserved4: () => void
+    reserved5: () => void
+}
+
+/**
+ * A simple class that takes all of the information from a
+ * 	#DbusmenuServer over DBus and makes the same set of
+ * 	#DbusmenuMenuitem objects appear on the other side.
+ * @record 
+ */
+export abstract class ClientClass {
+
+    // Own properties of Dbusmenu-0.4.Dbusmenu.ClientClass
+
+    static name: string
+}
+
+export interface ClientPrivate {
+}
+
+export class ClientPrivate {
+
+    // Own properties of Dbusmenu-0.4.Dbusmenu.ClientPrivate
+
+    static name: string
+}
+
+export interface MenuitemClass {
+
+    // Own fields of Dbusmenu-0.4.Dbusmenu.MenuitemClass
+
+    /**
+     * Functions and signals from our parent
+     * @field 
+     */
+    parent_class: GObject.ObjectClass
+    property_changed: (property: string | null, value: GLib.Variant) => void
+    item_activated: (timestamp: number) => void
+    child_added: (child: Menuitem, position: number) => void
+    child_removed: (child: Menuitem) => void
+    child_moved: (child: Menuitem, newpos: number, oldpos: number) => void
+    realized: () => void
+    handle_event: (mi: Menuitem, name: string | null, variant: GLib.Variant, timestamp: number) => void
+    show_to_user: (mi: Menuitem, timestamp: number, cb_data: any | null) => void
+    about_to_show: () => boolean
+    event: (name: string | null, value: GLib.Variant, timestamp: number) => void
+    reserved1: () => void
+    reserved2: () => void
+    reserved3: () => void
+    reserved4: () => void
+    reserved5: () => void
+}
+
+/**
+ * Functions and signals that every menuitem should know something
+ * about.
+ * @record 
+ */
+export abstract class MenuitemClass {
+
+    // Own properties of Dbusmenu-0.4.Dbusmenu.MenuitemClass
+
+    static name: string
+}
+
+export interface MenuitemPrivate {
+}
+
+/**
+ * These are the little secrets that we don't want getting
+ * 	out of data that we have.  They can still be gotten using
+ * 	accessor functions, but are protected appropriately.
+ * @record 
+ */
+export class MenuitemPrivate {
+
+    // Own properties of Dbusmenu-0.4.Dbusmenu.MenuitemPrivate
+
+    static name: string
+}
+
+export interface MenuitemProxyClass {
+
+    // Own fields of Dbusmenu-0.4.Dbusmenu.MenuitemProxyClass
+
+    /**
+     * The Class of #DbusmeneMenuitem
+     * @field 
+     */
+    parent_class: MenuitemClass
+    reserved1: () => void
+    reserved2: () => void
+    reserved3: () => void
+    reserved4: () => void
+}
+
+/**
+ * Functions and signal slots for #DbusmenuMenuitemProxy.
+ * @record 
+ */
+export abstract class MenuitemProxyClass {
+
+    // Own properties of Dbusmenu-0.4.Dbusmenu.MenuitemProxyClass
+
+    static name: string
+}
+
+export interface MenuitemProxyPrivate {
+}
+
+export class MenuitemProxyPrivate {
+
+    // Own properties of Dbusmenu-0.4.Dbusmenu.MenuitemProxyPrivate
+
+    static name: string
+}
+
+export interface ServerClass {
+
+    // Own fields of Dbusmenu-0.4.Dbusmenu.ServerClass
+
+    /**
+     * #GObjectClass
+     * @field 
+     */
+    parent_class: GObject.ObjectClass
+    id_prop_update: (id: number, property: string | null, value: string | null) => void
+    id_update: (id: number) => void
+    layout_updated: (revision: number) => void
+    item_activation: (id: number, timestamp: number) => void
+    reserved1: () => void
+    reserved2: () => void
+    reserved3: () => void
+    reserved4: () => void
+    reserved5: () => void
+    reserved6: () => void
+}
+
+/**
+ * The class implementing the virtual functions for #DbusmenuServer.
+ * @record 
+ */
+export abstract class ServerClass {
+
+    // Own properties of Dbusmenu-0.4.Dbusmenu.ServerClass
+
+    static name: string
+}
+
+export interface ServerPrivate {
+}
+
+export class ServerPrivate {
+
+    // Own properties of Dbusmenu-0.4.Dbusmenu.ServerPrivate
+
+    static name: string
+}
+
+/**
+ * Name of the imported GIR library
+ * @see https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188
+ */
+export const __name__: string
+/**
+ * Version of the imported GIR library
+ * @see https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189
+ */
+export const __version__: string
+// END