@gtkx/ffi 0.1.47 → 0.1.48

package/dist/generated/gtk/stack-switcher.js

@@ -1,6 +1,7 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { Stack } from "./stack.js";
+import { Tooltip } from "./tooltip.js";
 import { Widget } from "./widget.js";
 /**
  * Shows a row of buttons to switch between `GtkStack` pages.
@@ -36,6 +37,44 @@ import { Widget } from "./widget.js";
  * the stack switcher to be made vertical with
  * `gtk_orientable_set_orientation()`.
  */
+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 StackSwitcher extends Widget {
     /**
      * Create a new `GtkStackSwitcher`.
@@ -108,12 +147,24 @@ export class StackSwitcher 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], StackSwitcher);
-            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/stack.d.ts

@@ -1,58 +1,9 @@
-import { StackTransitionType } from "./enums.js";
+import { DirectionType, StackTransitionType, StateFlags, TextDirection } from "./enums.js";
 import { SelectionModel } from "./selection-model.js";
 import { StackPage } from "./stack-page.js";
+import { Tooltip } from "./tooltip.js";
 import * as GObject from "../gobject/index.js";
 import { Widget } from "./widget.js";
-/**
- * Shows one of its children at a time.
- *
- *
- *
- * In contrast to `GtkNotebook`, `GtkStack` does not provide a means
- * for users to change the visible child. Instead, a separate widget
- * such as [class@Gtk.StackSwitcher] or [class@Gtk.StackSidebar] can
- * be used with `GtkStack` to provide this functionality.
- *
- * Transitions between pages can be animated as slides or fades. This
- * can be controlled with [method@Gtk.Stack.set_transition_type].
- * These animations respect the [property@Gtk.Settings:gtk-enable-animations]
- * setting.
- *
- * `GtkStack` maintains a [class@Gtk.StackPage] object for each added
- * child, which holds additional per-child properties. You
- * obtain the `GtkStackPage` for a child with [method@Gtk.Stack.get_page]
- * and you can obtain a `GtkSelectionModel` containing all the pages
- * with [method@Gtk.Stack.get_pages].
- *
- * # GtkStack as GtkBuildable
- *
- * To set child-specific properties in a .ui file, create `GtkStackPage`
- * objects explicitly, and set the child widget as a property on it:
- *
- * ```xml
- * <object class="GtkStack" id="stack">
- * <child>
- * <object class="GtkStackPage">
- * <property name="name">page1</property>
- * <property name="title">In the beginning…</property>
- * <property name="child">
- * <object class="GtkLabel">
- * <property name="label">It was dark</property>
- * </object>
- * </property>
- * </object>
- * </child>
- * ```
- *
- * # CSS nodes
- *
- * `GtkStack` has a single CSS node named stack.
- *
- * # Accessibility
- *
- * `GtkStack` uses the [enum@Gtk.AccessibleRole.tab_panel] role for the stack
- * pages, which are the accessible parent objects of the child widgets.
- */
 export declare class Stack extends Widget {
     /**
      * Creates a new `GtkStack`.
@@ -229,6 +180,19 @@ export declare class Stack extends Widget {
      * @param name - the name of the child to make visible
      */
     setVisibleChildName(name: string): void;
+    connect(signal: "destroy", handler: (self: Stack) => void, after?: boolean): number;
+    connect(signal: "direction-changed", handler: (self: Stack, previousDirection: TextDirection) => void, after?: boolean): number;
+    connect(signal: "hide", handler: (self: Stack) => void, after?: boolean): number;
+    connect(signal: "keynav-failed", handler: (self: Stack, direction: DirectionType) => boolean, after?: boolean): number;
+    connect(signal: "map", handler: (self: Stack) => void, after?: boolean): number;
+    connect(signal: "mnemonic-activate", handler: (self: Stack, groupCycling: boolean) => boolean, after?: boolean): number;
+    connect(signal: "move-focus", handler: (self: Stack, direction: DirectionType) => void, after?: boolean): number;
+    connect(signal: "query-tooltip", handler: (self: Stack, x: number, y: number, keyboardMode: boolean, tooltip: Tooltip) => boolean, after?: boolean): number;
+    connect(signal: "realize", handler: (self: Stack) => void, after?: boolean): number;
+    connect(signal: "show", handler: (self: Stack) => void, after?: boolean): number;
+    connect(signal: "state-flags-changed", handler: (self: Stack, flags: StateFlags) => void, after?: boolean): number;
+    connect(signal: "unmap", handler: (self: Stack) => void, after?: boolean): number;
+    connect(signal: "unrealize", handler: (self: Stack) => void, after?: boolean): number;
     connect(signal: "notify", handler: (self: Stack, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/stack.js

@@ -2,6 +2,7 @@ import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { SelectionModel } from "./selection-model.js";
 import { StackPage } from "./stack-page.js";
+import { Tooltip } from "./tooltip.js";
 import { Widget } from "./widget.js";
 /**
  * Shows one of its children at a time.
@@ -53,6 +54,44 @@ import { Widget } from "./widget.js";
  * `GtkStack` uses the [enum@Gtk.AccessibleRole.tab_panel] role for the stack
  * pages, which are the accessible parent objects of the child widgets.
  */
+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 Stack extends Widget {
     /**
      * Creates a new `GtkStack`.
@@ -483,12 +522,24 @@ export class Stack 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], Stack);
-            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/statusbar.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 { Widget } from "./widget.js";
 export declare class Statusbar extends Widget {
@@ -45,6 +47,19 @@ export declare class Statusbar extends Widget {
     removeAll(contextId: number): void;
     connect(signal: "text-popped", handler: (self: Statusbar, contextId: number, text: string) => void, after?: boolean): number;
     connect(signal: "text-pushed", handler: (self: Statusbar, contextId: number, text: string) => void, after?: boolean): number;
+    connect(signal: "destroy", handler: (self: Statusbar) => void, after?: boolean): number;
+    connect(signal: "direction-changed", handler: (self: Statusbar, previousDirection: TextDirection) => void, after?: boolean): number;
+    connect(signal: "hide", handler: (self: Statusbar) => void, after?: boolean): number;
+    connect(signal: "keynav-failed", handler: (self: Statusbar, direction: DirectionType) => boolean, after?: boolean): number;
+    connect(signal: "map", handler: (self: Statusbar) => void, after?: boolean): number;
+    connect(signal: "mnemonic-activate", handler: (self: Statusbar, groupCycling: boolean) => boolean, after?: boolean): number;
+    connect(signal: "move-focus", handler: (self: Statusbar, direction: DirectionType) => void, after?: boolean): number;
+    connect(signal: "query-tooltip", handler: (self: Statusbar, x: number, y: number, keyboardMode: boolean, tooltip: Tooltip) => boolean, after?: boolean): number;
+    connect(signal: "realize", handler: (self: Statusbar) => void, after?: boolean): number;
+    connect(signal: "show", handler: (self: Statusbar) => void, after?: boolean): number;
+    connect(signal: "state-flags-changed", handler: (self: Statusbar, flags: StateFlags) => void, after?: boolean): number;
+    connect(signal: "unmap", handler: (self: Statusbar) => void, after?: boolean): number;
+    connect(signal: "unrealize", handler: (self: Statusbar) => void, after?: boolean): number;
     connect(signal: "notify", handler: (self: Statusbar, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/statusbar.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";
 /**
  * A `GtkStatusbar` widget is usually placed along the bottom of an application's
@@ -54,6 +55,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 Statusbar extends Widget {
     /**

package/dist/generated/gtk/string-filter.d.ts

@@ -1,21 +1,7 @@
-import { StringFilterMatchMode } from "./enums.js";
+import { FilterChange, StringFilterMatchMode } from "./enums.js";
 import { Expression } from "./expression.js";
 import * as GObject from "../gobject/index.js";
 import { Filter } from "./filter.js";
-/**
- * Determines whether to include items by comparing strings to a fixed search term.
- *
- * The strings are obtained from the items by evaluating an expression
- * set with [method@Gtk.StringFilter.set_expression], and they are
- * compared against a search term set with [method@Gtk.StringFilter.set_search].
- *
- * `GtkStringFilter` has several different modes of comparison - it
- * can match the whole string, just a prefix, or any substring. Use
- * [method@Gtk.StringFilter.set_match_mode] choose a mode.
- *
- * It is also possible to make case-insensitive comparisons, with
- * [method@Gtk.StringFilter.set_ignore_case].
- */
 export declare class StringFilter extends Filter {
     /**
      * Creates a new string filter.
@@ -67,6 +53,7 @@ export declare class StringFilter extends Filter {
      * @param search - the string to search for
      */
     setSearch(search?: string | null): void;
+    connect(signal: "changed", handler: (self: StringFilter, change: FilterChange) => void, after?: boolean): number;
     connect(signal: "notify", handler: (self: StringFilter, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/string-filter.js

@@ -16,6 +16,12 @@ import { Filter } from "./filter.js";
  * It is also possible to make case-insensitive comparisons, with
  * [method@Gtk.StringFilter.set_ignore_case].
  */
+const SIGNAL_META = {
+    changed: {
+        params: [{ type: { type: "int", size: 32, unsigned: false } }],
+        returnType: { type: "undefined" },
+    },
+};
 export class StringFilter extends Filter {
     constructor(...args) {
         super(...args);
@@ -148,12 +154,24 @@ export class StringFilter extends Filter {
         ], { 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], StringFilter);
-            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/string-sorter.d.ts

@@ -1,17 +1,7 @@
-import { Collation } from "./enums.js";
+import { Collation, SorterChange } from "./enums.js";
 import { Expression } from "./expression.js";
 import * as GObject from "../gobject/index.js";
 import { Sorter } from "./sorter.js";
-/**
- * Sorts items by comparing strings.
- *
- * To obtain the strings to compare, this sorter evaluates a
- * [class@Gtk.Expression].
- *
- * It does the comparison in a linguistically correct way using the
- * current locale by normalizing Unicode strings and possibly case-folding
- * them before performing the comparison.
- */
 export declare class StringSorter extends Sorter {
     /**
      * Creates a new string sorter that compares items using the given
@@ -53,6 +43,7 @@ export declare class StringSorter extends Sorter {
      * @param ignoreCase - %TRUE to ignore case differences
      */
     setIgnoreCase(ignoreCase: boolean): void;
+    connect(signal: "changed", handler: (self: StringSorter, change: SorterChange) => void, after?: boolean): number;
     connect(signal: "notify", handler: (self: StringSorter, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/string-sorter.js

@@ -12,6 +12,12 @@ import { Sorter } from "./sorter.js";
  * current locale by normalizing Unicode strings and possibly case-folding
  * them before performing the comparison.
  */
+const SIGNAL_META = {
+    changed: {
+        params: [{ type: { type: "int", size: 32, unsigned: false } }],
+        returnType: { type: "undefined" },
+    },
+};
 export class StringSorter extends Sorter {
     constructor(...args) {
         super(...args);
@@ -114,12 +120,24 @@ export class StringSorter extends Sorter {
         ], { 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], StringSorter);
-            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/switch.d.ts

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

package/dist/generated/gtk/switch.js

@@ -1,5 +1,6 @@
 import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
+import { Tooltip } from "./tooltip.js";
 import * as GLib from "../glib/index.js";
 import { Widget } from "./widget.js";
 /**
@@ -47,6 +48,42 @@ const SIGNAL_META = {
         params: [{ type: { type: "boolean" } }],
         returnType: { type: "boolean" },
     },
+    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 Switch extends Widget {
     /**

package/dist/generated/gtk/text-view.d.ts

@@ -1,11 +1,12 @@
 import { Ref } from "@gtkx/native";
-import { AccessibleTextContentChange, DeleteType, InputHints, InputPurpose, Justification, MovementStep, ScrollStep, ScrollablePolicy, TextExtendSelection, TextWindowType, WrapMode } from "./enums.js";
+import { AccessibleTextContentChange, DeleteType, DirectionType, InputHints, InputPurpose, Justification, MovementStep, ScrollStep, ScrollablePolicy, StateFlags, TextDirection, TextExtendSelection, TextWindowType, WrapMode } from "./enums.js";
 import { Border } from "./border.js";
 import { TextIter } from "./text-iter.js";
 import { Adjustment } from "./adjustment.js";
 import { TextBuffer } from "./text-buffer.js";
 import { TextChildAnchor } from "./text-child-anchor.js";
 import { TextMark } from "./text-mark.js";
+import { Tooltip } from "./tooltip.js";
 import * as GObject from "../gobject/index.js";
 import * as Gdk from "../gdk/index.js";
 import * as Gio from "../gio/index.js";
@@ -782,6 +783,19 @@ export declare class TextView extends Widget {
     connect(signal: "set-anchor", handler: (self: TextView) => void, after?: boolean): number;
     connect(signal: "toggle-cursor-visible", handler: (self: TextView) => void, after?: boolean): number;
     connect(signal: "toggle-overwrite", handler: (self: TextView) => void, after?: boolean): number;
+    connect(signal: "destroy", handler: (self: TextView) => void, after?: boolean): number;
+    connect(signal: "direction-changed", handler: (self: TextView, previousDirection: TextDirection) => void, after?: boolean): number;
+    connect(signal: "hide", handler: (self: TextView) => void, after?: boolean): number;
+    connect(signal: "keynav-failed", handler: (self: TextView, direction: DirectionType) => boolean, after?: boolean): number;
+    connect(signal: "map", handler: (self: TextView) => void, after?: boolean): number;
+    connect(signal: "mnemonic-activate", handler: (self: TextView, groupCycling: boolean) => boolean, after?: boolean): number;
+    connect(signal: "move-focus", handler: (self: TextView, direction: DirectionType) => void, after?: boolean): number;
+    connect(signal: "query-tooltip", handler: (self: TextView, x: number, y: number, keyboardMode: boolean, tooltip: Tooltip) => boolean, after?: boolean): number;
+    connect(signal: "realize", handler: (self: TextView) => void, after?: boolean): number;
+    connect(signal: "show", handler: (self: TextView) => void, after?: boolean): number;
+    connect(signal: "state-flags-changed", handler: (self: TextView, flags: StateFlags) => void, after?: boolean): number;
+    connect(signal: "unmap", handler: (self: TextView) => void, after?: boolean): number;
+    connect(signal: "unrealize", handler: (self: TextView) => void, after?: boolean): number;
     connect(signal: "notify", handler: (self: TextView, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }

package/dist/generated/gtk/text-view.js

@@ -2,6 +2,7 @@ import { call } from "@gtkx/native";
 import { getObject } from "@gtkx/ffi";
 import { Adjustment } from "./adjustment.js";
 import { TextBuffer } from "./text-buffer.js";
+import { Tooltip } from "./tooltip.js";
 import * as Gio from "../gio/index.js";
 import * as Pango from "../pango/index.js";
 import { Widget } from "./widget.js";
@@ -132,6 +133,42 @@ const SIGNAL_META = {
     "set-anchor": { params: [], returnType: { type: "undefined" } },
     "toggle-cursor-visible": { params: [], returnType: { type: "undefined" } },
     "toggle-overwrite": { params: [], 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 TextView extends Widget {
     /**

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

@@ -1,7 +1,8 @@
 import { Ref } from "@gtkx/native";
-import { AccessiblePlatformState, AccessibleTextContentChange, DeleteType, InputHints, InputPurpose, MovementStep } from "./enums.js";
+import { AccessiblePlatformState, AccessibleTextContentChange, DeleteType, DirectionType, InputHints, InputPurpose, MovementStep, StateFlags, TextDirection } from "./enums.js";
 import { Editable } from "./editable.js";
 import { EntryBuffer } from "./entry-buffer.js";
+import { Tooltip } from "./tooltip.js";
 import * as GObject from "../gobject/index.js";
 import * as Gio from "../gio/index.js";
 import * as Graphene from "../graphene/index.js";
@@ -520,6 +521,19 @@ export declare class Text extends Widget {
     connect(signal: "paste-clipboard", handler: (self: Text) => void, after?: boolean): number;
     connect(signal: "preedit-changed", handler: (self: Text, preedit: string) => void, after?: boolean): number;
     connect(signal: "toggle-overwrite", handler: (self: Text) => void, after?: boolean): number;
+    connect(signal: "destroy", handler: (self: Text) => void, after?: boolean): number;
+    connect(signal: "direction-changed", handler: (self: Text, previousDirection: TextDirection) => void, after?: boolean): number;
+    connect(signal: "hide", handler: (self: Text) => void, after?: boolean): number;
+    connect(signal: "keynav-failed", handler: (self: Text, direction: DirectionType) => boolean, after?: boolean): number;
+    connect(signal: "map", handler: (self: Text) => void, after?: boolean): number;
+    connect(signal: "mnemonic-activate", handler: (self: Text, groupCycling: boolean) => boolean, after?: boolean): number;
+    connect(signal: "move-focus", handler: (self: Text, direction: DirectionType) => void, after?: boolean): number;
+    connect(signal: "query-tooltip", handler: (self: Text, x: number, y: number, keyboardMode: boolean, tooltip: Tooltip) => boolean, after?: boolean): number;
+    connect(signal: "realize", handler: (self: Text) => void, after?: boolean): number;
+    connect(signal: "show", handler: (self: Text) => void, after?: boolean): number;
+    connect(signal: "state-flags-changed", handler: (self: Text, flags: StateFlags) => void, after?: boolean): number;
+    connect(signal: "unmap", handler: (self: Text) => void, after?: boolean): number;
+    connect(signal: "unrealize", handler: (self: Text) => void, after?: boolean): number;
     connect(signal: "notify", handler: (self: Text, pspec: GObject.ParamSpec) => void, after?: boolean): number;
     connect(signal: string, handler: (...args: any[]) => any, after?: boolean): number;
 }