@gtkx/ffi 0.1.46 → 0.1.48

package/dist/generated/gtk/imcontext-simple.d.ts

@@ -1,45 +1,5 @@
 import * as GObject from "../gobject/index.js";
 import { IMContext } from "./imcontext.js";
-/**
- * Supports compose sequences, dead keys and numeric Unicode input.
- *
- * ## Compose sequences
- *
- * `GtkIMContextSimple` reads compose sequences from the first of the
- * following files that is found: ~/.config/gtk-4.0/Compose, ~/.XCompose,
- * /usr/share/X11/locale/$locale/Compose (for locales that have a nontrivial
- * Compose file). A subset of the file syntax described in the Compose(5)
- * manual page is supported. Additionally, `include "%L"` loads GTK’s built-in
- * table of compose sequences rather than the locale-specific one from X11.
- *
- * If none of these files is found, `GtkIMContextSimple` uses a built-in table
- * of compose sequences that is derived from the X11 Compose files.
- *
- * Note that compose sequences typically start with the Compose_key, which is
- * often not available as a dedicated key on keyboards. Keyboard layouts may
- * map this keysym to other keys, such as the right Control key.
- *
- * ## Unicode characters
- *
- * `GtkIMContextSimple` also supports numeric entry of Unicode characters
- * by typing `Ctrl`-`Shift`-`u`, followed by a
- * hexadecimal Unicode codepoint.
- *
- * For example,
- *
- * Ctrl-Shift-u 1 2 3 Enter
- *
- * yields U+0123 LATIN SMALL LETTER G WITH CEDILLA, i.e. ģ.
- *
- * ## Dead keys
- *
- * `GtkIMContextSimple` supports dead keys. For example, typing
- *
- * dead_acute a
- *
- * yields U+00E! LATIN SMALL LETTER_A WITH ACUTE, i.e. á. Note that this
- * depends on the keyboard layout including dead keys.
- */
 export declare class IMContextSimple extends IMContext {
     /**
      * Creates a new `GtkIMContextSimple`.
@@ -51,6 +11,12 @@ export declare class IMContextSimple extends IMContext {
      * @param composeFile - The path of compose file
      */
     addComposeFile(composeFile: string): void;
+    connect(signal: "commit", handler: (self: IMContextSimple, str: string) => void, after?: boolean): number;
+    connect(signal: "delete-surrounding", handler: (self: IMContextSimple, offset: number, nChars: number) => boolean, after?: boolean): number;
+    connect(signal: "preedit-changed", handler: (self: IMContextSimple) => void, after?: boolean): number;
+    connect(signal: "preedit-end", handler: (self: IMContextSimple) => void, after?: boolean): number;
+    connect(signal: "preedit-start", handler: (self: IMContextSimple) => void, after?: boolean): number;
+    connect(signal: "retrieve-surrounding", handler: (self: IMContextSimple) => boolean, after?: boolean): number;
     connect(signal: "notify", handler: (self: IMContextSimple, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/imcontext-simple.js

@@ -41,6 +41,23 @@ import { IMContext } from "./imcontext.js";
  * yields U+00E! LATIN SMALL LETTER_A WITH ACUTE, i.e. á. Note that this
  * depends on the keyboard layout including dead keys.
  */
+const SIGNAL_META = {
+    commit: {
+        params: [{ type: { type: "string", borrowed: false } }],
+        returnType: { type: "undefined" },
+    },
+    "delete-surrounding": {
+        params: [
+            { type: { type: "int", size: 32, unsigned: false } },
+            { type: { type: "int", size: 32, unsigned: false } },
+        ],
+        returnType: { type: "boolean" },
+    },
+    "preedit-changed": { params: [], returnType: { type: "undefined" } },
+    "preedit-end": { params: [], returnType: { type: "undefined" } },
+    "preedit-start": { params: [], returnType: { type: "undefined" } },
+    "retrieve-surrounding": { params: [], returnType: { type: "boolean" } },
+};
 export class IMContextSimple extends IMContext {
     /**
      * Creates a new `GtkIMContextSimple`.
@@ -71,12 +88,24 @@ export class IMContextSimple extends IMContext {
         ], { type: "undefined" });
     }
     connect(signal, handler, after = false) {
+        const meta = SIGNAL_META[signal];
         const selfType = { type: "gobject", borrowed: true };
-        const argTypes = [selfType];
-        const returnType = undefined;
+        const argTypes = meta
+            ? [selfType, ...meta.params.map((m) => m.type)]
+            : [selfType];
+        const returnType = meta?.returnType;
         const wrappedHandler = (...args) => {
             const self = getObject(args[0], IMContextSimple);
-            return handler(self, ...args.slice(1));
+            const signalArgs = args.slice(1);
+            if (!meta)
+                return handler(self, ...signalArgs);
+            const wrapped = meta.params.map((m, i) => {
+                if (m.getCls && signalArgs[i] != null) {
+                    return getObject(signalArgs[i], m.getCls());
+                }
+                return signalArgs[i];
+            });
+            return handler(self, ...wrapped);
         };
         return call("libgtk-4.so.1", "g_signal_connect_closure", [
             { type: { type: "gobject" }, value: this.ptr },

package/dist/generated/gtk/immulticontext.d.ts

@@ -1,12 +1,5 @@
 import * as GObject from "../gobject/index.js";
 import { IMContext } from "./imcontext.js";
-/**
- * Supports switching between multiple input methods.
- *
- * Text widgets such as `GtkText` or `GtkTextView` use a `GtkIMMultiContext`
- * to implement their `im-module` property for switching between different
- * input methods.
- */
 export declare class IMMulticontext extends IMContext {
     /**
      * Creates a new `GtkIMMulticontext`.
@@ -29,6 +22,12 @@ export declare class IMMulticontext extends IMContext {
      * @param contextId - the id to use
      */
     setContextId(contextId?: string | null): void;
+    connect(signal: "commit", handler: (self: IMMulticontext, str: string) => void, after?: boolean): number;
+    connect(signal: "delete-surrounding", handler: (self: IMMulticontext, offset: number, nChars: number) => boolean, after?: boolean): number;
+    connect(signal: "preedit-changed", handler: (self: IMMulticontext) => void, after?: boolean): number;
+    connect(signal: "preedit-end", handler: (self: IMMulticontext) => void, after?: boolean): number;
+    connect(signal: "preedit-start", handler: (self: IMMulticontext) => void, after?: boolean): number;
+    connect(signal: "retrieve-surrounding", handler: (self: IMMulticontext) => boolean, after?: boolean): number;
     connect(signal: "notify", handler: (self: IMMulticontext, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/immulticontext.js

@@ -8,6 +8,23 @@ import { IMContext } from "./imcontext.js";
  * to implement their `im-module` property for switching between different
  * input methods.
  */
+const SIGNAL_META = {
+    commit: {
+        params: [{ type: { type: "string", borrowed: false } }],
+        returnType: { type: "undefined" },
+    },
+    "delete-surrounding": {
+        params: [
+            { type: { type: "int", size: 32, unsigned: false } },
+            { type: { type: "int", size: 32, unsigned: false } },
+        ],
+        returnType: { type: "boolean" },
+    },
+    "preedit-changed": { params: [], returnType: { type: "undefined" } },
+    "preedit-end": { params: [], returnType: { type: "undefined" } },
+    "preedit-start": { params: [], returnType: { type: "undefined" } },
+    "retrieve-surrounding": { params: [], returnType: { type: "boolean" } },
+};
 export class IMMulticontext extends IMContext {
     /**
      * Creates a new `GtkIMMulticontext`.
@@ -57,12 +74,24 @@ export class IMMulticontext extends IMContext {
         ], { type: "undefined" });
     }
     connect(signal, handler, after = false) {
+        const meta = SIGNAL_META[signal];
         const selfType = { type: "gobject", borrowed: true };
-        const argTypes = [selfType];
-        const returnType = undefined;
+        const argTypes = meta
+            ? [selfType, ...meta.params.map((m) => m.type)]
+            : [selfType];
+        const returnType = meta?.returnType;
         const wrappedHandler = (...args) => {
             const self = getObject(args[0], IMMulticontext);
-            return handler(self, ...args.slice(1));
+            const signalArgs = args.slice(1);
+            if (!meta)
+                return handler(self, ...signalArgs);
+            const wrapped = meta.params.map((m, i) => {
+                if (m.getCls && signalArgs[i] != null) {
+                    return getObject(signalArgs[i], m.getCls());
+                }
+                return signalArgs[i];
+            });
+            return handler(self, ...wrapped);
         };
         return call("libgtk-4.so.1", "g_signal_connect_closure", [
             { type: { type: "gobject" }, value: this.ptr },

package/dist/generated/gtk/info-bar.d.ts

@@ -1,5 +1,6 @@
-import { MessageType } from "./enums.js";
+import { DirectionType, MessageType, StateFlags, TextDirection } from "./enums.js";
 import { Button } from "./button.js";
+import { Tooltip } from "./tooltip.js";
 import * as GObject from "../gobject/index.js";
 import { Widget } from "./widget.js";
 export declare class InfoBar extends Widget {
@@ -114,6 +115,19 @@ export declare class InfoBar extends Widget {
     setShowCloseButton(setting: boolean): void;
     connect(signal: "close", handler: (self: InfoBar) => void, after?: boolean): number;
     connect(signal: "response", handler: (self: InfoBar, responseId: number) => void, after?: boolean): number;
+    connect(signal: "destroy", handler: (self: InfoBar) => void, after?: boolean): number;
+    connect(signal: "direction-changed", handler: (self: InfoBar, previousDirection: TextDirection) => void, after?: boolean): number;
+    connect(signal: "hide", handler: (self: InfoBar) => void, after?: boolean): number;
+    connect(signal: "keynav-failed", handler: (self: InfoBar, direction: DirectionType) => boolean, after?: boolean): number;
+    connect(signal: "map", handler: (self: InfoBar) => void, after?: boolean): number;
+    connect(signal: "mnemonic-activate", handler: (self: InfoBar, groupCycling: boolean) => boolean, after?: boolean): number;
+    connect(signal: "move-focus", handler: (self: InfoBar, direction: DirectionType) => void, after?: boolean): number;
+    connect(signal: "query-tooltip", handler: (self: InfoBar, x: number, y: number, keyboardMode: boolean, tooltip: Tooltip) => boolean, after?: boolean): number;
+    connect(signal: "realize", handler: (self: InfoBar) => void, after?: boolean): number;
+    connect(signal: "show", handler: (self: InfoBar) => void, after?: boolean): number;
+    connect(signal: "state-flags-changed", handler: (self: InfoBar, flags: StateFlags) => void, after?: boolean): number;
+    connect(signal: "unmap", handler: (self: InfoBar) => void, after?: boolean): number;
+    connect(signal: "unrealize", handler: (self: InfoBar) => void, after?: boolean): number;
     connect(signal: "notify", handler: (self: InfoBar, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/info-bar.js

@@ -1,6 +1,7 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { Button } from "./button.js";
+import { Tooltip } from "./tooltip.js";
 import { Widget } from "./widget.js";
 /**
  * `GtkInfoBar` can be used to show messages to the user without a dialog.
@@ -83,6 +84,42 @@ const SIGNAL_META = {
         params: [{ type: { type: "int", size: 32, unsigned: false } }],
         returnType: { type: "undefined" },
     },
+    destroy: { params: [], returnType: { type: "undefined" } },
+    "direction-changed": {
+        params: [{ type: { type: "int", size: 32, unsigned: false } }],
+        returnType: { type: "undefined" },
+    },
+    hide: { params: [], returnType: { type: "undefined" } },
+    "keynav-failed": {
+        params: [{ type: { type: "int", size: 32, unsigned: false } }],
+        returnType: { type: "boolean" },
+    },
+    map: { params: [], returnType: { type: "undefined" } },
+    "mnemonic-activate": {
+        params: [{ type: { type: "boolean" } }],
+        returnType: { type: "boolean" },
+    },
+    "move-focus": {
+        params: [{ type: { type: "int", size: 32, unsigned: false } }],
+        returnType: { type: "undefined" },
+    },
+    "query-tooltip": {
+        params: [
+            { type: { type: "int", size: 32, unsigned: false } },
+            { type: { type: "int", size: 32, unsigned: false } },
+            { type: { type: "boolean" } },
+            { type: { type: "gobject", borrowed: true }, getCls: () => Tooltip },
+        ],
+        returnType: { type: "boolean" },
+    },
+    realize: { params: [], returnType: { type: "undefined" } },
+    show: { params: [], returnType: { type: "undefined" } },
+    "state-flags-changed": {
+        params: [{ type: { type: "int", size: 32, unsigned: false } }],
+        returnType: { type: "undefined" },
+    },
+    unmap: { params: [], returnType: { type: "undefined" } },
+    unrealize: { params: [], returnType: { type: "undefined" } },
 };
 export class InfoBar extends Widget {
     /**

package/dist/generated/gtk/inscription.d.ts

@@ -1,25 +1,8 @@
-import { AccessibleTextContentChange, InscriptionOverflow } from "./enums.js";
+import { AccessibleTextContentChange, DirectionType, InscriptionOverflow, StateFlags, TextDirection } from "./enums.js";
+import { Tooltip } from "./tooltip.js";
 import * as GObject from "../gobject/index.js";
 import * as Pango from "../pango/index.js";
 import { Widget } from "./widget.js";
-/**
- * Shows text in a predefined area.
- *
- * You likely want to use `GtkLabel` instead as this widget is intended only
- * for a small subset of use cases. The main scenario envisaged is inside lists
- * such as `GtkColumnView`.
- *
- * While a `GtkLabel` sizes itself depending on the text that is displayed,
- * `GtkInscription` is given a size and inscribes the given text into that
- * space as well as it can.
- *
- * Users of this widget should take care to plan behaviour for the common case
- * where the text doesn't fit exactly in the allocated space.
- *
- * ## CSS nodes
- *
- * `GtkInscription` has a single CSS node with the name label.
- */
 export declare class Inscription extends Widget {
     /**
      * Creates a new `GtkInscription` with the given text.
@@ -184,6 +167,19 @@ export declare class Inscription extends Widget {
      * technologies.
      */
     updateSelectionBound(): void;
+    connect(signal: "destroy", handler: (self: Inscription) => void, after?: boolean): number;
+    connect(signal: "direction-changed", handler: (self: Inscription, previousDirection: TextDirection) => void, after?: boolean): number;
+    connect(signal: "hide", handler: (self: Inscription) => void, after?: boolean): number;
+    connect(signal: "keynav-failed", handler: (self: Inscription, direction: DirectionType) => boolean, after?: boolean): number;
+    connect(signal: "map", handler: (self: Inscription) => void, after?: boolean): number;
+    connect(signal: "mnemonic-activate", handler: (self: Inscription, groupCycling: boolean) => boolean, after?: boolean): number;
+    connect(signal: "move-focus", handler: (self: Inscription, direction: DirectionType) => void, after?: boolean): number;
+    connect(signal: "query-tooltip", handler: (self: Inscription, x: number, y: number, keyboardMode: boolean, tooltip: Tooltip) => boolean, after?: boolean): number;
+    connect(signal: "realize", handler: (self: Inscription) => void, after?: boolean): number;
+    connect(signal: "show", handler: (self: Inscription) => void, after?: boolean): number;
+    connect(signal: "state-flags-changed", handler: (self: Inscription, flags: StateFlags) => void, after?: boolean): number;
+    connect(signal: "unmap", handler: (self: Inscription) => void, after?: boolean): number;
+    connect(signal: "unrealize", handler: (self: Inscription) => void, after?: boolean): number;
     connect(signal: "notify", handler: (self: Inscription, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/inscription.js

@@ -1,5 +1,6 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
+import { Tooltip } from "./tooltip.js";
 import * as Pango from "../pango/index.js";
 import { Widget } from "./widget.js";
 /**
@@ -20,6 +21,44 @@ import { Widget } from "./widget.js";
  *
  * `GtkInscription` has a single CSS node with the name label.
  */
+const SIGNAL_META = {
+    destroy: { params: [], returnType: { type: "undefined" } },
+    "direction-changed": {
+        params: [{ type: { type: "int", size: 32, unsigned: false } }],
+        returnType: { type: "undefined" },
+    },
+    hide: { params: [], returnType: { type: "undefined" } },
+    "keynav-failed": {
+        params: [{ type: { type: "int", size: 32, unsigned: false } }],
+        returnType: { type: "boolean" },
+    },
+    map: { params: [], returnType: { type: "undefined" } },
+    "mnemonic-activate": {
+        params: [{ type: { type: "boolean" } }],
+        returnType: { type: "boolean" },
+    },
+    "move-focus": {
+        params: [{ type: { type: "int", size: 32, unsigned: false } }],
+        returnType: { type: "undefined" },
+    },
+    "query-tooltip": {
+        params: [
+            { type: { type: "int", size: 32, unsigned: false } },
+            { type: { type: "int", size: 32, unsigned: false } },
+            { type: { type: "boolean" } },
+            { type: { type: "gobject", borrowed: true }, getCls: () => Tooltip },
+        ],
+        returnType: { type: "boolean" },
+    },
+    realize: { params: [], returnType: { type: "undefined" } },
+    show: { params: [], returnType: { type: "undefined" } },
+    "state-flags-changed": {
+        params: [{ type: { type: "int", size: 32, unsigned: false } }],
+        returnType: { type: "undefined" },
+    },
+    unmap: { params: [], returnType: { type: "undefined" } },
+    unrealize: { params: [], returnType: { type: "undefined" } },
+};
 export class Inscription extends Widget {
     constructor(...args) {
         super(...args);
@@ -431,12 +470,24 @@ export class Inscription extends Widget {
         ], { type: "undefined" });
     }
     connect(signal, handler, after = false) {
+        const meta = SIGNAL_META[signal];
         const selfType = { type: "gobject", borrowed: true };
-        const argTypes = [selfType];
-        const returnType = undefined;
+        const argTypes = meta
+            ? [selfType, ...meta.params.map((m) => m.type)]
+            : [selfType];
+        const returnType = meta?.returnType;
         const wrappedHandler = (...args) => {
             const self = getObject(args[0], Inscription);
-            return handler(self, ...args.slice(1));
+            const signalArgs = args.slice(1);
+            if (!meta)
+                return handler(self, ...signalArgs);
+            const wrapped = meta.params.map((m, i) => {
+                if (m.getCls && signalArgs[i] != null) {
+                    return getObject(signalArgs[i], m.getCls());
+                }
+                return signalArgs[i];
+            });
+            return handler(self, ...wrapped);
         };
         return call("libgtk-4.so.1", "g_signal_connect_closure", [
             { type: { type: "gobject" }, value: this.ptr },

package/dist/generated/gtk/keyval-trigger.d.ts

@@ -1,3 +1,4 @@
+import * as GObject from "../gobject/index.js";
 import * as Gdk from "../gdk/index.js";
 import { ShortcutTrigger } from "./shortcut-trigger.js";
 /** Triggers when a specific keyval and modifiers are pressed. */
@@ -21,4 +22,6 @@ export declare class KeyvalTrigger extends ShortcutTrigger {
      * triggering @self.
      */
     getModifiers(): Gdk.ModifierType;
+    connect(signal: "notify", handler: (self: KeyvalTrigger, pspec: GObject.ParamSpec) => void, after?: boolean): number;
+    connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/keyval-trigger.js

@@ -1,4 +1,5 @@
 import { call } from "@gtkx/native";
+import { getObject } from "@gtkx/ffi";
 import { ShortcutTrigger } from "./shortcut-trigger.js";
 /** Triggers when a specific keyval and modifiers are pressed. */
 export class KeyvalTrigger extends ShortcutTrigger {
@@ -42,4 +43,22 @@ export class KeyvalTrigger extends ShortcutTrigger {
             },
         ], { type: "int", size: 32, unsigned: false });
     }
+    connect(signal, handler, after = false) {
+        const selfType = { type: "gobject", borrowed: true };
+        const argTypes = [selfType];
+        const returnType = undefined;
+        const wrappedHandler = (...args) => {
+            const self = getObject(args[0], KeyvalTrigger);
+            return handler(self, ...args.slice(1));
+        };
+        return call("libgtk-4.so.1", "g_signal_connect_closure", [
+            { type: { type: "gobject" }, value: this.ptr },
+            { type: { type: "string" }, value: signal },
+            {
+                type: { type: "callback", argTypes, returnType },
+                value: wrappedHandler,
+            },
+            { type: { type: "boolean" }, value: after },
+        ], { type: "int", size: 64, unsigned: true });
+    }
 }

package/dist/generated/gtk/label.d.ts

@@ -1,5 +1,6 @@
 import { Ref } from "@gtkx/native";
-import { AccessibleTextContentChange, Justification, MovementStep, NaturalWrapMode } from "./enums.js";
+import { AccessibleTextContentChange, DirectionType, Justification, MovementStep, NaturalWrapMode, StateFlags, TextDirection } from "./enums.js";
+import { Tooltip } from "./tooltip.js";
 import * as GObject from "../gobject/index.js";
 import * as Gio from "../gio/index.js";
 import * as Pango from "../pango/index.js";
@@ -483,6 +484,19 @@ export declare class Label extends Widget {
     connect(signal: "activate-link", handler: (self: Label, uri: string) => boolean, after?: boolean): number;
     connect(signal: "copy-clipboard", handler: (self: Label) => void, after?: boolean): number;
     connect(signal: "move-cursor", handler: (self: Label, step: MovementStep, count: number, extendSelection: boolean) => void, after?: boolean): number;
+    connect(signal: "destroy", handler: (self: Label) => void, after?: boolean): number;
+    connect(signal: "direction-changed", handler: (self: Label, previousDirection: TextDirection) => void, after?: boolean): number;
+    connect(signal: "hide", handler: (self: Label) => void, after?: boolean): number;
+    connect(signal: "keynav-failed", handler: (self: Label, direction: DirectionType) => boolean, after?: boolean): number;
+    connect(signal: "map", handler: (self: Label) => void, after?: boolean): number;
+    connect(signal: "mnemonic-activate", handler: (self: Label, groupCycling: boolean) => boolean, after?: boolean): number;
+    connect(signal: "move-focus", handler: (self: Label, direction: DirectionType) => void, after?: boolean): number;
+    connect(signal: "query-tooltip", handler: (self: Label, x: number, y: number, keyboardMode: boolean, tooltip: Tooltip) => boolean, after?: boolean): number;
+    connect(signal: "realize", handler: (self: Label) => void, after?: boolean): number;
+    connect(signal: "show", handler: (self: Label) => void, after?: boolean): number;
+    connect(signal: "state-flags-changed", handler: (self: Label, flags: StateFlags) => void, after?: boolean): number;
+    connect(signal: "unmap", handler: (self: Label) => void, after?: boolean): number;
+    connect(signal: "unrealize", handler: (self: Label) => void, after?: boolean): number;
     connect(signal: "notify", handler: (self: Label, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/label.js

@@ -1,5 +1,6 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
+import { Tooltip } from "./tooltip.js";
 import * as Gio from "../gio/index.js";
 import * as Pango from "../pango/index.js";
 import { Widget } from "./widget.js";
@@ -233,6 +234,42 @@ const SIGNAL_META = {
         ],
         returnType: { type: "undefined" },
     },
+    destroy: { params: [], returnType: { type: "undefined" } },
+    "direction-changed": {
+        params: [{ type: { type: "int", size: 32, unsigned: false } }],
+        returnType: { type: "undefined" },
+    },
+    hide: { params: [], returnType: { type: "undefined" } },
+    "keynav-failed": {
+        params: [{ type: { type: "int", size: 32, unsigned: false } }],
+        returnType: { type: "boolean" },
+    },
+    map: { params: [], returnType: { type: "undefined" } },
+    "mnemonic-activate": {
+        params: [{ type: { type: "boolean" } }],
+        returnType: { type: "boolean" },
+    },
+    "move-focus": {
+        params: [{ type: { type: "int", size: 32, unsigned: false } }],
+        returnType: { type: "undefined" },
+    },
+    "query-tooltip": {
+        params: [
+            { type: { type: "int", size: 32, unsigned: false } },
+            { type: { type: "int", size: 32, unsigned: false } },
+            { type: { type: "boolean" } },
+            { type: { type: "gobject", borrowed: true }, getCls: () => Tooltip },
+        ],
+        returnType: { type: "boolean" },
+    },
+    realize: { params: [], returnType: { type: "undefined" } },
+    show: { params: [], returnType: { type: "undefined" } },
+    "state-flags-changed": {
+        params: [{ type: { type: "int", size: 32, unsigned: false } }],
+        returnType: { type: "undefined" },
+    },
+    unmap: { params: [], returnType: { type: "undefined" } },
+    unrealize: { params: [], returnType: { type: "undefined" } },
 };
 export class Label extends Widget {
     constructor(...args) {

package/dist/generated/gtk/level-bar.d.ts

@@ -1,5 +1,6 @@
 import { Ref } from "@gtkx/native";
-import { LevelBarMode, Orientation } from "./enums.js";
+import { DirectionType, LevelBarMode, Orientation, StateFlags, TextDirection } from "./enums.js";
+import { Tooltip } from "./tooltip.js";
 import * as GObject from "../gobject/index.js";
 import { Widget } from "./widget.js";
 export declare class LevelBar extends Widget {
@@ -102,6 +103,19 @@ export declare class LevelBar extends Widget {
      */
     setOrientation(orientation: Orientation): void;
     connect(signal: "offset-changed", handler: (self: LevelBar, name: string) => void, after?: boolean): number;
+    connect(signal: "destroy", handler: (self: LevelBar) => void, after?: boolean): number;
+    connect(signal: "direction-changed", handler: (self: LevelBar, previousDirection: TextDirection) => void, after?: boolean): number;
+    connect(signal: "hide", handler: (self: LevelBar) => void, after?: boolean): number;
+    connect(signal: "keynav-failed", handler: (self: LevelBar, direction: DirectionType) => boolean, after?: boolean): number;
+    connect(signal: "map", handler: (self: LevelBar) => void, after?: boolean): number;
+    connect(signal: "mnemonic-activate", handler: (self: LevelBar, groupCycling: boolean) => boolean, after?: boolean): number;
+    connect(signal: "move-focus", handler: (self: LevelBar, direction: DirectionType) => void, after?: boolean): number;
+    connect(signal: "query-tooltip", handler: (self: LevelBar, x: number, y: number, keyboardMode: boolean, tooltip: Tooltip) => boolean, after?: boolean): number;
+    connect(signal: "realize", handler: (self: LevelBar) => void, after?: boolean): number;
+    connect(signal: "show", handler: (self: LevelBar) => void, after?: boolean): number;
+    connect(signal: "state-flags-changed", handler: (self: LevelBar, flags: StateFlags) => void, after?: boolean): number;
+    connect(signal: "unmap", handler: (self: LevelBar) => void, after?: boolean): number;
+    connect(signal: "unrealize", handler: (self: LevelBar) => void, after?: boolean): number;
     connect(signal: "notify", handler: (self: LevelBar, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/level-bar.js

@@ -1,5 +1,6 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
+import { Tooltip } from "./tooltip.js";
 import { Widget } from "./widget.js";
 /**
  * Shows a level indicator.
@@ -105,6 +106,42 @@ const SIGNAL_META = {
         params: [{ type: { type: "string", borrowed: false } }],
         returnType: { type: "undefined" },
     },
+    destroy: { params: [], returnType: { type: "undefined" } },
+    "direction-changed": {
+        params: [{ type: { type: "int", size: 32, unsigned: false } }],
+        returnType: { type: "undefined" },
+    },
+    hide: { params: [], returnType: { type: "undefined" } },
+    "keynav-failed": {
+        params: [{ type: { type: "int", size: 32, unsigned: false } }],
+        returnType: { type: "boolean" },
+    },
+    map: { params: [], returnType: { type: "undefined" } },
+    "mnemonic-activate": {
+        params: [{ type: { type: "boolean" } }],
+        returnType: { type: "boolean" },
+    },
+    "move-focus": {
+        params: [{ type: { type: "int", size: 32, unsigned: false } }],
+        returnType: { type: "undefined" },
+    },
+    "query-tooltip": {
+        params: [
+            { type: { type: "int", size: 32, unsigned: false } },
+            { type: { type: "int", size: 32, unsigned: false } },
+            { type: { type: "boolean" } },
+            { type: { type: "gobject", borrowed: true }, getCls: () => Tooltip },
+        ],
+        returnType: { type: "boolean" },
+    },
+    realize: { params: [], returnType: { type: "undefined" } },
+    show: { params: [], returnType: { type: "undefined" } },
+    "state-flags-changed": {
+        params: [{ type: { type: "int", size: 32, unsigned: false } }],
+        returnType: { type: "undefined" },
+    },
+    unmap: { params: [], returnType: { type: "undefined" } },
+    unrealize: { params: [], returnType: { type: "undefined" } },
 };
 export class LevelBar extends Widget {
     /**

package/dist/generated/gtk/link-button.d.ts

@@ -1,3 +1,5 @@
+import { DirectionType, StateFlags, TextDirection } from "./enums.js";
+import { Tooltip } from "./tooltip.js";
 import * as GObject from "../gobject/index.js";
 import { Button } from "./button.js";
 export declare class LinkButton extends Button {
@@ -44,6 +46,19 @@ export declare class LinkButton extends Button {
     connect(signal: "activate-link", handler: (self: LinkButton) => boolean, after?: boolean): number;
     connect(signal: "activate", handler: (self: LinkButton) => void, after?: boolean): number;
     connect(signal: "clicked", handler: (self: LinkButton) => void, after?: boolean): number;
+    connect(signal: "destroy", handler: (self: LinkButton) => void, after?: boolean): number;
+    connect(signal: "direction-changed", handler: (self: LinkButton, previousDirection: TextDirection) => void, after?: boolean): number;
+    connect(signal: "hide", handler: (self: LinkButton) => void, after?: boolean): number;
+    connect(signal: "keynav-failed", handler: (self: LinkButton, direction: DirectionType) => boolean, after?: boolean): number;
+    connect(signal: "map", handler: (self: LinkButton) => void, after?: boolean): number;
+    connect(signal: "mnemonic-activate", handler: (self: LinkButton, groupCycling: boolean) => boolean, after?: boolean): number;
+    connect(signal: "move-focus", handler: (self: LinkButton, direction: DirectionType) => void, after?: boolean): number;
+    connect(signal: "query-tooltip", handler: (self: LinkButton, x: number, y: number, keyboardMode: boolean, tooltip: Tooltip) => boolean, after?: boolean): number;
+    connect(signal: "realize", handler: (self: LinkButton) => void, after?: boolean): number;
+    connect(signal: "show", handler: (self: LinkButton) => void, after?: boolean): number;
+    connect(signal: "state-flags-changed", handler: (self: LinkButton, flags: StateFlags) => void, after?: boolean): number;
+    connect(signal: "unmap", handler: (self: LinkButton) => void, after?: boolean): number;
+    connect(signal: "unrealize", handler: (self: LinkButton) => void, after?: boolean): number;
     connect(signal: "notify", handler: (self: LinkButton, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }