@girs/gegl-0.3 0.3.35-4.0.0-beta.21 → 0.3.35-4.0.0-beta.24

package/README.md

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

package/gegl-0.3.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';
@@ -592,6 +594,11 @@ export namespace Gegl {
         INDENT,
     }
     namespace AudioFragment {
+        // Signal signatures
+        interface SignalSignatures extends GObject.Object.SignalSignatures {
+            'notify::string': (pspec: GObject.ParamSpec) => void;
+        }
+
         // Constructor properties interface
 
         interface ConstructorProps extends GObject.Object.ConstructorProps {
@@ -607,6 +614,15 @@ export namespace Gegl {
         get string(): string;
         set string(val: 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: AudioFragment.SignalSignatures;
+
         // Fields
 
         data: number[];
@@ -624,6 +640,24 @@ export namespace Gegl {
             max_samples: number,
         ): AudioFragment;
 
+        // Signals
+
+        connect<K extends keyof AudioFragment.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, AudioFragment.SignalSignatures[K]>,
+        ): number;
+        connect(signal: string, callback: (...args: any[]) => any): number;
+        connect_after<K extends keyof AudioFragment.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, AudioFragment.SignalSignatures[K]>,
+        ): number;
+        connect_after(signal: string, callback: (...args: any[]) => any): number;
+        emit<K extends keyof AudioFragment.SignalSignatures>(
+            signal: K,
+            ...args: GObject.GjsParameters<AudioFragment.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
+        ): void;
+        emit(signal: string, ...args: any[]): void;
+
         // Methods
 
         get_channel_layout(): number;
@@ -641,10 +675,27 @@ export namespace Gegl {
     }
 
     namespace Buffer {
-        // Signal callback interfaces
-
-        interface Changed {
-            (object: Rectangle): void;
+        // Signal signatures
+        interface SignalSignatures extends TileHandler.SignalSignatures {
+            changed: (arg0: Rectangle) => void;
+            'notify::abyss-height': (pspec: GObject.ParamSpec) => void;
+            'notify::abyss-width': (pspec: GObject.ParamSpec) => void;
+            'notify::abyss-x': (pspec: GObject.ParamSpec) => void;
+            'notify::abyss-y': (pspec: GObject.ParamSpec) => void;
+            'notify::backend': (pspec: GObject.ParamSpec) => void;
+            'notify::format': (pspec: GObject.ParamSpec) => void;
+            'notify::height': (pspec: GObject.ParamSpec) => void;
+            'notify::path': (pspec: GObject.ParamSpec) => void;
+            'notify::pixels': (pspec: GObject.ParamSpec) => void;
+            'notify::px-size': (pspec: GObject.ParamSpec) => void;
+            'notify::shift-x': (pspec: GObject.ParamSpec) => void;
+            'notify::shift-y': (pspec: GObject.ParamSpec) => void;
+            'notify::tile-height': (pspec: GObject.ParamSpec) => void;
+            'notify::tile-width': (pspec: GObject.ParamSpec) => void;
+            'notify::width': (pspec: GObject.ParamSpec) => void;
+            'notify::x': (pspec: GObject.ParamSpec) => void;
+            'notify::y': (pspec: GObject.ParamSpec) => void;
+            'notify::source': (pspec: GObject.ParamSpec) => void;
         }
 
         // Constructor properties interface
@@ -716,6 +767,15 @@ export namespace Gegl {
         get y(): number;
         set y(val: number);
 
+        /**
+         * 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: Buffer.SignalSignatures;
+
         // Constructors
 
         constructor(properties?: Partial<Buffer.ConstructorProps>, ...args: any[]);
@@ -728,12 +788,21 @@ export namespace Gegl {
 
         // 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: 'changed', callback: (_source: this, object: Rectangle) => void): number;
-        connect_after(signal: 'changed', callback: (_source: this, object: Rectangle) => void): number;
-        emit(signal: 'changed', object: Rectangle): void;
+        connect<K extends keyof Buffer.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, Buffer.SignalSignatures[K]>,
+        ): number;
+        connect(signal: string, callback: (...args: any[]) => any): number;
+        connect_after<K extends keyof Buffer.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, Buffer.SignalSignatures[K]>,
+        ): number;
+        connect_after(signal: string, callback: (...args: any[]) => any): number;
+        emit<K extends keyof Buffer.SignalSignatures>(
+            signal: K,
+            ...args: GObject.GjsParameters<Buffer.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
+        ): void;
+        emit(signal: string, ...args: any[]): void;
 
         // Static methods
 
@@ -897,6 +966,11 @@ export namespace Gegl {
     }
 
     namespace Color {
+        // Signal signatures
+        interface SignalSignatures extends GObject.Object.SignalSignatures {
+            'notify::string': (pspec: GObject.ParamSpec) => void;
+        }
+
         // Constructor properties interface
 
         interface ConstructorProps extends GObject.Object.ConstructorProps {
@@ -912,6 +986,15 @@ export namespace Gegl {
         get string(): string;
         set string(val: 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: Color.SignalSignatures;
+
         // Constructors
 
         constructor(properties?: Partial<Color.ConstructorProps>, ...args: any[]);
@@ -920,6 +1003,24 @@ export namespace Gegl {
 
         static ['new'](string: string): Color;
 
+        // Signals
+
+        connect<K extends keyof Color.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, Color.SignalSignatures[K]>,
+        ): number;
+        connect(signal: string, callback: (...args: any[]) => any): number;
+        connect_after<K extends keyof Color.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, Color.SignalSignatures[K]>,
+        ): number;
+        connect_after(signal: string, callback: (...args: any[]) => any): number;
+        emit<K extends keyof Color.SignalSignatures>(
+            signal: K,
+            ...args: GObject.GjsParameters<Color.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
+        ): void;
+        emit(signal: string, ...args: any[]): void;
+
         // Methods
 
         /**
@@ -955,6 +1056,20 @@ export namespace Gegl {
     }
 
     namespace Config {
+        // Signal signatures
+        interface SignalSignatures extends GObject.Object.SignalSignatures {
+            'notify::application-license': (pspec: GObject.ParamSpec) => void;
+            'notify::chunk-size': (pspec: GObject.ParamSpec) => void;
+            'notify::quality': (pspec: GObject.ParamSpec) => void;
+            'notify::queue-size': (pspec: GObject.ParamSpec) => void;
+            'notify::swap': (pspec: GObject.ParamSpec) => void;
+            'notify::threads': (pspec: GObject.ParamSpec) => void;
+            'notify::tile-cache-size': (pspec: GObject.ParamSpec) => void;
+            'notify::tile-height': (pspec: GObject.ParamSpec) => void;
+            'notify::tile-width': (pspec: GObject.ParamSpec) => void;
+            'notify::use-opencl': (pspec: GObject.ParamSpec) => void;
+        }
+
         // Constructor properties interface
 
         interface ConstructorProps extends GObject.Object.ConstructorProps {
@@ -1018,14 +1133,44 @@ export namespace Gegl {
         get useOpencl(): boolean;
         set useOpencl(val: boolean);
 
+        /**
+         * 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: Config.SignalSignatures;
+
         // Constructors
 
         constructor(properties?: Partial<Config.ConstructorProps>, ...args: any[]);
 
         _init(...args: any[]): void;
+
+        // Signals
+
+        connect<K extends keyof Config.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, Config.SignalSignatures[K]>,
+        ): number;
+        connect(signal: string, callback: (...args: any[]) => any): number;
+        connect_after<K extends keyof Config.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, Config.SignalSignatures[K]>,
+        ): number;
+        connect_after(signal: string, callback: (...args: any[]) => any): number;
+        emit<K extends keyof Config.SignalSignatures>(
+            signal: K,
+            ...args: GObject.GjsParameters<Config.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
+        ): void;
+        emit(signal: string, ...args: any[]): void;
     }
 
     namespace Curve {
+        // Signal signatures
+        interface SignalSignatures extends GObject.Object.SignalSignatures {}
+
         // Constructor properties interface
 
         interface ConstructorProps extends GObject.Object.ConstructorProps {}
@@ -1034,6 +1179,15 @@ export namespace Gegl {
     class Curve extends GObject.Object {
         static $gtype: GObject.GType<Curve>;
 
+        /**
+         * 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: Curve.SignalSignatures;
+
         // Constructors
 
         constructor(properties?: Partial<Curve.ConstructorProps>, ...args: any[]);
@@ -1044,6 +1198,24 @@ export namespace Gegl {
 
         static new_default(): Curve;
 
+        // Signals
+
+        connect<K extends keyof Curve.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, Curve.SignalSignatures[K]>,
+        ): number;
+        connect(signal: string, callback: (...args: any[]) => any): number;
+        connect_after<K extends keyof Curve.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, Curve.SignalSignatures[K]>,
+        ): number;
+        connect_after(signal: string, callback: (...args: any[]) => any): number;
+        emit<K extends keyof Curve.SignalSignatures>(
+            signal: K,
+            ...args: GObject.GjsParameters<Curve.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
+        ): void;
+        emit(signal: string, ...args: any[]): void;
+
         // Methods
 
         /**
@@ -1091,18 +1263,17 @@ export namespace Gegl {
     }
 
     namespace Node {
-        // Signal callback interfaces
-
-        interface Computed {
-            (object: Rectangle): void;
-        }
-
-        interface Invalidated {
-            (object: Rectangle): void;
-        }
-
-        interface Progress {
-            (object: number): void;
+        // Signal signatures
+        interface SignalSignatures extends GObject.Object.SignalSignatures {
+            computed: (arg0: Rectangle) => void;
+            invalidated: (arg0: Rectangle) => void;
+            progress: (arg0: number) => void;
+            'notify::dont-cache': (pspec: GObject.ParamSpec) => void;
+            'notify::gegl-operation': (pspec: GObject.ParamSpec) => void;
+            'notify::name': (pspec: GObject.ParamSpec) => void;
+            'notify::operation': (pspec: GObject.ParamSpec) => void;
+            'notify::passthrough': (pspec: GObject.ParamSpec) => void;
+            'notify::use-opencl': (pspec: GObject.ParamSpec) => void;
         }
 
         // Constructor properties interface
@@ -1144,6 +1315,15 @@ export namespace Gegl {
         get useOpencl(): boolean;
         set useOpencl(val: boolean);
 
+        /**
+         * 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: Node.SignalSignatures;
+
         // Constructors
 
         constructor(properties?: Partial<Node.ConstructorProps>, ...args: any[]);
@@ -1160,18 +1340,21 @@ export namespace Gegl {
 
         // 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: 'computed', callback: (_source: this, object: Rectangle) => void): number;
-        connect_after(signal: 'computed', callback: (_source: this, object: Rectangle) => void): number;
-        emit(signal: 'computed', object: Rectangle): void;
-        connect(signal: 'invalidated', callback: (_source: this, object: Rectangle) => void): number;
-        connect_after(signal: 'invalidated', callback: (_source: this, object: Rectangle) => void): number;
-        emit(signal: 'invalidated', object: Rectangle): void;
-        connect(signal: 'progress', callback: (_source: this, object: number) => void): number;
-        connect_after(signal: 'progress', callback: (_source: this, object: number) => void): number;
-        emit(signal: 'progress', object: number): void;
+        connect<K extends keyof Node.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, Node.SignalSignatures[K]>,
+        ): number;
+        connect(signal: string, callback: (...args: any[]) => any): number;
+        connect_after<K extends keyof Node.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, Node.SignalSignatures[K]>,
+        ): number;
+        connect_after(signal: string, callback: (...args: any[]) => any): number;
+        emit<K extends keyof Node.SignalSignatures>(
+            signal: K,
+            ...args: GObject.GjsParameters<Node.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
+        ): void;
+        emit(signal: string, ...args: any[]): void;
 
         // Methods
 
@@ -1361,8 +1544,6 @@ export namespace Gegl {
          * @param value a GValue containing the value to be set in the property.
          */
         set_property(property_name: string, value: GObject.Value | any): void;
-        // Conflicted with GObject.Object.set_property
-        set_property(...args: never[]): any;
         /**
          * Returns a freshly allocated \0 terminated string containing a XML
          * serialization of the composition produced by a node (and thus also
@@ -1385,6 +1566,9 @@ export namespace Gegl {
     }
 
     namespace Operation {
+        // Signal signatures
+        interface SignalSignatures extends GObject.Object.SignalSignatures {}
+
         // Constructor properties interface
 
         interface ConstructorProps extends GObject.Object.ConstructorProps {}
@@ -1393,12 +1577,39 @@ export namespace Gegl {
     class Operation extends GObject.Object {
         static $gtype: GObject.GType<Operation>;
 
+        /**
+         * 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: Operation.SignalSignatures;
+
         // Constructors
 
         constructor(properties?: Partial<Operation.ConstructorProps>, ...args: any[]);
 
         _init(...args: any[]): void;
 
+        // Signals
+
+        connect<K extends keyof Operation.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, Operation.SignalSignatures[K]>,
+        ): number;
+        connect(signal: string, callback: (...args: any[]) => any): number;
+        connect_after<K extends keyof Operation.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, Operation.SignalSignatures[K]>,
+        ): number;
+        connect_after(signal: string, callback: (...args: any[]) => any): number;
+        emit<K extends keyof Operation.SignalSignatures>(
+            signal: K,
+            ...args: GObject.GjsParameters<Operation.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
+        ): void;
+        emit(signal: string, ...args: any[]): void;
+
         // Static methods
 
         static find_property(operation_type: string, property_name: string): GObject.ParamSpec;
@@ -1415,10 +1626,9 @@ export namespace Gegl {
     }
 
     namespace Path {
-        // Signal callback interfaces
-
-        interface Changed {
-            (object?: any | null): void;
+        // Signal signatures
+        interface SignalSignatures extends GObject.Object.SignalSignatures {
+            changed: (arg0: any | null) => void;
         }
 
         // Constructor properties interface
@@ -1429,6 +1639,15 @@ export namespace Gegl {
     class Path extends GObject.Object {
         static $gtype: GObject.GType<Path>;
 
+        /**
+         * 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: Path.SignalSignatures;
+
         // Constructors
 
         constructor(properties?: Partial<Path.ConstructorProps>, ...args: any[]);
@@ -1441,12 +1660,21 @@ export namespace Gegl {
 
         // 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: 'changed', callback: (_source: this, object: any | null) => void): number;
-        connect_after(signal: 'changed', callback: (_source: this, object: any | null) => void): number;
-        emit(signal: 'changed', object?: any | null): void;
+        connect<K extends keyof Path.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, Path.SignalSignatures[K]>,
+        ): number;
+        connect(signal: string, callback: (...args: any[]) => any): number;
+        connect_after<K extends keyof Path.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, Path.SignalSignatures[K]>,
+        ): number;
+        connect_after(signal: string, callback: (...args: any[]) => any): number;
+        emit<K extends keyof Path.SignalSignatures>(
+            signal: K,
+            ...args: GObject.GjsParameters<Path.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
+        ): void;
+        emit(signal: string, ...args: any[]): void;
 
         // Static methods
 
@@ -1579,6 +1807,14 @@ export namespace Gegl {
     }
 
     namespace Processor {
+        // Signal signatures
+        interface SignalSignatures extends GObject.Object.SignalSignatures {
+            'notify::chunksize': (pspec: GObject.ParamSpec) => void;
+            'notify::node': (pspec: GObject.ParamSpec) => void;
+            'notify::progress': (pspec: GObject.ParamSpec) => void;
+            'notify::rectangle': (pspec: GObject.ParamSpec) => void;
+        }
+
         // Constructor properties interface
 
         interface ConstructorProps extends GObject.Object.ConstructorProps {
@@ -1601,12 +1837,39 @@ export namespace Gegl {
         get rectangle(): any;
         set rectangle(val: any);
 
+        /**
+         * 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: Processor.SignalSignatures;
+
         // Constructors
 
         constructor(properties?: Partial<Processor.ConstructorProps>, ...args: any[]);
 
         _init(...args: any[]): void;
 
+        // Signals
+
+        connect<K extends keyof Processor.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, Processor.SignalSignatures[K]>,
+        ): number;
+        connect(signal: string, callback: (...args: any[]) => any): number;
+        connect_after<K extends keyof Processor.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, Processor.SignalSignatures[K]>,
+        ): number;
+        connect_after(signal: string, callback: (...args: any[]) => any): number;
+        emit<K extends keyof Processor.SignalSignatures>(
+            signal: K,
+            ...args: GObject.GjsParameters<Processor.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
+        ): void;
+        emit(signal: string, ...args: any[]): void;
+
         // Methods
 
         set_level(level: number): void;
@@ -1633,6 +1896,19 @@ export namespace Gegl {
     }
 
     namespace Stats {
+        // Signal signatures
+        interface SignalSignatures extends GObject.Object.SignalSignatures {
+            'notify::swap-busy': (pspec: GObject.ParamSpec) => void;
+            'notify::swap-file-size': (pspec: GObject.ParamSpec) => void;
+            'notify::swap-total': (pspec: GObject.ParamSpec) => void;
+            'notify::tile-cache-hits': (pspec: GObject.ParamSpec) => void;
+            'notify::tile-cache-misses': (pspec: GObject.ParamSpec) => void;
+            'notify::tile-cache-total': (pspec: GObject.ParamSpec) => void;
+            'notify::tile-cache-total-max': (pspec: GObject.ParamSpec) => void;
+            'notify::tile-cache-total-uncloned': (pspec: GObject.ParamSpec) => void;
+            'notify::zoom-total': (pspec: GObject.ParamSpec) => void;
+        }
+
         // Constructor properties interface
 
         interface ConstructorProps extends GObject.Object.ConstructorProps {
@@ -1681,14 +1957,51 @@ export namespace Gegl {
         get zoom_total(): number;
         get zoomTotal(): number;
 
+        /**
+         * 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: Stats.SignalSignatures;
+
         // Constructors
 
         constructor(properties?: Partial<Stats.ConstructorProps>, ...args: any[]);
 
         _init(...args: any[]): void;
+
+        // Signals
+
+        connect<K extends keyof Stats.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, Stats.SignalSignatures[K]>,
+        ): number;
+        connect(signal: string, callback: (...args: any[]) => any): number;
+        connect_after<K extends keyof Stats.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, Stats.SignalSignatures[K]>,
+        ): number;
+        connect_after(signal: string, callback: (...args: any[]) => any): number;
+        emit<K extends keyof Stats.SignalSignatures>(
+            signal: K,
+            ...args: GObject.GjsParameters<Stats.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
+        ): void;
+        emit(signal: string, ...args: any[]): void;
     }
 
     namespace TileBackend {
+        // Signal signatures
+        interface SignalSignatures extends TileSource.SignalSignatures {
+            'notify::flush-on-destroy': (pspec: GObject.ParamSpec) => void;
+            'notify::format': (pspec: GObject.ParamSpec) => void;
+            'notify::px-size': (pspec: GObject.ParamSpec) => void;
+            'notify::tile-height': (pspec: GObject.ParamSpec) => void;
+            'notify::tile-size': (pspec: GObject.ParamSpec) => void;
+            'notify::tile-width': (pspec: GObject.ParamSpec) => void;
+        }
+
         // Constructor properties interface
 
         interface ConstructorProps extends TileSource.ConstructorProps {
@@ -1725,12 +2038,39 @@ export namespace Gegl {
         get tile_width(): number;
         get tileWidth(): number;
 
+        /**
+         * 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: TileBackend.SignalSignatures;
+
         // Constructors
 
         constructor(properties?: Partial<TileBackend.ConstructorProps>, ...args: any[]);
 
         _init(...args: any[]): void;
 
+        // Signals
+
+        connect<K extends keyof TileBackend.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, TileBackend.SignalSignatures[K]>,
+        ): number;
+        connect(signal: string, callback: (...args: any[]) => any): number;
+        connect_after<K extends keyof TileBackend.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, TileBackend.SignalSignatures[K]>,
+        ): number;
+        connect_after(signal: string, callback: (...args: any[]) => any): number;
+        emit<K extends keyof TileBackend.SignalSignatures>(
+            signal: K,
+            ...args: GObject.GjsParameters<TileBackend.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
+        ): void;
+        emit(signal: string, ...args: any[]): void;
+
         // Static methods
 
         /**
@@ -1771,6 +2111,11 @@ export namespace Gegl {
     }
 
     namespace TileHandler {
+        // Signal signatures
+        interface SignalSignatures extends TileSource.SignalSignatures {
+            'notify::source': (pspec: GObject.ParamSpec) => void;
+        }
+
         // Constructor properties interface
 
         interface ConstructorProps extends TileSource.ConstructorProps {
@@ -1786,12 +2131,39 @@ export namespace Gegl {
         get source(): GObject.Object;
         set source(val: GObject.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: TileHandler.SignalSignatures;
+
         // Constructors
 
         constructor(properties?: Partial<TileHandler.ConstructorProps>, ...args: any[]);
 
         _init(...args: any[]): void;
 
+        // Signals
+
+        connect<K extends keyof TileHandler.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, TileHandler.SignalSignatures[K]>,
+        ): number;
+        connect(signal: string, callback: (...args: any[]) => any): number;
+        connect_after<K extends keyof TileHandler.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, TileHandler.SignalSignatures[K]>,
+        ): number;
+        connect_after(signal: string, callback: (...args: any[]) => any): number;
+        emit<K extends keyof TileHandler.SignalSignatures>(
+            signal: K,
+            ...args: GObject.GjsParameters<TileHandler.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
+        ): void;
+        emit(signal: string, ...args: any[]): void;
+
         // Methods
 
         damage_rect(rect: Rectangle): void;
@@ -1799,6 +2171,9 @@ export namespace Gegl {
     }
 
     namespace TileSource {
+        // Signal signatures
+        interface SignalSignatures extends GObject.Object.SignalSignatures {}
+
         // Constructor properties interface
 
         interface ConstructorProps extends GObject.Object.ConstructorProps {}
@@ -1807,6 +2182,15 @@ export namespace Gegl {
     class TileSource extends GObject.Object {
         static $gtype: GObject.GType<TileSource>;
 
+        /**
+         * 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: TileSource.SignalSignatures;
+
         // Fields
 
         command: TileSourceCommand;
@@ -1817,6 +2201,24 @@ export namespace Gegl {
         constructor(properties?: Partial<TileSource.ConstructorProps>, ...args: any[]);
 
         _init(...args: any[]): void;
+
+        // Signals
+
+        connect<K extends keyof TileSource.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, TileSource.SignalSignatures[K]>,
+        ): number;
+        connect(signal: string, callback: (...args: any[]) => any): number;
+        connect_after<K extends keyof TileSource.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, TileSource.SignalSignatures[K]>,
+        ): number;
+        connect_after(signal: string, callback: (...args: any[]) => any): number;
+        emit<K extends keyof TileSource.SignalSignatures>(
+            signal: K,
+            ...args: GObject.GjsParameters<TileSource.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
+        ): void;
+        emit(signal: string, ...args: any[]): void;
     }
 
     type AudioFragmentClass = typeof AudioFragment;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@girs/gegl-0.3",
-  "version": "0.3.35-4.0.0-beta.21",
+  "version": "0.3.35-4.0.0-beta.24",
   "description": "GJS TypeScript type definitions for Gegl-0.3, generated from library version 0.3.35",
   "type": "module",
   "module": "gegl-0.3.js",
@@ -31,9 +31,9 @@
     "test": "tsc --project tsconfig.json"
   },
   "dependencies": {
-    "@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/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": "*"