@gtkx/ffi 0.10.4 → 0.11.0

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

@@ -1,14 +1,140 @@
 import { Ref } from "@gtkx/native";
 import { ApplicationFlags } from "./enums.js";
+import { ActionEntry } from "./action-entry.js";
 import { Action } from "./action.js";
 import { ActionGroup } from "./action-group.js";
-import { Cancellable } from "./cancellable.js";
-import { DBusConnection } from "./dbus-connection.js";
 import { File } from "./file.js";
-import { Notification } from "./notification.js";
 import { ApplicationCommandLine } from "./application-command-line.js";
+import { Cancellable } from "./cancellable.js";
+import { DBusConnection } from "./d-bus-connection.js";
+import { Notification } from "./notification.js";
 import * as GLib from "../glib/index.js";
 import * as GObject from "../gobject/index.js";
+/**
+ * `GApplication` is the core class for application support.
+ *
+ * A `GApplication` is the foundation of an application. It wraps some
+ * low-level platform-specific services and is intended to act as the
+ * foundation for higher-level application classes such as
+ * `GtkApplication` or `MxApplication`. In general, you should not use
+ * this class outside of a higher level framework.
+ *
+ * `GApplication` provides convenient life-cycle management by maintaining
+ * a "use count" for the primary application instance. The use count can
+ * be changed using {@link Gio.Application.hold} and
+ * {@link Gio.Application.release}. If it drops to zero, the application
+ * exits. Higher-level classes such as `GtkApplication` employ the use count
+ * to ensure that the application stays alive as long as it has any opened
+ * windows.
+ *
+ * Another feature that `GApplication` (optionally) provides is process
+ * uniqueness. Applications can make use of this functionality by
+ * providing a unique application ID. If given, only one application
+ * with this ID can be running at a time per session. The session
+ * concept is platform-dependent, but corresponds roughly to a graphical
+ * desktop login. When your application is launched again, its
+ * arguments are passed through platform communication to the already
+ * running program. The already running instance of the program is
+ * called the "primary instance"; for non-unique applications this is
+ * always the current instance. On Linux, the D-Bus session bus
+ * is used for communication.
+ *
+ * The use of `GApplication` differs from some other commonly-used
+ * uniqueness libraries (such as libunique) in important ways. The
+ * application is not expected to manually register itself and check
+ * if it is the primary instance. Instead, the main() function of a
+ * `GApplication` should do very little more than instantiating the
+ * application instance, possibly connecting signal handlers, then
+ * calling {@link Gio.Application.run}. All checks for uniqueness are done
+ * internally. If the application is the primary instance then the
+ * startup signal is emitted and the mainloop runs. If the application
+ * is not the primary instance then a signal is sent to the primary
+ * instance and {@link Gio.Application.run} promptly returns. See the code
+ * examples below.
+ *
+ * If used, the expected form of an application identifier is the
+ * same as that of a
+ * D-Bus well-known bus name.
+ * Examples include: `com.example.MyApp`, `org.example.internal_apps.Calculator`,
+ * `org._7_zip.Archiver`.
+ * For details on valid application identifiers, see {@link Gio.Application.id_is_valid}.
+ *
+ * On Linux, the application identifier is claimed as a well-known bus name
+ * on the user's session bus. This means that the uniqueness of your
+ * application is scoped to the current session. It also means that your
+ * application may provide additional services (through registration of other
+ * object paths) at that bus name. The registration of these object paths
+ * should be done with the shared GDBus session bus. Note that 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 #GApplication
+ * attempts to acquire the bus name of your application (which happens in
+ * {@link Gio.Application.register}). Unfortunately, this means that you cannot
+ * use {@link Gio.Application.is-remote} to decide if you want to register
+ * object paths.
+ *
+ * `GApplication` also implements the {@link Gio.ActionGroup} and {@link Gio.ActionMap}
+ * interfaces and lets you easily export actions by adding them with
+ * {@link Gio.ActionMap.add_action}. When invoking an action by calling
+ * {@link Gio.ActionGroup.activate_action} on the application, it is always
+ * invoked in the primary instance. The actions are also exported on
+ * the session bus, and GIO provides the {@link Gio.DBusActionGroup} wrapper to
+ * conveniently access them remotely. GIO provides a {@link Gio.DBusMenuModel} wrapper
+ * for remote access to exported {@link Gio.MenuModel}s.
+ *
+ * Note: Due to the fact that actions are exported on the session bus,
+ * using `maybe` parameters is not supported, since D-Bus does not support
+ * `maybe` types.
+ *
+ * There is a number of different entry points into a `GApplication`:
+ *
+ * - via 'Activate' (i.e. just starting the application)
+ *
+ * - via 'Open' (i.e. opening some files)
+ *
+ * - by handling a command-line
+ *
+ * - via activating an action
+ *
+ * The {@link Gio.Application.:startup} signal lets you handle the application
+ * initialization for all of these in a single place.
+ *
+ * Regardless of which of these entry points is used to start the
+ * application, `GApplication` passes some ‘platform data’ from the
+ * launching instance to the primary instance, in the form of a
+ * {@link GLib.Variant} dictionary mapping strings to variants. To use platform
+ * data, override the {@link Gio.Application.before_emit} or
+ * {@link Gio.Application.after_emit} virtual functions
+ * in your `GApplication` subclass. When dealing with
+ * {@link Gio.ApplicationCommandLine} objects, the platform data is
+ * directly available via {@link Gio.ApplicationCommandLine.get_cwd},
+ * {@link Gio.ApplicationCommandLine.get_environ} and
+ * {@link Gio.ApplicationCommandLine.get_platform_data}.
+ *
+ * As the name indicates, the platform data may vary depending on the
+ * operating system, but it always includes the current directory (key
+ * `cwd`), and optionally the environment (ie the set of environment
+ * variables and their values) of the calling process (key `environ`).
+ * The environment is only added to the platform data if the
+ * `G_APPLICATION_SEND_ENVIRONMENT` flag is set. `GApplication` subclasses
+ * can add their own platform data by overriding the
+ * {@link Gio.Application.add_platform_data} virtual function. For instance,
+ * `GtkApplication` adds startup notification data in this way.
+ *
+ * To parse commandline arguments you may handle the
+ * {@link Gio.Application.:command-line} signal or override the
+ * {@link Gio.Application.local_command_line} virtual function, to parse them in
+ * either the primary instance or the local instance, respectively.
+ *
+ * For an example of opening files with a `GApplication`, see
+ * [gapplication-example-open.c](https://gitlab.gnome.org/GNOME/glib/-/blob/HEAD/gio/tests/gapplication-example-open.c).
+ *
+ * For an example of using actions with `GApplication`, see
+ * [gapplication-example-actions.c](https://gitlab.gnome.org/GNOME/glib/-/blob/HEAD/gio/tests/gapplication-example-actions.c).
+ *
+ * For an example of using extra D-Bus hooks with `GApplication`, see
+ * [gapplication-example-dbushooks.c](https://gitlab.gnome.org/GNOME/glib/-/blob/HEAD/gio/tests/gapplication-example-dbushooks.c).
+ */
 export declare class Application extends GObject.GObject {
     static readonly glibTypeName: string;
     static readonly objectType: "gobject";
@@ -20,10 +146,8 @@ export declare class Application extends GObject.GObject {
      *
      * 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);
+    constructor(flags: ApplicationFlags, applicationId?: string | null);
     /**
      * Returns the default #GApplication instance for this process.
      *
@@ -33,7 +157,7 @@ export declare class Application extends GObject.GObject {
      *
      * If there is no default application then %NULL is returned.
      */
-    static getDefault(): Application;
+    static getDefault(): Application | null;
     /**
      * Checks if `application_id` is a valid application identifier.
      *
@@ -46,14 +170,14 @@ export declare class Application extends GObject.GObject {
      * reproduced here:
      *
      * - Application identifiers are composed of 1 or more elements separated by a
-     * period (`.`) character. All elements must contain at least one character.
+     *   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.
+     *   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).
+     *   (and thus at least two elements).
      *
      * - Application identifiers must not begin with a `.` (period) character.
      *
@@ -80,7 +204,6 @@ export declare class Application extends GObject.GObject {
      * 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;
     /**
@@ -106,14 +229,8 @@ export declare class Application extends GObject.GObject {
      * 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): void;
+    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`.
      *
@@ -171,9 +288,8 @@ export declare class Application extends GObject.GObject {
      * - 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;
+    addMainOptionEntries(entries: GLib.OptionEntry[]): void;
     /**
      * Adds a #GOptionGroup to the commandline handling of `application`.
      *
@@ -200,7 +316,6 @@ export declare class Application extends GObject.GObject {
      * 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;
     /**
@@ -210,13 +325,9 @@ export declare class Application extends GObject.GObject {
      * 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`.
-     */
+    /** Gets the unique identifier for `application`. */
     getApplicationId(): string | null;
     /**
      * Gets the #GDBusConnection being used by the application, or %NULL.
@@ -295,9 +406,7 @@ export declare class Application extends GObject.GObject {
      * See g_application_set_resource_base_path() for more information.
      */
     getResourceBasePath(): string | null;
-    /**
-     * Gets the version of `application`.
-     */
+    /** Gets the version of `application`. */
     getVersion(): string | null;
     /**
      * Increases the use count of `application`.
@@ -339,9 +448,6 @@ export declare class Application extends GObject.GObject {
      *
      * 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;
     /**
@@ -391,9 +497,8 @@ export declare class Application extends GObject.GObject {
      * 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): boolean;
+    register(cancellable?: Cancellable | null): boolean;
     /**
      * Decrease the use count of `application`.
      *
@@ -479,10 +584,8 @@ export declare class Application extends GObject.GObject {
      * 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[]): number;
+    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,
@@ -513,16 +616,13 @@ export declare class Application extends GObject.GObject {
      *
      * 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): void;
+    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): void;
+    setActionGroup(actionGroup?: ActionGroup | null): void;
     /**
      * Sets the unique identifier for `application`.
      *
@@ -531,9 +631,8 @@ export declare class Application extends GObject.GObject {
      *
      * If non-%NULL, the application id must be valid.  See
      * g_application_id_is_valid().
-     * @param applicationId - the identifier for `application`
      */
-    setApplicationId(applicationId?: string): void;
+    setApplicationId(applicationId?: string | null): void;
     /**
      * Sets or unsets the default application for the process, as returned
      * by g_application_get_default().
@@ -550,7 +649,6 @@ export declare class Application extends GObject.GObject {
      * registered.
      *
      * See #GApplicationFlags.
-     * @param flags - the flags for `application`
      */
     setFlags(flags: ApplicationFlags): void;
     /**
@@ -562,16 +660,14 @@ export declare class Application extends GObject.GObject {
      * 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): void;
+    setOptionContextDescription(description?: string | null): void;
     /**
      * Sets the parameter string to be used by the commandline handling of `application`.
      *
@@ -579,16 +675,14 @@ export declare class Application extends GObject.GObject {
      * 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): void;
+    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): void;
+    setOptionContextSummary(summary?: string | null): void;
     /**
      * Sets (or unsets) the base resource path of `application`.
      *
@@ -623,24 +717,20 @@ export declare class Application extends GObject.GObject {
      * 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): void;
+    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;
     /**
@@ -667,37 +757,30 @@ export declare class Application extends GObject.GObject {
      * 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 {@link Gio.ActionGroup.:action-added} signal on `action_group`.
      *
      * This function should only be called by {@link Gio.ActionGroup} implementations.
-     * @param actionName - the name of an action in the group
      */
     actionAdded(actionName: string): void;
     /**
      * Emits the {@link Gio.ActionGroup.:action-enabled-changed} signal on `action_group`.
      *
      * This function should only be called by {@link 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 {@link Gio.ActionGroup.:action-removed} signal on `action_group`.
      *
      * This function should only be called by {@link Gio.ActionGroup} implementations.
-     * @param actionName - the name of an action in the group
      */
     actionRemoved(actionName: string): void;
     /**
      * Emits the {@link Gio.ActionGroup.:action-state-changed} signal on `action_group`.
      *
      * This function should only be called by {@link 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;
     /**
@@ -734,10 +817,8 @@ export declare class Application extends GObject.GObject {
      *
      * exit (0);
      * ```
-     * @param actionName - the name of the action to activate
-     * @param parameter - parameters to the activation
      */
-    activateAction(actionName: string, parameter?: GLib.Variant): void;
+    activateAction(actionName: string, parameter?: GLib.Variant | null): void;
     /**
      * Request for the state of the named action within `action_group` to be
      * changed to `value`.
@@ -750,8 +831,6 @@ export declare class Application extends GObject.GObject {
      * See {@link 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;
     /**
@@ -759,7 +838,6 @@ export declare class Application extends GObject.GObject {
      *
      * 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;
     /**
@@ -776,7 +854,6 @@ export declare class Application extends GObject.GObject {
      * 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;
     /**
@@ -788,7 +865,6 @@ export declare class Application extends GObject.GObject {
      *
      * The return value (if non-`NULL`) should be freed with
      * {@link GLib.Variant.unref} when it is no longer required.
-     * @param actionName - the name of the action to query
      */
     getActionState(actionName: string): GLib.Variant | null;
     /**
@@ -810,7 +886,6 @@ export declare class Application extends GObject.GObject {
      *
      * The return value (if non-`NULL`) should be freed with
      * {@link GLib.Variant.unref} when it is no longer required.
-     * @param actionName - the name of the action to query
      */
     getActionStateHint(actionName: string): GLib.Variant | null;
     /**
@@ -830,13 +905,9 @@ export declare class Application extends GObject.GObject {
      * 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
-     */
+    /** Checks if the named action exists within `action_group`. */
     hasAction(actionName: string): boolean;
     /**
      * Lists the actions contained within `action_group`.
@@ -873,14 +944,8 @@ export declare class Application extends GObject.GObject {
      * 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>, stateType?: Ref<GLib.VariantType>, stateHint?: Ref<GLib.Variant>, state?: Ref<GLib.Variant>): boolean;
+    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`.
      *
@@ -888,7 +953,6 @@ export declare class Application extends GObject.GObject {
      * as `action` then the old action is dropped from the action map.
      *
      * The action map takes its own reference on `action`.
-     * @param action - a {@link Gio.Action}
      */
     addAction(action: Action): void;
     /**
@@ -929,23 +993,18 @@ export declare class Application extends GObject.GObject {
      *   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): void;
+    addActionEntries(entries: ActionEntry[], 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;
     /**
@@ -970,10 +1029,8 @@ export declare class Application extends GObject.GObject {
      *   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;
+    removeActionEntries(entries: ActionEntry[], 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;
     connect(signal: "handle-local-options", handler: (self: Application, options: GLib.VariantDict) => number, after?: boolean): number;
@@ -985,6 +1042,5 @@ export declare class Application extends GObject.GObject {
     connect(signal: "action-enabled-changed", handler: (self: Application, actionName: string, enabled: boolean) => void, after?: boolean): number;
     connect(signal: "action-removed", handler: (self: Application, actionName: string) => void, after?: boolean): number;
     connect(signal: "action-state-changed", handler: (self: Application, actionName: string, value: GLib.Variant) => void, after?: boolean): number;
-    connect(signal: "notify", handler: (self: Application, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }