@girs/cogl-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/cogl-2.0)
 
 
-GJS TypeScript type definitions for Cogl-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 Cogl-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/cogl-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';
@@ -3511,6 +3513,11 @@ export namespace Cogl {
          */
         NO_ATLAS,
     }
+    namespace AtlasTexture {
+        // Signal signatures
+        interface SignalSignatures extends Object.SignalSignatures {}
+    }
+
     class AtlasTexture extends Object {
         static $gtype: GObject.GType<AtlasTexture>;
 
@@ -3532,6 +3539,29 @@ export namespace Cogl {
         static new_from_file(ctx: Context, filename: string): AtlasTexture;
 
         static new_with_size(ctx: Context, width: number, height: number): AtlasTexture;
+
+        // Signals
+
+        connect<K extends keyof AtlasTexture.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, AtlasTexture.SignalSignatures[K]>,
+        ): number;
+        connect(signal: string, callback: (...args: any[]) => any): number;
+        connect_after<K extends keyof AtlasTexture.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, AtlasTexture.SignalSignatures[K]>,
+        ): number;
+        connect_after(signal: string, callback: (...args: any[]) => any): number;
+        emit<K extends keyof AtlasTexture.SignalSignatures>(
+            signal: K,
+            ...args: GObject.GjsParameters<AtlasTexture.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
+        ): void;
+        emit(signal: string, ...args: any[]): void;
+    }
+
+    namespace Attribute {
+        // Signal signatures
+        interface SignalSignatures extends Object.SignalSignatures {}
     }
 
     class Attribute extends Object {
@@ -3583,6 +3613,24 @@ export namespace Cogl {
 
         static new_const_4x4fv(context: Context, name: string, matrix4x4: number, transpose: Bool): Attribute;
 
+        // Signals
+
+        connect<K extends keyof Attribute.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, Attribute.SignalSignatures[K]>,
+        ): number;
+        connect(signal: string, callback: (...args: any[]) => any): number;
+        connect_after<K extends keyof Attribute.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, Attribute.SignalSignatures[K]>,
+        ): number;
+        connect_after(signal: string, callback: (...args: any[]) => any): number;
+        emit<K extends keyof Attribute.SignalSignatures>(
+            signal: K,
+            ...args: GObject.GjsParameters<Attribute.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
+        ): void;
+        emit(signal: string, ...args: any[]): void;
+
         // Methods
 
         get_buffer(): AttributeBuffer;
@@ -3607,6 +3655,11 @@ export namespace Cogl {
         set_normalized(normalized: Bool): void;
     }
 
