@girs/atspi-2.0 2.0.0-4.0.0-beta.21 → 2.0.0-4.0.0-beta.24

package/README.md

@@ -5,7 +5,7 @@
 ![downloads/week](https://img.shields.io/npm/dw/@girs/atspi-2.0)
 
 
-GJS TypeScript type definitions for Atspi-2.0, generated from library version 2.0.0 using [ts-for-gir](https://github.com/gjsify/ts-for-gir) v4.0.0-beta.21.
+GJS TypeScript type definitions for Atspi-2.0, generated from library version 2.0.0 using [ts-for-gir](https://github.com/gjsify/ts-for-gir) v4.0.0-beta.24.
 
 
 ## Install

package/atspi-2.0.d.ts

@@ -7,6 +7,8 @@
  * The based EJS template file is used for the generated .d.ts file of each GIR module like Gtk-4.0, GObject-2.0, ...
  */
 
+import '@girs/gjs';
+
 // Module dependencies
 import type GObject from '@girs/gobject-2.0';
 import type GLib from '@girs/glib-2.0';
@@ -1986,6 +1988,7 @@ export namespace Atspi {
     const DBUS_INTERFACE_HYPERLINK: string;
     const DBUS_INTERFACE_HYPERTEXT: string;
     const DBUS_INTERFACE_IMAGE: string;
+    const DBUS_INTERFACE_KEYBOARD_MONITOR: string;
     const DBUS_INTERFACE_REGISTRY: string;
     const DBUS_INTERFACE_SELECTION: string;
     const DBUS_INTERFACE_SOCKET: string;
@@ -1993,12 +1996,16 @@ export namespace Atspi {
     const DBUS_INTERFACE_TABLE_CELL: string;
     const DBUS_INTERFACE_TEXT: string;
     const DBUS_INTERFACE_VALUE: string;
+    const DBUS_NAME_A11Y_MANAGER: string;
     const DBUS_NAME_REGISTRY: string;
+    const DBUS_PATH_A11Y_MANAGER: string;
     const DBUS_PATH_DEC: string;
     const DBUS_PATH_NULL: string;
     const DBUS_PATH_REGISTRY: string;
     const DBUS_PATH_ROOT: string;
     const DBUS_PATH_SCREEN_READER: string;
+    const DEVICE_A11Y_MANAGER_VIRTUAL_MOD_END: number;
+    const DEVICE_A11Y_MANAGER_VIRTUAL_MOD_START: number;
     /**
      * One higher than the highest valid value of #AtspiEventType.
      */
@@ -2336,14 +2343,10 @@ export namespace Atspi {
         ALL_WINDOWS,
     }
     namespace Accessible {
-        // Signal callback interfaces
-
-        interface ModeChanged {
-            (arg1: number, why: string): void;
-        }
-
-        interface RegionChanged {
-            (arg1: number, arg2: number): void;
+        // Signal signatures
+        interface SignalSignatures extends Object.SignalSignatures {
+            'mode-changed': (arg0: number, arg1: string) => void;
+            'region-changed': (arg0: number, arg1: number) => void;
         }
 
         // Constructor properties interface
@@ -2389,6 +2392,15 @@ export namespace Atspi {
     {
         static $gtype: GObject.GType<Accessible>;
 
+        /**
+         * Compile-time signal type information.
+         *
+         * This instance property is generated only for TypeScript type checking.
+         * It is not defined at runtime and should not be accessed in JS code.
+         * @internal
+         */
+        $signals: Accessible.SignalSignatures;
+
         // Fields
 
         accessible_parent: Accessible;
@@ -2408,15 +2420,21 @@ export namespace Atspi {
 
         // Signals
 
-        connect(id: string, callback: (...args: any[]) => any): number;
-        connect_after(id: string, callback: (...args: any[]) => any): number;
-        emit(id: string, ...args: any[]): void;
-        connect(signal: 'mode-changed', callback: (_source: this, arg1: number, why: string) => void): number;
-        connect_after(signal: 'mode-changed', callback: (_source: this, arg1: number, why: string) => void): number;
-        emit(signal: 'mode-changed', arg1: number, why: string): void;
-        connect(signal: 'region-changed', callback: (_source: this, arg1: number, arg2: number) => void): number;
-        connect_after(signal: 'region-changed', callback: (_source: this, arg1: number, arg2: number) => void): number;
-        emit(signal: 'region-changed', arg1: number, arg2: number): void;
+        connect<K extends keyof Accessible.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, Accessible.SignalSignatures[K]>,
+        ): number;
+        connect(signal: string, callback: (...args: any[]) => any): number;
+        connect_after<K extends keyof Accessible.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, Accessible.SignalSignatures[K]>,
+        ): number;
+        connect_after(signal: string, callback: (...args: any[]) => any): number;
+        emit<K extends keyof Accessible.SignalSignatures>(
+            signal: K,
+            ...args: GObject.GjsParameters<Accessible.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
+        ): void;
+        emit(signal: string, ...args: any[]): void;
 
         // Virtual methods
 
@@ -3839,7 +3857,21 @@ export namespace Atspi {
          * @returns the data if found,          or %NULL if no such data exists.
          */
         get_data(key: string): any | null;
-        get_property(property_name: string): any;
+        /**
+         * Gets a property of an object.
+         *
+         * The value can be:
+         * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+         * - a GObject.Value initialized with the expected type of the property
+         * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+         *
+         * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+         *
+         * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+         * @param property_name The name of the property to get
+         * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+         */
+        get_property(property_name: string, value: GObject.Value | any): any;
         /**
          * This function gets back user data pointers stored via
          * g_object_set_qdata().
@@ -3967,7 +3999,12 @@ export namespace Atspi {
          * @param data data to associate with that key
          */
         set_data(key: string, data?: any | null): void;
-        set_property(property_name: string, value: any): void;
+        /**
+         * Sets a property on an object.
+         * @param property_name The name of the property to set
+         * @param value The value to set the property to
+         */
+        set_property(property_name: string, value: GObject.Value | any): void;
         /**
          * Remove a specified datum from the object's data associations,
          * without invoking the association's destroy handler.
@@ -4117,14 +4154,37 @@ export namespace Atspi {
          * @param pspec
          */
         vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+        /**
+         * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+         * @param id Handler ID of the handler to be disconnected
+         */
         disconnect(id: number): void;
+        /**
+         * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+         * @param properties Object containing the properties to set
+         */
         set(properties: { [key: string]: any }): void;
-        block_signal_handler(id: number): any;
-        unblock_signal_handler(id: number): any;
-        stop_emission_by_name(detailedName: string): any;
+        /**
+         * Blocks a handler of an instance so it will not be called during any signal emissions
+         * @param id Handler ID of the handler to be blocked
+         */
+        block_signal_handler(id: number): void;
+        /**
+         * Unblocks a handler so it will be called again during any signal emissions
+         * @param id Handler ID of the handler to be unblocked
+         */
+        unblock_signal_handler(id: number): void;
+        /**
+         * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+         * @param detailedName Name of the signal to stop emission of
+         */
+        stop_emission_by_name(detailedName: string): void;
     }
 
     namespace Application {
+        // Signal signatures
+        interface SignalSignatures extends GObject.Object.SignalSignatures {}
+
         // Constructor properties interface
 
         interface ConstructorProps extends GObject.Object.ConstructorProps {}
@@ -4140,6 +4200,15 @@ export namespace Atspi {
     class Application extends GObject.Object {
         static $gtype: GObject.GType<Application>;
 
+        /**
+         * Compile-time signal type information.
+         *
+         * This instance property is generated only for TypeScript type checking.
+         * It is not defined at runtime and should not be accessed in JS code.
+         * @internal
+         */
+        $signals: Application.SignalSignatures;
+
         // Fields
 
         bus_name: string;
@@ -4155,17 +4224,67 @@ export namespace Atspi {
         constructor(properties?: Partial<Application.ConstructorProps>, ...args: any[]);
 
         _init(...args: any[]): void;
+
+        // Signals
+
+        connect<K extends keyof Application.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, Application.SignalSignatures[K]>,
+        ): number;
+        connect(signal: string, callback: (...args: any[]) => any): number;
+        connect_after<K extends keyof Application.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, Application.SignalSignatures[K]>,
+        ): number;
+        connect_after(signal: string, callback: (...args: any[]) => any): number;
+        emit<K extends keyof Application.SignalSignatures>(
+            signal: K,
+            ...args: GObject.GjsParameters<Application.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
+        ): void;
+        emit(signal: string, ...args: any[]): void;
     }
 
     namespace Device {
+        // Signal signatures
+        interface SignalSignatures extends GObject.Object.SignalSignatures {
+            'notify::app-id': (pspec: GObject.ParamSpec) => void;
+        }
+
         // Constructor properties interface
 
-        interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        interface ConstructorProps extends GObject.Object.ConstructorProps {
+            app_id: string;
+            appId: string;
+        }
     }
 
     class Device extends GObject.Object {
         static $gtype: GObject.GType<Device>;
 
+        // Properties
+
+        /**
+         * The application ID of the application that created this device.
+         * The ID might be used for access control purposes
+         * by some device backends.
+         */
+        get app_id(): string;
+        /**
+         * The application ID of the application that created this device.
+         * The ID might be used for access control purposes
+         * by some device backends.
+         */
+        get appId(): string;
+
+        /**
+         * Compile-time signal type information.
+         *
+         * This instance property is generated only for TypeScript type checking.
+         * It is not defined at runtime and should not be accessed in JS code.
+         * @internal
+         */
+        $signals: Device.SignalSignatures;
+
         // Constructors
 
         constructor(properties?: Partial<Device.ConstructorProps>, ...args: any[]);
@@ -4174,6 +4293,26 @@ export namespace Atspi {
 
         static ['new'](): Device;
 
+        static new_full(app_id?: string | null): Device;
+
+        // Signals
+
+        connect<K extends keyof Device.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, Device.SignalSignatures[K]>,
+        ): number;
+        connect(signal: string, callback: (...args: any[]) => any): number;
+        connect_after<K extends keyof Device.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, Device.SignalSignatures[K]>,
+        ): number;
+        connect_after(signal: string, callback: (...args: any[]) => any): number;
+        emit<K extends keyof Device.SignalSignatures>(
+            signal: K,
+            ...args: GObject.GjsParameters<Device.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
+        ): void;
+        emit(signal: string, ...args: any[]): void;
+
         // Virtual methods
 
         vfunc_add_key_grab(kd: KeyDefinition): boolean;
@@ -4283,6 +4422,10 @@ export namespace Atspi {
          * @param name a string indicating which mouse event to be synthesized        (e.g. "b1p", "b1c", "b2r", "rel", "abs").
          */
         generate_mouse_event(obj: Accessible, x: number, y: number, name: string): void;
+        /**
+         * Returns the application ID of the device.
+         */
+        get_app_id(): string;
         get_grab_by_id(id: number): KeyDefinition;
         /**
          * Gets the modifier for a given keysym, if one exists. Does not create a new
@@ -4347,6 +4490,11 @@ export namespace Atspi {
          * @param id the identifier of the grab to be removed.
          */
         remove_key_grab(id: number): void;
+        /**
+         * Sets the application ID of the device.
+         * @param app_id the application ID.
+         */
+        set_app_id(app_id: string): void;
         /**
          * Removes a keyboard grab added via a call to atspi_device_add_keyboard.
          */
@@ -4363,7 +4511,64 @@ export namespace Atspi {
         unmap_modifier(keycode: number): void;
     }
 
+    namespace DeviceA11yManager {
+        // Signal signatures
+        interface SignalSignatures extends Device.SignalSignatures {
+            'notify::app-id': (pspec: GObject.ParamSpec) => void;
+        }
+
+        // Constructor properties interface
+
+        interface ConstructorProps extends Device.ConstructorProps {}
+    }
+
+    class DeviceA11yManager extends Device {
+        static $gtype: GObject.GType<DeviceA11yManager>;
+
+        /**
+         * Compile-time signal type information.
+         *
+         * This instance property is generated only for TypeScript type checking.
+         * It is not defined at runtime and should not be accessed in JS code.
+         * @internal
+         */
+        $signals: DeviceA11yManager.SignalSignatures;
+
+        // Constructors
+
+        constructor(properties?: Partial<DeviceA11yManager.ConstructorProps>, ...args: any[]);
+
+        _init(...args: any[]): void;
+
+        static try_new(): DeviceA11yManager;
+
+        static try_new_full(app_id?: string | null): DeviceA11yManager;
+
+        // Signals
+
+        connect<K extends keyof DeviceA11yManager.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, DeviceA11yManager.SignalSignatures[K]>,
+        ): number;
+        connect(signal: string, callback: (...args: any[]) => any): number;
+        connect_after<K extends keyof DeviceA11yManager.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, DeviceA11yManager.SignalSignatures[K]>,
+        ): number;
+        connect_after(signal: string, callback: (...args: any[]) => any): number;
+        emit<K extends keyof DeviceA11yManager.SignalSignatures>(
+            signal: K,
+            ...args: GObject.GjsParameters<DeviceA11yManager.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
+        ): void;
+        emit(signal: string, ...args: any[]): void;
+    }
+
     namespace DeviceLegacy {
+        // Signal signatures
+        interface SignalSignatures extends Device.SignalSignatures {
+            'notify::app-id': (pspec: GObject.ParamSpec) => void;
+        }
+
         // Constructor properties interface
 
         interface ConstructorProps extends Device.ConstructorProps {}
@@ -4372,6 +4577,15 @@ export namespace Atspi {
     class DeviceLegacy extends Device {
         static $gtype: GObject.GType<DeviceLegacy>;
 
+        /**
+         * Compile-time signal type information.
+         *
+         * This instance property is generated only for TypeScript type checking.
+         * It is not defined at runtime and should not be accessed in JS code.
+         * @internal
+         */
+        $signals: DeviceLegacy.SignalSignatures;
+
         // Constructors
 
         constructor(properties?: Partial<DeviceLegacy.ConstructorProps>, ...args: any[]);
@@ -4379,9 +4593,32 @@ export namespace Atspi {
         _init(...args: any[]): void;
 
         static ['new'](): DeviceLegacy;
+
+        static new_full(app_id?: string | null): DeviceLegacy;
+
+        // Signals
+
+        connect<K extends keyof DeviceLegacy.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, DeviceLegacy.SignalSignatures[K]>,
+        ): number;
+        connect(signal: string, callback: (...args: any[]) => any): number;
+        connect_after<K extends keyof DeviceLegacy.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, DeviceLegacy.SignalSignatures[K]>,
+        ): number;
+        connect_after(signal: string, callback: (...args: any[]) => any): number;
+        emit<K extends keyof DeviceLegacy.SignalSignatures>(
+            signal: K,
+            ...args: GObject.GjsParameters<DeviceLegacy.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
+        ): void;
+        emit(signal: string, ...args: any[]): void;
     }
 
     namespace DeviceListener {
+        // Signal signatures
+        interface SignalSignatures extends GObject.Object.SignalSignatures {}
+
         // Constructor properties interface
 
         interface ConstructorProps extends GObject.Object.ConstructorProps {}
@@ -4390,6 +4627,15 @@ export namespace Atspi {
     class DeviceListener extends GObject.Object {
         static $gtype: GObject.GType<DeviceListener>;
 
+        /**
+         * Compile-time signal type information.
+         *
+         * This instance property is generated only for TypeScript type checking.
+         * It is not defined at runtime and should not be accessed in JS code.
+         * @internal
+         */
+        $signals: DeviceListener.SignalSignatures;
+
         // Fields
 
         id: number;
@@ -4403,6 +4649,24 @@ export namespace Atspi {
 
         static ['new'](callback?: DeviceListenerCB | null): DeviceListener;
 
+        // Signals
+
+        connect<K extends keyof DeviceListener.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, DeviceListener.SignalSignatures[K]>,
+        ): number;
+        connect(signal: string, callback: (...args: any[]) => any): number;
+        connect_after<K extends keyof DeviceListener.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, DeviceListener.SignalSignatures[K]>,
+        ): number;
+        connect_after(signal: string, callback: (...args: any[]) => any): number;
+        emit<K extends keyof DeviceListener.SignalSignatures>(
+            signal: K,
+            ...args: GObject.GjsParameters<DeviceListener.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
+        ): void;
+        emit(signal: string, ...args: any[]): void;
+
         // Virtual methods
 
         vfunc_device_event(event: DeviceEvent): boolean;
@@ -4423,6 +4687,11 @@ export namespace Atspi {
     }
 
     namespace DeviceX11 {
+        // Signal signatures
+        interface SignalSignatures extends Device.SignalSignatures {
+            'notify::app-id': (pspec: GObject.ParamSpec) => void;
+        }
+
         // Constructor properties interface
 
         interface ConstructorProps extends Device.ConstructorProps {}
@@ -4431,6 +4700,15 @@ export namespace Atspi {
     class DeviceX11 extends Device {
         static $gtype: GObject.GType<DeviceX11>;
 
+        /**
+         * Compile-time signal type information.
+         *
+         * This instance property is generated only for TypeScript type checking.
+         * It is not defined at runtime and should not be accessed in JS code.
+         * @internal
+         */
+        $signals: DeviceX11.SignalSignatures;
+
         // Constructors
 
         constructor(properties?: Partial<DeviceX11.ConstructorProps>, ...args: any[]);
@@ -4438,9 +4716,32 @@ export namespace Atspi {
         _init(...args: any[]): void;
 
         static ['new'](): DeviceX11;
+
+        static new_full(app_id?: string | null): DeviceX11;
+
+        // Signals
+
+        connect<K extends keyof DeviceX11.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, DeviceX11.SignalSignatures[K]>,
+        ): number;
+        connect(signal: string, callback: (...args: any[]) => any): number;
+        connect_after<K extends keyof DeviceX11.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, DeviceX11.SignalSignatures[K]>,
+        ): number;
+        connect_after(signal: string, callback: (...args: any[]) => any): number;
+        emit<K extends keyof DeviceX11.SignalSignatures>(
+            signal: K,
+            ...args: GObject.GjsParameters<DeviceX11.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
+        ): void;
+        emit(signal: string, ...args: any[]): void;
     }
 
     namespace EventListener {
+        // Signal signatures
+        interface SignalSignatures extends GObject.Object.SignalSignatures {}
+
         // Constructor properties interface
 
         interface ConstructorProps extends GObject.Object.ConstructorProps {}
@@ -4458,6 +4759,15 @@ export namespace Atspi {
     class EventListener extends GObject.Object {
         static $gtype: GObject.GType<EventListener>;
 
+        /**
+         * Compile-time signal type information.
+         *
+         * This instance property is generated only for TypeScript type checking.
+         * It is not defined at runtime and should not be accessed in JS code.
+         * @internal
+         */
+        $signals: EventListener.SignalSignatures;
+
         // Fields
 
         callback: EventListenerCB;
@@ -4472,6 +4782,24 @@ export namespace Atspi {
 
         static ['new'](callback: EventListenerCB): EventListener;
 
+        // Signals
+
+        connect<K extends keyof EventListener.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, EventListener.SignalSignatures[K]>,
+        ): number;
+        connect(signal: string, callback: (...args: any[]) => any): number;
+        connect_after<K extends keyof EventListener.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, EventListener.SignalSignatures[K]>,
+        ): number;
+        connect_after(signal: string, callback: (...args: any[]) => any): number;
+        emit<K extends keyof EventListener.SignalSignatures>(
+            signal: K,
+            ...args: GObject.GjsParameters<EventListener.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
+        ): void;
+        emit(signal: string, ...args: any[]): void;
+
         // Static methods
 
         /**
@@ -4615,6 +4943,9 @@ export namespace Atspi {
     }
 
     namespace Hyperlink {
+        // Signal signatures
+        interface SignalSignatures extends Object.SignalSignatures {}
+
         // Constructor properties interface
 
         interface ConstructorProps extends Object.ConstructorProps {}
@@ -4635,12 +4966,39 @@ export namespace Atspi {
     class Hyperlink extends Object {
         static $gtype: GObject.GType<Hyperlink>;
 
+        /**
+         * Compile-time signal type information.
+         *
+         * This instance property is generated only for TypeScript type checking.
+         * It is not defined at runtime and should not be accessed in JS code.
+         * @internal
+         */
+        $signals: Hyperlink.SignalSignatures;
+
         // Constructors
 
         constructor(properties?: Partial<Hyperlink.ConstructorProps>, ...args: any[]);
 
         _init(...args: any[]): void;
 
+        // Signals
+
+        connect<K extends keyof Hyperlink.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, Hyperlink.SignalSignatures[K]>,
+        ): number;
+        connect(signal: string, callback: (...args: any[]) => any): number;
+        connect_after<K extends keyof Hyperlink.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, Hyperlink.SignalSignatures[K]>,
+        ): number;
+        connect_after(signal: string, callback: (...args: any[]) => any): number;
+        emit<K extends keyof Hyperlink.SignalSignatures>(
+            signal: K,
+            ...args: GObject.GjsParameters<Hyperlink.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
+        ): void;
+        emit(signal: string, ...args: any[]): void;
+
         // Methods
 
         /**
@@ -4690,6 +5048,9 @@ export namespace Atspi {
     }
 
     namespace MatchRule {
+        // Signal signatures
+        interface SignalSignatures extends GObject.Object.SignalSignatures {}
+
         // Constructor properties interface
 
         interface ConstructorProps extends GObject.Object.ConstructorProps {}
@@ -4702,6 +5063,15 @@ export namespace Atspi {
     class MatchRule extends GObject.Object {
         static $gtype: GObject.GType<MatchRule>;
 
+        /**
+         * Compile-time signal type information.
+         *
+         * This instance property is generated only for TypeScript type checking.
+         * It is not defined at runtime and should not be accessed in JS code.
+         * @internal
+         */
+        $signals: MatchRule.SignalSignatures;
+
         // Fields
 
         states: StateSet;
@@ -4730,9 +5100,30 @@ export namespace Atspi {
             interfacematchtype: CollectionMatchType,
             invert: boolean,
         ): MatchRule;
+
+        // Signals
+
+        connect<K extends keyof MatchRule.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, MatchRule.SignalSignatures[K]>,
+        ): number;
+        connect(signal: string, callback: (...args: any[]) => any): number;
+        connect_after<K extends keyof MatchRule.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, MatchRule.SignalSignatures[K]>,
+        ): number;
+        connect_after(signal: string, callback: (...args: any[]) => any): number;
+        emit<K extends keyof MatchRule.SignalSignatures>(
+            signal: K,
+            ...args: GObject.GjsParameters<MatchRule.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
+        ): void;
+        emit(signal: string, ...args: any[]): void;
     }
 
     namespace Object {
+        // Signal signatures
+        interface SignalSignatures extends GObject.Object.SignalSignatures {}
+
         // Constructor properties interface
 
         interface ConstructorProps extends GObject.Object.ConstructorProps {}
@@ -4741,6 +5132,15 @@ export namespace Atspi {
     class Object extends GObject.Object {
         static $gtype: GObject.GType<Object>;
 
+        /**
+         * Compile-time signal type information.
+         *
+         * This instance property is generated only for TypeScript type checking.
+         * It is not defined at runtime and should not be accessed in JS code.
+         * @internal
+         */
+        $signals: Object.SignalSignatures;
+
         // Fields
 
         app: Application;
@@ -4751,9 +5151,30 @@ export namespace Atspi {
         constructor(properties?: Partial<Object.ConstructorProps>, ...args: any[]);
 
         _init(...args: any[]): void;
+
+        // Signals
+
+        connect<K extends keyof Object.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, Object.SignalSignatures[K]>,
+        ): number;
+        connect(signal: string, callback: (...args: any[]) => any): number;
+        connect_after<K extends keyof Object.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, Object.SignalSignatures[K]>,
+        ): number;
+        connect_after(signal: string, callback: (...args: any[]) => any): number;
+        emit<K extends keyof Object.SignalSignatures>(
+            signal: K,
+            ...args: GObject.GjsParameters<Object.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
+        ): void;
+        emit(signal: string, ...args: any[]): void;
     }
 
     namespace Relation {
+        // Signal signatures
+        interface SignalSignatures extends GObject.Object.SignalSignatures {}
+
         // Constructor properties interface
 
         interface ConstructorProps extends GObject.Object.ConstructorProps {}
@@ -4770,6 +5191,15 @@ export namespace Atspi {
     class Relation extends GObject.Object {
         static $gtype: GObject.GType<Relation>;
 
+        /**
+         * Compile-time signal type information.
+         *
+         * This instance property is generated only for TypeScript type checking.
+         * It is not defined at runtime and should not be accessed in JS code.
+         * @internal
+         */
+        $signals: Relation.SignalSignatures;
+
         // Fields
 
         relation_type: RelationType;
@@ -4781,6 +5211,24 @@ export namespace Atspi {
 
         _init(...args: any[]): void;
 
+        // Signals
+
+        connect<K extends keyof Relation.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, Relation.SignalSignatures[K]>,
+        ): number;
+        connect(signal: string, callback: (...args: any[]) => any): number;
+        connect_after<K extends keyof Relation.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, Relation.SignalSignatures[K]>,
+        ): number;
+        connect_after(signal: string, callback: (...args: any[]) => any): number;
+        emit<K extends keyof Relation.SignalSignatures>(
+            signal: K,
+            ...args: GObject.GjsParameters<Relation.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
+        ): void;
+        emit(signal: string, ...args: any[]): void;
+
         // Methods
 
         /**
@@ -4804,6 +5252,9 @@ export namespace Atspi {
     }
 
     namespace StateSet {
+        // Signal signatures
+        interface SignalSignatures extends GObject.Object.SignalSignatures {}
+
         // Constructor properties interface
 
         interface ConstructorProps extends GObject.Object.ConstructorProps {}
@@ -4816,6 +5267,15 @@ export namespace Atspi {
     class StateSet extends GObject.Object {
         static $gtype: GObject.GType<StateSet>;
 
+        /**
+         * Compile-time signal type information.
+         *
+         * This instance property is generated only for TypeScript type checking.
+         * It is not defined at runtime and should not be accessed in JS code.
+         * @internal
+         */
+        $signals: StateSet.SignalSignatures;
+
         // Fields
 
         accessible: any;
@@ -4829,6 +5289,24 @@ export namespace Atspi {
 
         static ['new'](states: StateType[]): StateSet;
 
+        // Signals
+
+        connect<K extends keyof StateSet.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, StateSet.SignalSignatures[K]>,
+        ): number;
+        connect(signal: string, callback: (...args: any[]) => any): number;
+        connect_after<K extends keyof StateSet.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, StateSet.SignalSignatures[K]>,
+        ): number;
+        connect_after(signal: string, callback: (...args: any[]) => any): number;
+        emit<K extends keyof StateSet.SignalSignatures>(
+            signal: K,
+            ...args: GObject.GjsParameters<StateSet.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
+        ): void;
+        emit(signal: string, ...args: any[]): void;
+
         // Methods
 
         /**
@@ -4892,6 +5370,7 @@ export namespace Atspi {
     }
 
     type ApplicationClass = typeof Application;
+    type DeviceA11yManagerClass = typeof DeviceA11yManager;
     type DeviceClass = typeof Device;
     class DeviceEvent {
         static $gtype: GObject.GType<DeviceEvent>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@girs/atspi-2.0",
-  "version": "2.0.0-4.0.0-beta.21",
+  "version": "2.0.0-4.0.0-beta.24",
   "description": "GJS TypeScript type definitions for Atspi-2.0, generated from library version 2.0.0",
   "type": "module",
   "module": "atspi-2.0.js",
@@ -31,10 +31,10 @@
     "test": "tsc --project tsconfig.json"
   },
   "dependencies": {
-    "@girs/dbus-1.0": "^1.0.0-4.0.0-beta.21",
-    "@girs/gjs": "^4.0.0-beta.21",
-    "@girs/glib-2.0": "^2.83.3-4.0.0-beta.21",
-    "@girs/gobject-2.0": "^2.83.3-4.0.0-beta.21"
+    "@girs/dbus-1.0": "^1.0.0-4.0.0-beta.24",
+    "@girs/gjs": "^4.0.0-beta.24",
+    "@girs/glib-2.0": "^2.84.2-4.0.0-beta.24",
+    "@girs/gobject-2.0": "^2.84.2-4.0.0-beta.24"
   },
   "devDependencies": {
     "typescript": "*"