@gtkx/ffi 0.1.44 → 0.1.46

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

@@ -10,65 +10,968 @@ import { ApplicationCommandLine } from "./application-command-line.js";
 import * as GLib from "../glib/index.js";
 import * as GObject from "../gobject/index.js";
 export declare class Application extends GObject.GObject {
+    /**
+     * Creates a new #GApplication instance.
+     *
+     * If non-%NULL, the application id must be valid.  See
+     * g_application_id_is_valid().
+     *
+     * If no application ID is given then some features of #GApplication
+     * (most notably application uniqueness) will be disabled.
+     * @param applicationId - the application id
+     * @param flags - the application flags
+     */
     constructor(flags: ApplicationFlags, applicationId?: string | null);
     constructor(...args: unknown[]);
     protected createPtr(args: unknown[]): unknown;
+    /**
+     * Returns the default #GApplication instance for this process.
+     *
+     * Normally there is only one #GApplication per process and it becomes
+     * the default when it is created.  You can exercise more control over
+     * this by using g_application_set_default().
+     *
+     * If there is no default application then %NULL is returned.
+     */
     static getDefault(): Application;
+    /**
+     * Checks if `application_id` is a valid application identifier.
+     *
+     * A valid ID is required for calls to g_application_new() and
+     * g_application_set_application_id().
+     *
+     * Application identifiers follow the same format as
+     * D-Bus well-known bus names.
+     * For convenience, the restrictions on application identifiers are
+     * reproduced here:
+     *
+     * - Application identifiers are composed of 1 or more elements separated by a
+     * period (`.`) character. All elements must contain at least one character.
+     *
+     * - Each element must only contain the ASCII characters `[A-Z][a-z][0-9]_-`,
+     * with `-` discouraged in new application identifiers. Each element must not
+     * begin with a digit.
+     *
+     * - Application identifiers must contain at least one `.` (period) character
+     * (and thus at least two elements).
+     *
+     * - Application identifiers must not begin with a `.` (period) character.
+     *
+     * - Application identifiers must not exceed 255 characters.
+     *
+     * Note that the hyphen (`-`) character is allowed in application identifiers,
+     * but is problematic or not allowed in various specifications and APIs that
+     * refer to D-Bus, such as
+     * Flatpak application IDs,
+     * the
+     * `DBusActivatable` interface in the Desktop Entry Specification,
+     * and the convention that an application's "main" interface and object path
+     * resemble its application identifier and bus name. To avoid situations that
+     * require special-case handling, it is recommended that new application
+     * identifiers consistently replace hyphens with underscores.
+     *
+     * Like D-Bus interface names, application identifiers should start with the
+     * reversed DNS domain name of the author of the interface (in lower-case), and
+     * it is conventional for the rest of the application identifier to consist of
+     * words run together, with initial capital letters.
+     *
+     * As with D-Bus interface names, if the author's DNS domain name contains
+     * hyphen/minus characters they should be replaced by underscores, and if it
+     * contains leading digits they should be escaped by prepending an underscore.
+     * For example, if the owner of 7-zip.org used an application identifier for an
+     * archiving application, it might be named `org._7_zip.Archiver`.
+     * @param applicationId - a potential application identifier
+     */
     static idIsValid(applicationId: string): boolean;
+    /**
+     * Activates the application.
+     *
+     * In essence, this results in the #GApplication::activate signal being
+     * emitted in the primary instance.
+     *
+     * The application must be registered before calling this function.
+     */
     activate(): void;
+    /**
+     * Add an option to be handled by @application.
+     *
+     * Calling this function is the equivalent of calling
+     * g_application_add_main_option_entries() with a single #GOptionEntry
+     * that has its arg_data member set to %NULL.
+     *
+     * The parsed arguments will be packed into a #GVariantDict which
+     * is passed to #GApplication::handle-local-options. If
+     * %G_APPLICATION_HANDLES_COMMAND_LINE is set, then it will also
+     * be sent to the primary instance. See
+     * g_application_add_main_option_entries() for more details.
+     *
+     * See #GOptionEntry for more documentation of the arguments.
+     * @param longName - the long name of an option used to specify it in a commandline
+     * @param shortName - the short name of an option
+     * @param flags - flags from #GOptionFlags
+     * @param arg - the type of the option, as a #GOptionArg
+     * @param description - the description for the option in `--help` output
+     * @param argDescription - the placeholder to use for the extra argument
+     */
     addMainOption(longName: string, shortName: number, flags: GLib.OptionFlags, arg: GLib.OptionArg, description: string, argDescription?: string | null): void;
+    /**
+     * Adds main option entries to be handled by @application.
+     *
+     * This function is comparable to g_option_context_add_main_entries().
+     *
+     * After the commandline arguments are parsed, the
+     * #GApplication::handle-local-options signal will be emitted.  At this
+     * point, the application can inspect the values pointed to by `arg_data` in the given #GOptionEntrys.
+     *
+     * Unlike #GOptionContext, #GApplication supports giving a %NULL
+     * `arg_data` for a non-callback #GOptionEntry.  This results in the
+     * argument in question being packed into a #GVariantDict which is also
+     * passed to #GApplication::handle-local-options, where it can be
+     * inspected and modified.  If %G_APPLICATION_HANDLES_COMMAND_LINE is
+     * set, then the resulting dictionary is sent to the primary instance,
+     * where g_application_command_line_get_options_dict() will return it.
+     * As it has been passed outside the process at this point, the types of all
+     * values in the options dict must be checked before being used.
+     * This "packing" is done according to the type of the argument --
+     * booleans for normal flags, strings for strings, bytestrings for
+     * filenames, etc.  The packing only occurs if the flag is given (ie: we
+     * do not pack a "false" #GVariant in the case that a flag is missing).
+     *
+     * In general, it is recommended that all commandline arguments are
+     * parsed locally.  The options dictionary should then be used to
+     * transmit the result of the parsing to the primary instance, where
+     * g_variant_dict_lookup() can be used.  For local options, it is
+     * possible to either use `arg_data` in the usual way, or to consult (and
+     * potentially remove) the option from the options dictionary.
+     *
+     * This function is new in GLib 2.40.  Before then, the only real choice
+     * was to send all of the commandline arguments (options and all) to the
+     * primary instance for handling.  #GApplication ignored them completely
+     * on the local side.  Calling this function "opts in" to the new
+     * behaviour, and in particular, means that unrecognized options will be
+     * treated as errors.  Unrecognized options have never been ignored when
+     * %G_APPLICATION_HANDLES_COMMAND_LINE is unset.
+     *
+     * If #GApplication::handle-local-options needs to see the list of
+     * filenames, then the use of %G_OPTION_REMAINING is recommended.  If
+     * `arg_data` is %NULL then %G_OPTION_REMAINING can be used as a key into
+     * the options dictionary.  If you do use %G_OPTION_REMAINING then you
+     * need to handle these arguments for yourself because once they are
+     * consumed, they will no longer be visible to the default handling
+     * (which treats them as filenames to be opened).
+     *
+     * It is important to use the proper GVariant format when retrieving
+     * the options with g_variant_dict_lookup():
+     * - for %G_OPTION_ARG_NONE, use `b`
+     * - for %G_OPTION_ARG_STRING, use `&s`
+     * - for %G_OPTION_ARG_INT, use `i`
+     * - for %G_OPTION_ARG_INT64, use `x`
+     * - for %G_OPTION_ARG_DOUBLE, use `d`
+     * - for %G_OPTION_ARG_FILENAME, use `^&ay`
+     * - for %G_OPTION_ARG_STRING_ARRAY, use `^a&s`
+     * - for %G_OPTION_ARG_FILENAME_ARRAY, use `^a&ay`
+     * @param entries - the
+     */
     addMainOptionEntries(entries: number[]): void;
+    /**
+     * Adds a #GOptionGroup to the commandline handling of @application.
+     *
+     * This function is comparable to g_option_context_add_group().
+     *
+     * Unlike g_application_add_main_option_entries(), this function does
+     * not deal with %NULL `arg_data` and never transmits options to the
+     * primary instance.
+     *
+     * The reason for that is because, by the time the options arrive at the
+     * primary instance, it is typically too late to do anything with them.
+     * Taking the GTK option group as an example: GTK will already have been
+     * initialised by the time the #GApplication::command-line handler runs.
+     * In the case that this is not the first-running instance of the
+     * application, the existing instance may already have been running for
+     * a very long time.
+     *
+     * This means that the options from #GOptionGroup are only really usable
+     * in the case that the instance of the application being run is the
+     * first instance.  Passing options like `--display=` or `--gdk-debug=`
+     * on future runs will have no effect on the existing primary instance.
+     *
+     * Calling this function will cause the options in the supplied option
+     * group to be parsed, but it does not cause you to be "opted in" to the
+     * new functionality whereby unrecognized options are rejected even if
+     * %G_APPLICATION_HANDLES_COMMAND_LINE was given.
+     * @param group - a #GOptionGroup
+     */
     addOptionGroup(group: GLib.OptionGroup): void;
+    /**
+     * Marks `application` as busy (see g_application_mark_busy()) while
+     * `property` on `object` is %TRUE.
+     *
+     * The binding holds a reference to `application` while it is active, but
+     * not to @object. Instead, the binding is destroyed when `object` is
+     * finalized.
+     * @param object - a #GObject
+     * @param property - the name of a boolean property of @object
+     */
     bindBusyProperty(object: GObject.GObject, property: string): void;
+    /**
+     * Gets the unique identifier for @application.
+     */
     getApplicationId(): string | null;
+    /**
+     * Gets the #GDBusConnection being used by the application, or %NULL.
+     *
+     * If #GApplication is using its D-Bus backend then this function will
+     * return the #GDBusConnection being used for uniqueness and
+     * communication with the desktop environment and other instances of the
+     * application.
+     *
+     * If #GApplication is not using D-Bus then this function will return
+     * %NULL.  This includes the situation where the D-Bus backend would
+     * normally be in use but we were unable to connect to the bus.
+     *
+     * This function must not be called before the application has been
+     * registered.  See g_application_get_is_registered().
+     */
     getDbusConnection(): DBusConnection | null;
+    /**
+     * Gets the D-Bus object path being used by the application, or %NULL.
+     *
+     * If #GApplication is using its D-Bus backend then this function will
+     * return the D-Bus object path that #GApplication is using.  If the
+     * application is the primary instance then there is an object published
+     * at this path.  If the application is not the primary instance then
+     * the result of this function is undefined.
+     *
+     * If #GApplication is not using D-Bus then this function will return
+     * %NULL.  This includes the situation where the D-Bus backend would
+     * normally be in use but we were unable to connect to the bus.
+     *
+     * This function must not be called before the application has been
+     * registered.  See g_application_get_is_registered().
+     */
     getDbusObjectPath(): string | null;
+    /**
+     * Gets the flags for @application.
+     *
+     * See #GApplicationFlags.
+     */
     getFlags(): ApplicationFlags;
+    /**
+     * Gets the current inactivity timeout for the application.
+     *
+     * This is the amount of time (in milliseconds) after the last call to
+     * g_application_release() before the application stops running.
+     */
     getInactivityTimeout(): number;
+    /**
+     * Gets the application's current busy state, as set through
+     * g_application_mark_busy() or g_application_bind_busy_property().
+     */
     getIsBusy(): boolean;
+    /**
+     * Checks if `application` is registered.
+     *
+     * An application is registered if g_application_register() has been
+     * successfully called.
+     */
     getIsRegistered(): boolean;
+    /**
+     * Checks if `application` is remote.
+     *
+     * If `application` is remote then it means that another instance of
+     * application already exists (the 'primary' instance).  Calls to
+     * perform actions on `application` will result in the actions being
+     * performed by the primary instance.
+     *
+     * The value of this property cannot be accessed before
+     * g_application_register() has been called.  See
+     * g_application_get_is_registered().
+     */
     getIsRemote(): boolean;
+    /**
+     * Gets the resource base path of @application.
+     *
+     * See g_application_set_resource_base_path() for more information.
+     */
     getResourceBasePath(): string | null;
+    /**
+     * Gets the version of @application.
+     */
     getVersion(): string | null;
+    /**
+     * Increases the use count of @application.
+     *
+     * Use this function to indicate that the application has a reason to
+     * continue to run.  For example, g_application_hold() is called by GTK
+     * when a toplevel window is on the screen.
+     *
+     * To cancel the hold, call g_application_release().
+     */
     hold(): void;
+    /**
+     * Increases the busy count of @application.
+     *
+     * Use this function to indicate that the application is busy, for instance
+     * while a long running operation is pending.
+     *
+     * The busy state will be exposed to other processes, so a session shell will
+     * use that information to indicate the state to the user (e.g. with a
+     * spinner).
+     *
+     * To cancel the busy indication, use g_application_unmark_busy().
+     *
+     * The application must be registered before calling this function.
+     */
     markBusy(): void;
+    /**
+     * Opens the given files.
+     *
+     * In essence, this results in the #GApplication::open signal being emitted
+     * in the primary instance.
+     *
+     * `n_files` must be greater than zero.
+     *
+     * `hint` is simply passed through to the ::open signal.  It is
+     * intended to be used by applications that have multiple modes for
+     * opening files (eg: "view" vs "edit", etc).  Unless you have a need
+     * for this functionality, you should use "".
+     *
+     * The application must be registered before calling this function
+     * and it must have the %G_APPLICATION_HANDLES_OPEN flag set.
+     * @param files - an array of #GFiles to open
+     * @param nFiles - the length of the `files` array
+     * @param hint - a hint (or ""), but never %NULL
+     */
     open(files: File[], nFiles: number, hint: string): void;
+    /**
+     * Immediately quits the application.
+     *
+     * Upon return to the mainloop, g_application_run() will return,
+     * calling only the 'shutdown' function before doing so.
+     *
+     * The hold count is ignored.
+     * Take care if your code has called g_application_hold() on the application and
+     * is therefore still expecting it to exist.
+     * (Note that you may have called g_application_hold() indirectly, for example
+     * through gtk_application_add_window().)
+     *
+     * The result of calling g_application_run() again after it returns is
+     * unspecified.
+     */
     quit(): void;
+    /**
+     * Attempts registration of the application.
+     *
+     * This is the point at which the application discovers if it is the
+     * primary instance or merely acting as a remote for an already-existing
+     * primary instance.  This is implemented by attempting to acquire the
+     * application identifier as a unique bus name on the session bus using
+     * GDBus.
+     *
+     * If there is no application ID or if %G_APPLICATION_NON_UNIQUE was
+     * given, then this process will always become the primary instance.
+     *
+     * Due to the internal architecture of GDBus, method calls can be
+     * dispatched at any time (even if a main loop is not running).  For
+     * this reason, you must ensure that any object paths that you wish to
+     * register are registered before calling this function.
+     *
+     * If the application has already been registered then %TRUE is
+     * returned with no work performed.
+     *
+     * The #GApplication::startup signal is emitted if registration succeeds
+     * and `application` is the primary instance (including the non-unique
+     * case).
+     *
+     * In the event of an error (such as `cancellable` being cancelled, or a
+     * failure to connect to the session bus), %FALSE is returned and `error` is set appropriately.
+     *
+     * Note: the return value of this function is not an indicator that this
+     * instance is or is not the primary instance of the application.  See
+     * g_application_get_is_remote() for that.
+     * @param cancellable - a #GCancellable, or %NULL
+     */
     register(cancellable?: Cancellable | null): boolean;
+    /**
+     * Decrease the use count of @application.
+     *
+     * When the use count reaches zero, the application will stop running.
+     *
+     * Never call this function except to cancel the effect of a previous
+     * call to g_application_hold().
+     */
     release(): void;
+    /**
+     * Runs the application.
+     *
+     * This function is intended to be run from main() and its return value
+     * is intended to be returned by main(). Although you are expected to pass
+     * the @argc, `argv` parameters from main() to this function, it is possible
+     * to pass %NULL if `argv` is not available or commandline handling is not
+     * required.  Note that on Windows, `argc` and `argv` are ignored, and
+     * g_win32_get_command_line() is called internally (for proper support
+     * of Unicode commandline arguments).
+     *
+     * #GApplication will attempt to parse the commandline arguments.  You
+     * can add commandline flags to the list of recognised options by way of
+     * g_application_add_main_option_entries().  After this, the
+     * #GApplication::handle-local-options signal is emitted, from which the
+     * application can inspect the values of its #GOptionEntrys.
+     *
+     * #GApplication::handle-local-options is a good place to handle options
+     * such as `--version`, where an immediate reply from the local process is
+     * desired (instead of communicating with an already-running instance).
+     * A #GApplication::handle-local-options handler can stop further processing
+     * by returning a non-negative value, which then becomes the exit status of
+     * the process.
+     *
+     * What happens next depends on the flags: if
+     * %G_APPLICATION_HANDLES_COMMAND_LINE was specified then the remaining
+     * commandline arguments are sent to the primary instance, where a
+     * #GApplication::command-line signal is emitted.  Otherwise, the
+     * remaining commandline arguments are assumed to be a list of files.
+     * If there are no files listed, the application is activated via the
+     * #GApplication::activate signal.  If there are one or more files, and
+     * %G_APPLICATION_HANDLES_OPEN was specified then the files are opened
+     * via the #GApplication::open signal.
+     *
+     * If you are interested in doing more complicated local handling of the
+     * commandline then you should implement your own #GApplication subclass
+     * and override local_command_line(). In this case, you most likely want
+     * to return %TRUE from your local_command_line() implementation to
+     * suppress the default handling. See
+     * [gapplication-example-cmdline2.c][https://gitlab.gnome.org/GNOME/glib/-/blob/HEAD/gio/tests/gapplication-example-cmdline2.c]
+     * for an example.
+     *
+     * If, after the above is done, the use count of the application is zero
+     * then the exit status is returned immediately.  If the use count is
+     * non-zero then the default main context is iterated until the use count
+     * falls to zero, at which point 0 is returned.
+     *
+     * If the %G_APPLICATION_IS_SERVICE flag is set, then the service will
+     * run for as much as 10 seconds with a use count of zero while waiting
+     * for the message that caused the activation to arrive.  After that,
+     * if the use count falls to zero the application will exit immediately,
+     * except in the case that g_application_set_inactivity_timeout() is in
+     * use.
+     *
+     * This function sets the prgname (g_set_prgname()), if not already set,
+     * to the basename of argv[0].
+     *
+     * Much like g_main_loop_run(), this function will acquire the main context
+     * for the duration that the application is running.
+     *
+     * Since 2.40, applications that are not explicitly flagged as services
+     * or launchers (ie: neither %G_APPLICATION_IS_SERVICE or
+     * %G_APPLICATION_IS_LAUNCHER are given as flags) will check (from the
+     * default handler for local_command_line) if "--gapplication-service"
+     * was given in the command line.  If this flag is present then normal
+     * commandline processing is interrupted and the
+     * %G_APPLICATION_IS_SERVICE flag is set.  This provides a "compromise"
+     * solution whereby running an application directly from the commandline
+     * will invoke it in the normal way (which can be useful for debugging)
+     * while still allowing applications to be D-Bus activated in service
+     * mode.  The D-Bus service file should invoke the executable with
+     * "--gapplication-service" as the sole commandline argument.  This
+     * approach is suitable for use by most graphical applications but
+     * should not be used from applications like editors that need precise
+     * control over when processes invoked via the commandline will exit and
+     * what their exit status will be.
+     * @param argc - the argc from main() (or 0 if `argv` is %NULL)
+     * @param argv - the argv from main(), or %NULL
+     */
     run(argc: number, argv?: string[] | null): number;
+    /**
+     * Sends a notification on behalf of `application` to the desktop shell.
+     * There is no guarantee that the notification is displayed immediately,
+     * or even at all.
+     *
+     * Notifications may persist after the application exits. It will be
+     * D-Bus-activated when the notification or one of its actions is
+     * activated.
+     *
+     * Modifying `notification` after this call has no effect. However, the
+     * object can be reused for a later call to this function.
+     *
+     * `id` may be any string that uniquely identifies the event for the
+     * application. It does not need to be in any special format. For
+     * example, "new-message" might be appropriate for a notification about
+     * new messages.
+     *
+     * If a previous notification was sent with the same @id, it will be
+     * replaced with `notification` and shown again as if it was a new
+     * notification. This works even for notifications sent from a previous
+     * execution of the application, as long as `id` is the same string.
+     *
+     * `id` may be `NULL`, but it is impossible to replace or withdraw
+     * notifications without an id.
+     *
+     * If `notification` is no longer relevant, it can be withdrawn with
+     * [method@Gio.Application.withdraw_notification].
+     *
+     * It is an error to call this function if `application` has no
+     * application ID.
+     * @param id - id of the notification, or %NULL
+     * @param notification - the #GNotification to send
+     */
     sendNotification(notification: Notification, id?: string | null): void;
+    /**
+     * This used to be how actions were associated with a #GApplication.
+     * Now there is #GActionMap for that.
+     * @param actionGroup - a #GActionGroup, or %NULL
+     */
     setActionGroup(actionGroup?: ActionGroup | null): void;
+    /**
+     * Sets the unique identifier for @application.
+     *
+     * The application id can only be modified if `application` has not yet
+     * been registered.
+     *
+     * If non-%NULL, the application id must be valid.  See
+     * g_application_id_is_valid().
+     * @param applicationId - the identifier for @application
+     */
     setApplicationId(applicationId?: string | null): void;
+    /**
+     * Sets or unsets the default application for the process, as returned
+     * by g_application_get_default().
+     *
+     * This function does not take its own reference on @application.  If
+     * `application` is destroyed then the default application will revert
+     * back to %NULL.
+     */
     setDefault(): void;
+    /**
+     * Sets the flags for @application.
+     *
+     * The flags can only be modified if `application` has not yet been
+     * registered.
+     *
+     * See #GApplicationFlags.
+     * @param flags - the flags for @application
+     */
     setFlags(flags: ApplicationFlags): void;
+    /**
+     * Sets the current inactivity timeout for the application.
+     *
+     * This is the amount of time (in milliseconds) after the last call to
+     * g_application_release() before the application stops running.
+     *
+     * This call has no side effects of its own.  The value set here is only
+     * used for next time g_application_release() drops the use count to
+     * zero.  Any timeouts currently in progress are not impacted.
+     * @param inactivityTimeout - the timeout, in milliseconds
+     */
     setInactivityTimeout(inactivityTimeout: number): void;
+    /**
+     * Adds a description to the `application` option context.
+     *
+     * See g_option_context_set_description() for more information.
+     * @param description - a string to be shown in `--help` output
+     */
     setOptionContextDescription(description?: string | null): void;
+    /**
+     * Sets the parameter string to be used by the commandline handling of @application.
+     *
+     * This function registers the argument to be passed to g_option_context_new()
+     * when the internal #GOptionContext of `application` is created.
+     *
+     * See g_option_context_new() for more information about @parameter_string.
+     * @param parameterString - a string which is displayed
+     */
     setOptionContextParameterString(parameterString?: string | null): void;
+    /**
+     * Adds a summary to the `application` option context.
+     *
+     * See g_option_context_set_summary() for more information.
+     * @param summary - a string to be shown in `--help` output
+     */
     setOptionContextSummary(summary?: string | null): void;
+    /**
+     * Sets (or unsets) the base resource path of @application.
+     *
+     * The path is used to automatically load various
+     * [application resources][struct@Gio.Resource] such as menu layouts and
+     * action descriptions. The various types of resources will be found at
+     * fixed names relative to the given base path.
+     *
+     * By default, the resource base path is determined from the application
+     * ID by prefixing '/' and replacing each '.' with '/'.  This is done at
+     * the time that the #GApplication object is constructed.  Changes to
+     * the application ID after that point will not have an impact on the
+     * resource base path.
+     *
+     * As an example, if the application has an ID of "org.example.app" then
+     * the default resource base path will be "/org/example/app".  If this
+     * is a #GtkApplication (and you have not manually changed the path)
+     * then Gtk will then search for the menus of the application at
+     * "/org/example/app/gtk/menus.ui".
+     *
+     * See #GResource for more information about adding resources to your
+     * application.
+     *
+     * You can disable automatic resource loading functionality by setting
+     * the path to %NULL.
+     *
+     * Changing the resource base path once the application is running is
+     * not recommended.  The point at which the resource path is consulted
+     * for forming paths for various purposes is unspecified.  When writing
+     * a sub-class of #GApplication you should either set the
+     * #GApplication:resource-base-path property at construction time, or call
+     * this function during the instance initialization. Alternatively, you
+     * can call this function in the #GApplicationClass.startup virtual function,
+     * before chaining up to the parent implementation.
+     * @param resourcePath - the resource path to use
+     */
     setResourceBasePath(resourcePath?: string | null): void;
+    /**
+     * Sets the version number of @application. This will be used to implement
+     * a `--version` command line argument
+     *
+     * The application version can only be modified if `application` has not yet
+     * been registered.
+     * @param version - the version of @application
+     */
     setVersion(version: string): void;
+    /**
+     * Destroys a binding between `property` and the busy state of
+     * `application` that was previously created with
+     * g_application_bind_busy_property().
+     * @param object - a #GObject
+     * @param property - the name of a boolean property of @object
+     */
     unbindBusyProperty(object: GObject.GObject, property: string): void;
+    /**
+     * Decreases the busy count of @application.
+     *
+     * When the busy count reaches zero, the new state will be propagated
+     * to other processes.
+     *
+     * This function must only be called to cancel the effect of a previous
+     * call to g_application_mark_busy().
+     */
     unmarkBusy(): void;
+    /**
+     * Withdraws a notification that was sent with
+     * g_application_send_notification().
+     *
+     * This call does nothing if a notification with `id` doesn't exist or
+     * the notification was never sent.
+     *
+     * This function works even for notifications sent in previous
+     * executions of this application, as long `id` is the same as it was for
+     * the sent notification.
+     *
+     * Note that notifications are dismissed when the user clicks on one
+     * of the buttons in a notification or triggers its default action, so
+     * there is no need to explicitly withdraw the notification in that case.
+     * @param id - id of a previously sent notification
+     */
     withdrawNotification(id: string): void;
+    /**
+     * Emits the [signal@Gio.ActionGroup::action-added] signal on @action_group.
+     *
+     * This function should only be called by [type@Gio.ActionGroup] implementations.
+     * @param actionName - the name of an action in the group
+     */
     actionAdded(actionName: string): void;
+    /**
+     * Emits the [signal@Gio.ActionGroup::action-enabled-changed] signal on @action_group.
+     *
+     * This function should only be called by [type@Gio.ActionGroup] implementations.
+     * @param actionName - the name of an action in the group
+     * @param enabled - whether the action is now enabled
+     */
     actionEnabledChanged(actionName: string, enabled: boolean): void;
+    /**
+     * Emits the [signal@Gio.ActionGroup::action-removed] signal on @action_group.
+     *
+     * This function should only be called by [type@Gio.ActionGroup] implementations.
+     * @param actionName - the name of an action in the group
+     */
     actionRemoved(actionName: string): void;
+    /**
+     * Emits the [signal@Gio.ActionGroup::action-state-changed] signal on @action_group.
+     *
+     * This function should only be called by [type@Gio.ActionGroup] implementations.
+     * @param actionName - the name of an action in the group
+     * @param state - the new state of the named action
+     */
     actionStateChanged(actionName: string, state: GLib.Variant): void;
+    /**
+     * Activate the named action within @action_group.
+     *
+     * If the action is expecting a parameter, then the correct type of
+     * parameter must be given as @parameter.  If the action is expecting no
+     * parameters then `parameter` must be `NULL`.  See
+     * [method@Gio.ActionGroup.get_action_parameter_type].
+     *
+     * If the [type@Gio.ActionGroup] implementation supports asynchronous remote
+     * activation over D-Bus, this call may return before the relevant
+     * D-Bus traffic has been sent, or any replies have been received. In
+     * order to block on such asynchronous activation calls,
+     * [method@Gio.DBusConnection.flush] should be called prior to the code, which
+     * depends on the result of the action activation. Without flushing
+     * the D-Bus connection, there is no guarantee that the action would
+     * have been activated.
+     *
+     * The following code which runs in a remote app instance, shows an
+     * example of a ‘quit’ action being activated on the primary app
+     * instance over D-Bus. Here [method@Gio.DBusConnection.flush] is called
+     * before `exit()`. Without `g_dbus_connection_flush()`, the ‘quit’ action
+     * may fail to be activated on the primary instance.
+     *
+     * ```c
+     * // call ‘quit’ action on primary instance
+     * g_action_group_activate_action (G_ACTION_GROUP (app), "quit", NULL);
+     *
+     * // make sure the action is activated now
+     * g_dbus_connection_flush (…);
+     *
+     * g_debug ("Application has been terminated. Exiting.");
+     *
+     * exit (0);
+     * ```
+     * @param actionName - the name of the action to activate
+     * @param parameter - parameters to the activation
+     */
     activateAction(actionName: string, parameter?: GLib.Variant | null): void;
+    /**
+     * Request for the state of the named action within `action_group` to be
+     * changed to @value.
+     *
+     * The action must be stateful and `value` must be of the correct type.
+     * See [method@Gio.ActionGroup.get_action_state_type].
+     *
+     * This call merely requests a change.  The action may refuse to change
+     * its state or may change its state to something other than @value.
+     * See [method@Gio.ActionGroup.get_action_state_hint].
+     *
+     * If the `value` GVariant is floating, it is consumed.
+     * @param actionName - the name of the action to request the change on
+     * @param value - the new state
+     */
     changeActionState(actionName: string, value: GLib.Variant): void;
+    /**
+     * Checks if the named action within `action_group` is currently enabled.
+     *
+     * An action must be enabled in order to be activated or in order to
+     * have its state changed from outside callers.
+     * @param actionName - the name of the action to query
+     */
     getActionEnabled(actionName: string): boolean;
+    /**
+     * Queries the type of the parameter that must be given when activating
+     * the named action within @action_group.
+     *
+     * When activating the action using [method@Gio.ActionGroup.activate_action],
+     * the [type@GLib.Variant] given to that function must be of the type returned
+     * by this function.
+     *
+     * In the case that this function returns `NULL`, you must not give any
+     * [type@GLib.Variant], but `NULL` instead.
+     *
+     * The parameter type of a particular action will never change but it is
+     * possible for an action to be removed and for a new action to be added
+     * with the same name but a different parameter type.
+     * @param actionName - the name of the action to query
+     */
     getActionParameterType(actionName: string): GLib.VariantType | null;
+    /**
+     * Queries the current state of the named action within @action_group.
+     *
+     * If the action is not stateful then `NULL` will be returned.  If the
+     * action is stateful then the type of the return value is the type
+     * given by [method@Gio.ActionGroup.get_action_state_type].
+     *
+     * The return value (if non-`NULL`) should be freed with
+     * [method@GLib.Variant.unref] when it is no longer required.
+     * @param actionName - the name of the action to query
+     */
     getActionState(actionName: string): GLib.Variant | null;
+    /**
+     * Requests a hint about the valid range of values for the state of the
+     * named action within @action_group.
+     *
+     * If `NULL` is returned it either means that the action is not stateful
+     * or that there is no hint about the valid range of values for the
+     * state of the action.
+     *
+     * If a [type@GLib.Variant] array is returned then each item in the array is a
+     * possible value for the state.  If a [type@GLib.Variant] pair (ie: two-tuple) is
+     * returned then the tuple specifies the inclusive lower and upper bound
+     * of valid values for the state.
+     *
+     * In any case, the information is merely a hint.  It may be possible to
+     * have a state value outside of the hinted range and setting a value
+     * within the range may fail.
+     *
+     * The return value (if non-`NULL`) should be freed with
+     * [method@GLib.Variant.unref] when it is no longer required.
+     * @param actionName - the name of the action to query
+     */
     getActionStateHint(actionName: string): GLib.Variant | null;
+    /**
+     * Queries the type of the state of the named action within
+     * @action_group.
+     *
+     * If the action is stateful then this function returns the
+     * [type@GLib.VariantType] of the state.  All calls to
+     * [method@Gio.ActionGroup.change_action_state] must give a [type@GLib.Variant] of this
+     * type and [method@Gio.ActionGroup.get_action_state] will return a [type@GLib.Variant]
+     * of the same type.
+     *
+     * If the action is not stateful then this function will return `NULL`.
+     * In that case, [method@Gio.ActionGroup.get_action_state] will return `NULL`
+     * and you must not call [method@Gio.ActionGroup.change_action_state].
+     *
+     * The state type of a particular action will never change but it is
+     * possible for an action to be removed and for a new action to be added
+     * with the same name but a different state type.
+     * @param actionName - the name of the action to query
+     */
     getActionStateType(actionName: string): GLib.VariantType | null;
+    /**
+     * Checks if the named action exists within @action_group.
+     * @param actionName - the name of the action to check for
+     */
     hasAction(actionName: string): boolean;
+    /**
+     * Lists the actions contained within @action_group.
+     *
+     * The caller is responsible for freeing the list with [func@GLib.strfreev] when
+     * it is no longer required.
+     */
     listActions(): string[];
+    /**
+     * Queries all aspects of the named action within an @action_group.
+     *
+     * This function acquires the information available from
+     * [method@Gio.ActionGroup.has_action], [method@Gio.ActionGroup.get_action_enabled],
+     * [method@Gio.ActionGroup.get_action_parameter_type],
+     * [method@Gio.ActionGroup.get_action_state_type],
+     * [method@Gio.ActionGroup.get_action_state_hint] and
+     * [method@Gio.ActionGroup.get_action_state] with a single function call.
+     *
+     * This provides two main benefits.
+     *
+     * The first is the improvement in efficiency that comes with not having
+     * to perform repeated lookups of the action in order to discover
+     * different things about it.  The second is that implementing
+     * [type@Gio.ActionGroup] can now be done by only overriding this one virtual
+     * function.
+     *
+     * The interface provides a default implementation of this function that
+     * calls the individual functions, as required, to fetch the
+     * information.  The interface also provides default implementations of
+     * those functions that call this function.  All implementations,
+     * therefore, must override either this function or all of the others.
+     *
+     * If the action exists, `TRUE` is returned and any of the requested
+     * fields (as indicated by having a non-`NULL` reference passed in) are
+     * filled.  If the action doesn’t exist, `FALSE` is returned and the
+     * fields may or may not have been modified.
+     * @param actionName - the name of an action in the group
+     * @param enabled - if the action is presently enabled
+     * @param parameterType - the parameter type, or `NULL` if none needed
+     * @param stateType - the state type, or `NULL` if stateless
+     * @param stateHint - the state hint, or `NULL` if none
+     * @param state - the current state, or `NULL` if stateless
+     */
     queryAction(actionName: string, enabled: Ref<boolean>, parameterType?: Ref<GLib.VariantType> | null, stateType?: Ref<GLib.VariantType> | null, stateHint?: Ref<GLib.Variant> | null, state?: Ref<GLib.Variant> | null): boolean;
+    /**
+     * Adds an action to the @action_map.
+     *
+     * If the action map already contains an action with the same name
+     * as `action` then the old action is dropped from the action map.
+     *
+     * The action map takes its own reference on @action.
+     * @param action - a [iface@Gio.Action]
+     */
     addAction(action: Action): void;
+    /**
+     * A convenience function for creating multiple [class@Gio.SimpleAction]
+     * instances and adding them to a [iface@Gio.ActionMap].
+     *
+     * Each action is constructed as per one [struct@Gio.ActionEntry].
+     *
+     * ```c
+     * static void
+     * activate_quit (GSimpleAction *simple,
+     * GVariant      *parameter,
+     * gpointer       user_data)
+     * {
+     * exit (0);
+     * }
+     *
+     * static void
+     * activate_print_string (GSimpleAction *simple,
+     * GVariant      *parameter,
+     * gpointer       user_data)
+     * {
+     * g_print ("%s\n", g_variant_get_string (parameter, NULL));
+     * }
+     *
+     * static GActionGroup *
+     * create_action_group (void)
+     * {
+     * const GActionEntry entries[] = {
+     * { "quit",         activate_quit              },
+     * { "print-string", activate_print_string, "s" }
+     * };
+     * GSimpleActionGroup *group;
+     *
+     * group = g_simple_action_group_new ();
+     * g_action_map_add_action_entries (G_ACTION_MAP (group), entries, G_N_ELEMENTS (entries), NULL);
+     *
+     * return G_ACTION_GROUP (group);
+     * }
+     * ```
+     * @param entries - a pointer to
+     * @param nEntries - the length of @entries, or -1 if `entries` is `NULL`-terminated
+     * @param userData - the user data for signal connections
+     */
     addActionEntries(entries: number[], nEntries: number, userData?: number | null): void;
+    /**
+     * Looks up the action with the name `action_name` in @action_map.
+     *
+     * If no such action exists, returns `NULL`.
+     * @param actionName - the name of an action
+     */
     lookupAction(actionName: string): Action | null;
+    /**
+     * Removes the named action from the action map.
+     *
+     * If no action of this name is in the map then nothing happens.
+     * @param actionName - the name of the action
+     */
     removeAction(actionName: string): void;
+    /**
+     * Remove actions from a [iface@Gio.ActionMap]. This is meant as the reverse of
+     * [method@Gio.ActionMap.add_action_entries].
+     *
+     *
+     * ```c
+     * static const GActionEntry entries[] = {
+     * { "quit",         activate_quit              },
+     * { "print-string", activate_print_string, "s" }
+     * };
+     *
+     * void
+     * add_actions (GActionMap *map)
+     * {
+     * g_action_map_add_action_entries (map, entries, G_N_ELEMENTS (entries), NULL);
+     * }
+     *
+     * void
+     * remove_actions (GActionMap *map)
+     * {
+     * g_action_map_remove_action_entries (map, entries, G_N_ELEMENTS (entries));
+     * }
+     * ```
+     * @param entries - a pointer to
+     * @param nEntries - the length of @entries, or -1 if `entries` is `NULL`-terminated
+     */
     removeActionEntries(entries: number[], nEntries: number): void;
     connect(signal: "activate", handler: (self: Application) => void, after?: boolean): number;
     connect(signal: "command-line", handler: (self: Application, commandLine: ApplicationCommandLine) => number, after?: boolean): number;