+    namespace AttributeBuffer {
+        // Signal signatures
+        interface SignalSignatures extends Object.SignalSignatures {}
+    }
+
     class AttributeBuffer extends Object {
         static $gtype: GObject.GType<AttributeBuffer>;
 
@@ -3615,6 +3668,29 @@ export namespace Cogl {
         _init(...args: any[]): void;
 
         static new_with_size(context: Context, bytes: number): AttributeBuffer;
+
+        // Signals
+
+        connect<K extends keyof AttributeBuffer.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, AttributeBuffer.SignalSignatures[K]>,
+        ): number;
+        connect(signal: string, callback: (...args: any[]) => any): number;
+        connect_after<K extends keyof AttributeBuffer.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, AttributeBuffer.SignalSignatures[K]>,
+        ): number;
+        connect_after(signal: string, callback: (...args: any[]) => any): number;
+        emit<K extends keyof AttributeBuffer.SignalSignatures>(
+            signal: K,
+            ...args: GObject.GjsParameters<AttributeBuffer.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
+        ): void;
+        emit(signal: string, ...args: any[]): void;
+    }
+
+    namespace Bitmap {
+        // Signal signatures
+        interface SignalSignatures extends Object.SignalSignatures {}
     }
 
     class Bitmap extends Object {
@@ -3646,6 +3722,24 @@ export namespace Cogl {
 
         static new_with_size(context: Context, width: number, height: number, format: PixelFormat): Bitmap;
 
+        // Signals
+
+        connect<K extends keyof Bitmap.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, Bitmap.SignalSignatures[K]>,
+        ): number;
+        connect(signal: string, callback: (...args: any[]) => any): number;
+        connect_after<K extends keyof Bitmap.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, Bitmap.SignalSignatures[K]>,
+        ): number;
+        connect_after(signal: string, callback: (...args: any[]) => any): number;
+        emit<K extends keyof Bitmap.SignalSignatures>(
+            signal: K,
+            ...args: GObject.GjsParameters<Bitmap.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
+        ): void;
+        emit(signal: string, ...args: any[]): void;
+
         // Static methods
 
         /**
@@ -3664,6 +3758,11 @@ export namespace Cogl {
         get_width(): number;
     }
 
+    namespace Context {
+        // Signal signatures
+        interface SignalSignatures extends Object.SignalSignatures {}
+    }
+
     class Context extends Object {
         static $gtype: GObject.GType<Context>;
 
@@ -3673,6 +3772,24 @@ export namespace Cogl {
 
         static ['new'](display?: Display | null): Context;
 
+        // Signals
+
+        connect<K extends keyof Context.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, Context.SignalSignatures[K]>,
+        ): number;
+        connect(signal: string, callback: (...args: any[]) => any): number;
+        connect_after<K extends keyof Context.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, Context.SignalSignatures[K]>,
+        ): number;
+        connect_after(signal: string, callback: (...args: any[]) => any): number;
+        emit<K extends keyof Context.SignalSignatures>(
+            signal: K,
+            ...args: GObject.GjsParameters<Context.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
+        ): void;
+        emit(signal: string, ...args: any[]): void;
+
         // Methods
 
         /**
@@ -3696,6 +3813,11 @@ export namespace Cogl {
         get_renderer(): Renderer;
     }
 
+    namespace Display {
+        // Signal signatures
+        interface SignalSignatures extends Object.SignalSignatures {}
+    }
+
     class Display extends Object {
         static $gtype: GObject.GType<Display>;
 
@@ -3705,6 +3827,24 @@ export namespace Cogl {
 
         static ['new'](renderer: Renderer, onscreen_template: OnscreenTemplate): Display;
 
+        // Signals
+
+        connect<K extends keyof Display.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, Display.SignalSignatures[K]>,
+        ): number;
+        connect(signal: string, callback: (...args: any[]) => any): number;
+        connect_after<K extends keyof Display.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, Display.SignalSignatures[K]>,
+        ): number;
+        connect_after(signal: string, callback: (...args: any[]) => any): number;
+        emit<K extends keyof Display.SignalSignatures>(
+            signal: K,
+            ...args: GObject.GjsParameters<Display.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
+        ): void;
+        emit(signal: string, ...args: any[]): void;
+
         // Methods
 
         /**
@@ -3749,6 +3889,11 @@ export namespace Cogl {
         setup(): Bool;
     }
 
+    namespace Fixed {
+        // Signal signatures
+        interface SignalSignatures extends GObject.Object.SignalSignatures {}
+    }
+
     /**
      * Fixed point number using a (16.16) notation.
      */
@@ -3758,6 +3903,29 @@ export namespace Cogl {
         // Constructors
 
         _init(...args: any[]): void;
+
+        // Signals
+
+        connect<K extends keyof Fixed.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, Fixed.SignalSignatures[K]>,
+        ): number;
+        connect(signal: string, callback: (...args: any[]) => any): number;
+        connect_after<K extends keyof Fixed.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, Fixed.SignalSignatures[K]>,
+        ): number;
+        connect_after(signal: string, callback: (...args: any[]) => any): number;
+        emit<K extends keyof Fixed.SignalSignatures>(
+            signal: K,
+            ...args: GObject.GjsParameters<Fixed.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
+        ): void;
+        emit(signal: string, ...args: any[]): void;
+    }
+
+    namespace FrameInfo {
+        // Signal signatures
+        interface SignalSignatures extends Object.SignalSignatures {}
     }
 
     class FrameInfo extends Object {
@@ -3767,6 +3935,24 @@ export namespace Cogl {
 
         _init(...args: any[]): void;
 
+        // Signals
+
+        connect<K extends keyof FrameInfo.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, FrameInfo.SignalSignatures[K]>,
+        ): number;
+        connect(signal: string, callback: (...args: any[]) => any): number;
+        connect_after<K extends keyof FrameInfo.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, FrameInfo.SignalSignatures[K]>,
+        ): number;
+        connect_after(signal: string, callback: (...args: any[]) => any): number;
+        emit<K extends keyof FrameInfo.SignalSignatures>(
+            signal: K,
+            ...args: GObject.GjsParameters<FrameInfo.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
+        ): void;
+        emit(signal: string, ...args: any[]): void;
+
         // Methods
 
         /**
@@ -3811,6 +3997,11 @@ export namespace Cogl {
         get_refresh_rate(): number;
     }
 
+    namespace GLES2Context {
+        // Signal signatures
+        interface SignalSignatures extends Object.SignalSignatures {}
+    }
+
     /**
      * Represents an OpenGLES 2.0 api context used as a sandbox for
      * OpenGLES 2.0 state. This is comparable to an EGLContext for those
@@ -3825,6 +4016,24 @@ export namespace Cogl {
 
         static ['new'](ctx: Context): GLES2Context;
 
+        // Signals
+
+        connect<K extends keyof GLES2Context.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, GLES2Context.SignalSignatures[K]>,
+        ): number;
+        connect(signal: string, callback: (...args: any[]) => any): number;
+        connect_after<K extends keyof GLES2Context.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, GLES2Context.SignalSignatures[K]>,
+        ): number;
+        connect_after(signal: string, callback: (...args: any[]) => any): number;
+        emit<K extends keyof GLES2Context.SignalSignatures>(
+            signal: K,
+            ...args: GObject.GjsParameters<GLES2Context.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
+        ): void;
+        emit(signal: string, ...args: any[]): void;
+
         // Methods
 
         /**
@@ -3838,6 +4047,11 @@ export namespace Cogl {
         get_vtable(): GLES2Vtable;
     }
 
+    namespace IndexBuffer {
+        // Signal signatures
+        interface SignalSignatures extends Object.SignalSignatures {}
+    }
+
     class IndexBuffer extends Object {
         static $gtype: GObject.GType<IndexBuffer>;
 
@@ -3846,6 +4060,29 @@ export namespace Cogl {
         _init(...args: any[]): void;
 
         static ['new'](context: Context, bytes: number): IndexBuffer;
+
+        // Signals
+
+        connect<K extends keyof IndexBuffer.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, IndexBuffer.SignalSignatures[K]>,
+        ): number;
+        connect(signal: string, callback: (...args: any[]) => any): number;
+        connect_after<K extends keyof IndexBuffer.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, IndexBuffer.SignalSignatures[K]>,
+        ): number;
+        connect_after(signal: string, callback: (...args: any[]) => any): number;
+        emit<K extends keyof IndexBuffer.SignalSignatures>(
+            signal: K,
+            ...args: GObject.GjsParameters<IndexBuffer.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
+        ): void;
+        emit(signal: string, ...args: any[]): void;
+    }
+
+    namespace Indices {
+        // Signal signatures
+        interface SignalSignatures extends Object.SignalSignatures {}
     }
 
     class Indices extends Object {
@@ -3859,6 +4096,24 @@ export namespace Cogl {
 
         static new_for_buffer(type: IndicesType, buffer: IndexBuffer, offset: number): Indices;
 
+        // Signals
+
+        connect<K extends keyof Indices.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, Indices.SignalSignatures[K]>,
+        ): number;
+        connect(signal: string, callback: (...args: any[]) => any): number;
+        connect_after<K extends keyof Indices.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, Indices.SignalSignatures[K]>,
+        ): number;
+        connect_after(signal: string, callback: (...args: any[]) => any): number;
+        emit<K extends keyof Indices.SignalSignatures>(
+            signal: K,
+            ...args: GObject.GjsParameters<Indices.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
+        ): void;
+        emit(signal: string, ...args: any[]): void;
+
         // Methods
 
         get_offset(): number;
@@ -3866,6 +4121,11 @@ export namespace Cogl {
         set_offset(offset: number): void;
     }
 
+    namespace MatrixStack {
+        // Signal signatures
+        interface SignalSignatures extends Object.SignalSignatures {}
+    }
+
     /**
      * Tracks your current position within a hierarchy and lets you build
      * up a graph of transformations as you traverse through a hierarchy
@@ -3908,6 +4168,24 @@ export namespace Cogl {
 
         static ['new'](ctx: Context): MatrixStack;
 
+        // Signals
+
+        connect<K extends keyof MatrixStack.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, MatrixStack.SignalSignatures[K]>,
+        ): number;
+        connect(signal: string, callback: (...args: any[]) => any): number;
+        connect_after<K extends keyof MatrixStack.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, MatrixStack.SignalSignatures[K]>,
+        ): number;
+        connect_after(signal: string, callback: (...args: any[]) => any): number;
+        emit<K extends keyof MatrixStack.SignalSignatures>(
+            signal: K,
+            ...args: GObject.GjsParameters<MatrixStack.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
+        ): void;
+        emit(signal: string, ...args: any[]): void;
+
         // Methods
 
         /**
@@ -4063,6 +4341,11 @@ export namespace Cogl {
         translate(x: number, y: number, z: number): void;
     }
 
+    namespace Object {
+        // Signal signatures
+        interface SignalSignatures extends GObject.Object.SignalSignatures {}
+    }
+
     abstract class Object {
         static $gtype: GObject.GType<Object>;
 
@@ -4070,12 +4353,35 @@ export namespace Cogl {
 
         _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;
+
         // Static methods
 
         static value_get_object(value: GObject.Value | any): any | null;
         static value_set_object(value: GObject.Value | any, object?: any | null): void;
     }
 
+    namespace Onscreen {
+        // Signal signatures
+        interface SignalSignatures extends Object.SignalSignatures {}
+    }
+
     class Onscreen extends Object implements Framebuffer {
         static $gtype: GObject.GType<Onscreen>;
 
@@ -4085,6 +4391,24 @@ export namespace Cogl {
 
         static ['new'](context: Context, width: number, height: number): Onscreen;
 
+        // Signals
+
+        connect<K extends keyof Onscreen.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, Onscreen.SignalSignatures[K]>,
+        ): number;
+        connect(signal: string, callback: (...args: any[]) => any): number;
+        connect_after<K extends keyof Onscreen.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, Onscreen.SignalSignatures[K]>,
+        ): number;
+        connect_after(signal: string, callback: (...args: any[]) => any): number;
+        emit<K extends keyof Onscreen.SignalSignatures>(
+            signal: K,
+            ...args: GObject.GjsParameters<Onscreen.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
+        ): void;
+        emit(signal: string, ...args: any[]): void;
+
         // Methods
 
         /**
@@ -5361,6 +5685,11 @@ export namespace Cogl {
         translate(x: number, y: number, z: number): void;
     }
 
+    namespace OnscreenTemplate {
+        // Signal signatures
+        interface SignalSignatures extends Object.SignalSignatures {}
+    }
+
     class OnscreenTemplate extends Object {
         static $gtype: GObject.GType<OnscreenTemplate>;
 
@@ -5370,6 +5699,24 @@ export namespace Cogl {
 
         static ['new'](swap_chain: SwapChain): OnscreenTemplate;
 
+        // Signals
+
+        connect<K extends keyof OnscreenTemplate.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, OnscreenTemplate.SignalSignatures[K]>,
+        ): number;
+        connect(signal: string, callback: (...args: any[]) => any): number;
+        connect_after<K extends keyof OnscreenTemplate.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, OnscreenTemplate.SignalSignatures[K]>,
+        ): number;
+        connect_after(signal: string, callback: (...args: any[]) => any): number;
+        emit<K extends keyof OnscreenTemplate.SignalSignatures>(
+            signal: K,
+            ...args: GObject.GjsParameters<OnscreenTemplate.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
+        ): void;
+        emit(signal: string, ...args: any[]): void;
+
         // Methods
 
         /**
@@ -5408,6 +5755,11 @@ export namespace Cogl {
         set_swap_throttled(throttled: Bool): void;
     }
 
+    namespace Output {
+        // Signal signatures
+        interface SignalSignatures extends Object.SignalSignatures {}
+    }
+
     class Output extends Object {
         static $gtype: GObject.GType<Output>;
 
@@ -5415,6 +5767,24 @@ export namespace Cogl {
 
         _init(...args: any[]): void;
 
+        // Signals
+
+        connect<K extends keyof Output.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, Output.SignalSignatures[K]>,
+        ): number;
+        connect(signal: string, callback: (...args: any[]) => any): number;
+        connect_after<K extends keyof Output.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, Output.SignalSignatures[K]>,
+        ): number;
+        connect_after(signal: string, callback: (...args: any[]) => any): number;
+        emit<K extends keyof Output.SignalSignatures>(
+            signal: K,
+            ...args: GObject.GjsParameters<Output.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
+        ): void;
+        emit(signal: string, ...args: any[]): void;
+
         // Methods
 
         /**
@@ -5470,6 +5840,11 @@ export namespace Cogl {
         get_y(): number;
     }
 
+    namespace Pipeline {
+        // Signal signatures
+        interface SignalSignatures extends Object.SignalSignatures {}
+    }
+
     class Pipeline extends Object {
         static $gtype: GObject.GType<Pipeline>;
 
@@ -5479,6 +5854,24 @@ export namespace Cogl {
 
         static ['new'](context: Context): Pipeline;
 
+        // Signals
+
+        connect<K extends keyof Pipeline.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, Pipeline.SignalSignatures[K]>,
+        ): number;
+        connect(signal: string, callback: (...args: any[]) => any): number;
+        connect_after<K extends keyof Pipeline.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, Pipeline.SignalSignatures[K]>,
+        ): number;
+        connect_after(signal: string, callback: (...args: any[]) => any): number;
+        emit<K extends keyof Pipeline.SignalSignatures>(
+            signal: K,
+            ...args: GObject.GjsParameters<Pipeline.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
+        ): void;
+        emit(signal: string, ...args: any[]): void;
+
         // Methods
 
         /**
@@ -6244,6 +6637,11 @@ export namespace Cogl {
         set_user_program(program: Handle): void;
     }
 
+    namespace PixelBuffer {
+        // Signal signatures
+        interface SignalSignatures extends Object.SignalSignatures {}
+    }
+
     class PixelBuffer extends Object {
         static $gtype: GObject.GType<PixelBuffer>;
 
@@ -6252,6 +6650,29 @@ export namespace Cogl {
         _init(...args: any[]): void;
 
         static ['new'](context: Context, size: number, data?: any | null): PixelBuffer;
+
+        // Signals
+
+        connect<K extends keyof PixelBuffer.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, PixelBuffer.SignalSignatures[K]>,
+        ): number;
+        connect(signal: string, callback: (...args: any[]) => any): number;
+        connect_after<K extends keyof PixelBuffer.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, PixelBuffer.SignalSignatures[K]>,
+        ): number;
+        connect_after(signal: string, callback: (...args: any[]) => any): number;
+        emit<K extends keyof PixelBuffer.SignalSignatures>(
+            signal: K,
+            ...args: GObject.GjsParameters<PixelBuffer.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
+        ): void;
+        emit(signal: string, ...args: any[]): void;
+    }
+
+    namespace Primitive {
+        // Signal signatures
+        interface SignalSignatures extends Object.SignalSignatures {}
     }
 
     class Primitive extends Object {
@@ -6284,6 +6705,24 @@ export namespace Cogl {
             n_attributes: number,
         ): Primitive;
 
+        // Signals
+
+        connect<K extends keyof Primitive.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, Primitive.SignalSignatures[K]>,
+        ): number;
+        connect(signal: string, callback: (...args: any[]) => any): number;
+        connect_after<K extends keyof Primitive.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, Primitive.SignalSignatures[K]>,
+        ): number;
+        connect_after(signal: string, callback: (...args: any[]) => any): number;
+        emit<K extends keyof Primitive.SignalSignatures>(
+            signal: K,
+            ...args: GObject.GjsParameters<Primitive.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
+        ): void;
+        emit(signal: string, ...args: any[]): void;
+
         // Static methods
 
         /**
@@ -6390,6 +6829,11 @@ export namespace Cogl {
         set_n_vertices(n_vertices: number): void;
     }
 
+    namespace Renderer {
+        // Signal signatures
+        interface SignalSignatures extends Object.SignalSignatures {}
+    }
+
     class Renderer extends Object {
         static $gtype: GObject.GType<Renderer>;
 
@@ -6399,6 +6843,24 @@ export namespace Cogl {
 
         static ['new'](): Renderer;
 
+        // Signals
+
+        connect<K extends keyof Renderer.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, Renderer.SignalSignatures[K]>,
+        ): number;
+        connect(signal: string, callback: (...args: any[]) => any): number;
+        connect_after<K extends keyof Renderer.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, Renderer.SignalSignatures[K]>,
+        ): number;
+        connect_after(signal: string, callback: (...args: any[]) => any): number;
+        emit<K extends keyof Renderer.SignalSignatures>(
+            signal: K,
+            ...args: GObject.GjsParameters<Renderer.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
+        ): void;
+        emit(signal: string, ...args: any[]): void;
+
         // Methods
 
         /**
@@ -6483,6 +6945,11 @@ export namespace Cogl {
         set_winsys_id(winsys_id: WinsysID | null): void;
     }
 
+    namespace Snippet {
+        // Signal signatures
+        interface SignalSignatures extends Object.SignalSignatures {}
+    }
+
     class Snippet extends Object {
         static $gtype: GObject.GType<Snippet>;
 
@@ -6492,6 +6959,24 @@ export namespace Cogl {
 
         static ['new'](hook: SnippetHook, declarations: string, post: string): Snippet;
 
+        // Signals
+
+        connect<K extends keyof Snippet.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, Snippet.SignalSignatures[K]>,
+        ): number;
+        connect(signal: string, callback: (...args: any[]) => any): number;
+        connect_after<K extends keyof Snippet.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, Snippet.SignalSignatures[K]>,
+        ): number;
+        connect_after(signal: string, callback: (...args: any[]) => any): number;
+        emit<K extends keyof Snippet.SignalSignatures>(
+            signal: K,
+            ...args: GObject.GjsParameters<Snippet.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
+        ): void;
+        emit(signal: string, ...args: any[]): void;
+
         // Methods
 
         get_declarations(): string;
@@ -6549,6 +7034,11 @@ export namespace Cogl {
         set_replace(replace: string): void;
     }
 
+    namespace SubTexture {
+        // Signal signatures
+        interface SignalSignatures extends Object.SignalSignatures {}
+    }
+
     class SubTexture extends Object {
         static $gtype: GObject.GType<SubTexture>;
 
@@ -6565,6 +7055,24 @@ export namespace Cogl {
             sub_height: number,
         ): SubTexture;
 
+        // Signals
+
+        connect<K extends keyof SubTexture.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, SubTexture.SignalSignatures[K]>,
+        ): number;
+        connect(signal: string, callback: (...args: any[]) => any): number;
+        connect_after<K extends keyof SubTexture.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, SubTexture.SignalSignatures[K]>,
+        ): number;
+        connect_after(signal: string, callback: (...args: any[]) => any): number;
+        emit<K extends keyof SubTexture.SignalSignatures>(
+            signal: K,
+            ...args: GObject.GjsParameters<SubTexture.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
+        ): void;
+        emit(signal: string, ...args: any[]): void;
+
         // Methods
 
         /**
@@ -6576,6 +7084,11 @@ export namespace Cogl {
         get_parent(): Texture;
     }
 
+    namespace SwapChain {
+        // Signal signatures
+        interface SignalSignatures extends Object.SignalSignatures {}
+    }
+
     class SwapChain extends Object {
         static $gtype: GObject.GType<SwapChain>;
 
@@ -6585,12 +7098,35 @@ export namespace Cogl {
 
         static ['new'](): SwapChain;
 
+        // Signals
+
+        connect<K extends keyof SwapChain.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, SwapChain.SignalSignatures[K]>,
+        ): number;
+        connect(signal: string, callback: (...args: any[]) => any): number;
+        connect_after<K extends keyof SwapChain.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, SwapChain.SignalSignatures[K]>,
+        ): number;
+        connect_after(signal: string, callback: (...args: any[]) => any): number;
+        emit<K extends keyof SwapChain.SignalSignatures>(
+            signal: K,
+            ...args: GObject.GjsParameters<SwapChain.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
+        ): void;
+        emit(signal: string, ...args: any[]): void;
+
         // Methods
 
         set_has_alpha(has_alpha: Bool): void;
         set_length(length: number): void;
     }
 
+    namespace Texture2D {
+        // Signal signatures
+        interface SignalSignatures extends Object.SignalSignatures {}
+    }
+
     class Texture2D extends Object implements Texture {
         static $gtype: GObject.GType<Texture2D>;
 
@@ -6621,6 +7157,24 @@ export namespace Cogl {
 
         static new_with_size(ctx: Context, width: number, height: number): Texture2D;
 
+        // Signals
+
+        connect<K extends keyof Texture2D.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, Texture2D.SignalSignatures[K]>,
+        ): number;
+        connect(signal: string, callback: (...args: any[]) => any): number;
+        connect_after<K extends keyof Texture2D.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, Texture2D.SignalSignatures[K]>,
+        ): number;
+        connect_after(signal: string, callback: (...args: any[]) => any): number;
+        emit<K extends keyof Texture2D.SignalSignatures>(
+            signal: K,
+            ...args: GObject.GjsParameters<Texture2D.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
+        ): void;
+        emit(signal: string, ...args: any[]): void;
+
         // Inherited methods
         /**
          * Explicitly allocates the storage for the given `texture` which
@@ -6851,6 +7405,11 @@ export namespace Cogl {
         ): Bool;
     }
 
+    namespace Texture2DSliced {
+        // Signal signatures
+        interface SignalSignatures extends Object.SignalSignatures {}
+    }
+
     class Texture2DSliced extends Object implements Texture {
         static $gtype: GObject.GType<Texture2DSliced>;
 
@@ -6874,6 +7433,24 @@ export namespace Cogl {
 
         static new_with_size(ctx: Context, width: number, height: number, max_waste: number): Texture2DSliced;
 
+        // Signals
+
+        connect<K extends keyof Texture2DSliced.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, Texture2DSliced.SignalSignatures[K]>,
+        ): number;
+        connect(signal: string, callback: (...args: any[]) => any): number;
+        connect_after<K extends keyof Texture2DSliced.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, Texture2DSliced.SignalSignatures[K]>,
+        ): number;
+        connect_after(signal: string, callback: (...args: any[]) => any): number;
+        emit<K extends keyof Texture2DSliced.SignalSignatures>(
+            signal: K,
+            ...args: GObject.GjsParameters<Texture2DSliced.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
+        ): void;
+        emit(signal: string, ...args: any[]): void;
+
         // Inherited methods
         /**
          * Explicitly allocates the storage for the given `texture` which
@@ -7104,6 +7681,11 @@ export namespace Cogl {
         ): Bool;
     }
 
+    namespace Texture3D {
+        // Signal signatures
+        interface SignalSignatures extends Object.SignalSignatures {}
+    }
+
     class Texture3D extends Object implements Texture {
         static $gtype: GObject.GType<Texture3D>;
 
@@ -7126,6 +7708,24 @@ export namespace Cogl {
 
         static new_with_size(context: Context, width: number, height: number, depth: number): Texture3D;
 
+        // Signals
+
+        connect<K extends keyof Texture3D.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, Texture3D.SignalSignatures[K]>,
+        ): number;
+        connect(signal: string, callback: (...args: any[]) => any): number;
+        connect_after<K extends keyof Texture3D.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, Texture3D.SignalSignatures[K]>,
+        ): number;
+        connect_after(signal: string, callback: (...args: any[]) => any): number;
+        emit<K extends keyof Texture3D.SignalSignatures>(
+            signal: K,
+            ...args: GObject.GjsParameters<Texture3D.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
+        ): void;
+        emit(signal: string, ...args: any[]): void;
+
         // Inherited methods
         /**
          * Explicitly allocates the storage for the given `texture` which
@@ -7356,6 +7956,11 @@ export namespace Cogl {
         ): Bool;
     }
 
+    namespace TexturePixmapX11 {
+        // Signal signatures
+        interface SignalSignatures extends Object.SignalSignatures {}
+    }
+
     class TexturePixmapX11 extends Object {
         static $gtype: GObject.GType<TexturePixmapX11>;
 
@@ -7367,6 +7972,24 @@ export namespace Cogl {
 
         static new_left(context: Context, pixmap: number, automatic_updates: Bool): TexturePixmapX11;
 
+        // Signals
+
+        connect<K extends keyof TexturePixmapX11.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, TexturePixmapX11.SignalSignatures[K]>,
+        ): number;
+        connect(signal: string, callback: (...args: any[]) => any): number;
+        connect_after<K extends keyof TexturePixmapX11.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, TexturePixmapX11.SignalSignatures[K]>,
+        ): number;
+        connect_after(signal: string, callback: (...args: any[]) => any): number;
+        emit<K extends keyof TexturePixmapX11.SignalSignatures>(
+            signal: K,
+            ...args: GObject.GjsParameters<TexturePixmapX11.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
+        ): void;
+        emit(signal: string, ...args: any[]): void;
+
         // Static methods
 
         static error_quark(): number;
@@ -7406,6 +8029,11 @@ export namespace Cogl {
         update_area(x: number, y: number, width: number, height: number): void;
     }
 
+    namespace TextureRectangle {
+        // Signal signatures
+        interface SignalSignatures extends Object.SignalSignatures {}
+    }
+
     class TextureRectangle extends Object implements Texture {
         static $gtype: GObject.GType<TextureRectangle>;
 
@@ -7425,6 +8053,24 @@ export namespace Cogl {
 
         static new_with_size(ctx: Context, width: number, height: number): TextureRectangle;
 
+        // Signals
+
+        connect<K extends keyof TextureRectangle.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, TextureRectangle.SignalSignatures[K]>,
+        ): number;
+        connect(signal: string, callback: (...args: any[]) => any): number;
+        connect_after<K extends keyof TextureRectangle.SignalSignatures>(
+            signal: K,
+            callback: GObject.SignalCallback<this, TextureRectangle.SignalSignatures[K]>,
+        ): number;
+        connect_after(signal: string, callback: (...args: any[]) => any): number;
+        emit<K extends keyof TextureRectangle.SignalSignatures>(
+            signal: K,
+            ...args: GObject.GjsParameters<TextureRectangle.SignalSignatures[K]> extends [any, ...infer Q] ? Q : never
+        ): void;
+        emit(signal: string, ...args: any[]): void;
+
         // Inherited methods
         /**
          * Explicitly allocates the storage for the given `texture` which

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@girs/cogl-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 Cogl-2.0, generated from library version 2.0.0",
   "type": "module",
   "module": "cogl-2.0.js",
@@ -31,10 +31,10 @@
     "test": "tsc --project tsconfig.json"
   },
   "dependencies": {
-    "@girs/gjs": "^4.0.0-beta.21",
-    "@girs/gl-1.0": "^1.0.0-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/gl-1.0": "^1.0.0-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": "*"